Files
persionalBrand/packages/template-contract/test/preview-target.test.mjs

134 lines
5.5 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 })),
);
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",
);
});
}