122 lines
4.9 KiB
JavaScript
122 lines
4.9 KiB
JavaScript
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 })),
|
|
);
|
|
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(
|
|
section.previewTargets?.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(
|
|
section.previewTargets?.some(
|
|
(candidate) => candidate.key === child && !candidate.composite,
|
|
),
|
|
`${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),
|
|
`${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",
|
|
);
|
|
});
|
|
}
|