import assert from "node:assert/strict"; import fs from "node:fs"; import path from "node:path"; import test from "node:test"; import { fileURLToPath } from "node:url"; const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../.."); const templateDirectories = fs .readdirSync(path.join(root, "packages")) .filter( (directory) => directory.startsWith("template-") && fs.existsSync(path.join(root, "packages", directory, "template.json")), ); for (const directory of templateDirectories) { const manifest = JSON.parse( fs.readFileSync(path.join(root, "packages", directory, "template.json"), "utf8"), ); const rendererPath = path.join(root, "packages", directory, "taro/index.tsx"); test(`${manifest.packageKey} preview targets match manifest and renderer`, () => { const sections = manifest.admin.sections; const targets = sections.flatMap((section) => (section.previewTargets ?? []).map((target) => ({ ...target, page: section.page, section })), ); for (const declaration of manifest.trustContentTypes ?? []) for (const target of declaration.previewTargets ?? []) targets.push({ ...target, page: declaration.pages?.[0] ?? "home", section: { fields: declaration.configFields ?? [] }, }); const keys = targets.map((target) => target.key); assert.equal(new Set(keys).size, keys.length, "preview target keys must be unique"); for (const section of sections) { for (const field of section.fields) { assert.ok(field.binding, `${section.key}.${field.key} must have an editable binding`); assert.ok(field.previewTarget, `${section.key}.${field.key} must map to a visual region`); assert.ok( targets.some((target) => target.key === field.previewTarget), `${section.key}.${field.key} references an undeclared previewTarget`, ); } for (const target of section.previewTargets ?? []) { if (target.composite) { assert.ok( Array.isArray(target.children) && target.children.length > 0, `${target.key} composite target must declare child targets`, ); for (const child of target.children) assert.ok( targets.some((candidate) => candidate.key === child && !candidate.composite) || (child.startsWith("trust:") && (manifest.trustContentTypes ?? []).some( (declaration) => `trust:${declaration.type}` === child, )), `${target.key} references missing or composite child ${child}`, ); assert.ok( !section.fields.some((field) => field.previewTarget === target.key), `${target.key} composite target must not duplicate editable fields`, ); } } } for (const field of manifest.templateFields ?? []) { assert.ok(field.binding, `templateFields.${field.key} must have an editable binding`); assert.ok(field.previewTarget, `templateFields.${field.key} must map to a visual region`); assert.ok( targets.some((target) => target.key === field.previewTarget), `templateFields.${field.key} references an undeclared previewTarget`, ); assert.ok(rendererPath && fs.existsSync(rendererPath)); } for (const target of targets) if (!target.composite) assert.ok( target.section.fields.some((field) => field.previewTarget === target.key) || (manifest.trustContentTypes ?? []).some((declaration) => (declaration.configFields ?? []).some((field) => field.previewTarget === target.key), ), `${target.key} must map to at least one editable field`, ); if (!targets.length) return; assert.ok(fs.existsSync(rendererPath), "templates with preview targets need a Taro renderer"); const renderer = fs.readFileSync(rendererPath, "utf8"); for (const target of targets) assert.ok( renderer.includes(`data-editor-target="${target.key}"`) || renderer.includes(`data-editor-target={\`${target.key}`) || renderer.includes(`data-editor-target={formTargets[`), `renderer is missing data-editor-target ${target.key}`, ); assert.ok(renderer.includes("data-editor-target"), "renderer must expose editor targets"); const hasDynamicTrustTarget = /data-editor-target=\{`trust:\$\{item\.type\}`\}/.test(renderer); const literalRendererTargets = new Set( [...renderer.matchAll(/data-editor-target="([^"]+)"/g)] .map((match) => match[1]) .filter((key) => !key.startsWith("trust:")), ); for (const renderedKey of literalRendererTargets) assert.ok( keys.includes(renderedKey), `renderer target ${renderedKey} is missing from manifest`, ); const concreteTrustTypes = new Set( [...literalRendererTargets] .filter((key) => key.startsWith("trust:")) .map((key) => key.slice("trust:".length)), ); for (const type of concreteTrustTypes) { const key = `trust:${type}`; assert.ok( (manifest.trustContentTypes ?? []).some((item) => item.type === type), `renderer trust target ${key} has no trust type declaration`, ); assert.ok( targets.some((target) => target.key === key), `renderer trust target ${key} is missing from Admin declarations`, ); } if (hasDynamicTrustTarget) assert.ok( manifest.trustContentTypes?.length, "dynamic trust targets need trust type declarations", ); }); }