@wocart/theme 1.6.0 → 2.0.0

package/dist/instances.js

@@ -8,7 +8,9 @@
  * → `content[contentKey]` → `field.default` → omit (the component's own
  * default applies last).
  */
+import { THEME_LIMITS, completeRequired, resolveFixed, slotCap } from "./blocks.js";
 import { localize } from "./locales.js";
+import { COLOR_SCHEME_ID_PATTERN, colorSchemesProblem, styleValueProblem } from "./style.js";
 import { isRichTextDocumentShape, richTextProblem } from "./rich-text.js";
 import { COLLECTION_HANDLE_PATTERN, COLOR_PATTERN, MEDIA_KEY_PATTERN, MENU_HANDLE_PATTERN, RESOURCE_HANDLE_PATTERN, isLocaleMap, isLocaleMapOf, isSafeLinkTarget, } from "./schemas.js";
 /**
@@ -49,9 +51,9 @@ export function resolveInstance(definition, instance, scope = {}) {
     const slotDefinitions = new Map((definition.slots ?? []).map((slot) => [slot.name, slot]));
     const fromChildren = instance.children ?? [];
     const fromDefaultSlot = instance.slots?.default ?? [];
+    const defaultSlot = slotDefinitions.get("default");
     let children = [];
     if (fromChildren.length + fromDefaultSlot.length > 0) {
-        const defaultSlot = slotDefinitions.get("default");
         if (defaultSlot === undefined) {
             issues.push({
                 path: "children",
@@ -67,6 +69,8 @@ export function resolveInstance(definition, instance, scope = {}) {
             children = applyMultiple(defaultSlot, accepted, "children", issues);
         }
     }
+    if (defaultSlot !== undefined)
+        children = completeSlot(defaultSlot, children, instance.id, "children", issues);
     const slots = {};
     for (const [name, list] of Object.entries(instance.slots ?? {})) {
         if (name === "default") {
@@ -82,9 +86,25 @@ export function resolveInstance(definition, instance, scope = {}) {
             continue;
         }
         const accepted = filterAllowed(slotDefinition, list, `slots.${name}`, issues);
-        slots[name] = applyMultiple(slotDefinition, accepted, `slots.${name}`, issues);
+        slots[name] = completeSlot(slotDefinition, applyMultiple(slotDefinition, accepted, `slots.${name}`, issues), instance.id, `slots.${name}`, issues);
     }
-    return { props, children, slots, issues };
+    for (const slotDefinition of definition.slots ?? []) {
+        const { name } = slotDefinition;
+        if (name === "default" || Object.hasOwn(slots, name) || (slotDefinition.required ?? []).length === 0)
+            continue;
+        slots[name] = completeSlot(slotDefinition, [], instance.id, `slots.${name}`, issues);
+    }
+    return { props, children, slots, fixed: resolveFixed(definition, instance, issues), issues };
+}
+/** A slot's list as it renders: at most its cap, then every required type present. */
+function completeSlot(slot, list, ownerId, path, issues) {
+    const cap = slotCap(slot, THEME_LIMITS.slotInstances);
+    let kept = list;
+    if (list.length > cap) {
+        issues.push({ path, code: "limit-exceeded", message: `slot "${slot.name}" holds at most ${cap} instances; ${list.length - cap} dropped` });
+        kept = list.slice(0, cap);
+    }
+    return completeRequired(kept, slot.required, { id: ownerId, slot: slot.name }, path, issues);
 }
 /** Whether a field shows something with no stored value: a default, or content-pack text. */
 export function hasFallback(field) {
@@ -381,6 +401,37 @@ function mediaReferenceProblem(value, mode) {
     }
     return null;
 }
+/** The most handles a `productList` or `collectionList` holds. */
+export const HANDLE_LIST_MAX = 50;
+/** Why `value` is not a list of distinct handles within `min` and `max`, or `null`. */
+export function handleListProblem(kind, min, max, value) {
+    const noun = kind === "productList" ? "product handles" : "collection handles";
+    if (!Array.isArray(value))
+        return `must be a list of ${noun}`;
+    const cap = Math.min(max ?? HANDLE_LIST_MAX, HANDLE_LIST_MAX);
+    if (value.length > cap)
+        return `holds at most ${cap} ${noun}`;
+    if (min !== undefined && value.length < min)
+        return `needs at least ${min} ${noun}`;
+    const pattern = kind === "productList" ? RESOURCE_HANDLE_PATTERN : COLLECTION_HANDLE_PATTERN;
+    const seen = new Set();
+    for (const [index, handle] of value.entries()) {
+        if (typeof handle !== "string" || !pattern.test(handle))
+            return `item ${index} is not a ${kind === "productList" ? "product" : "collection"} handle`;
+        if (seen.has(handle))
+            return `item ${index} repeats "${handle}"`;
+        seen.add(handle);
+    }
+    return null;
+}
+/** Why a rich-text document is not one line — a single paragraph — or `null`. */
+function inlineProblem(value) {
+    const content = isRecord(value) ? value.content : undefined;
+    if (!Array.isArray(content) || content.length > 1 || content.some((block) => !isRecord(block) || block.type !== "paragraph")) {
+        return "must be one line: a single paragraph, no headings or lists";
+    }
+    return null;
+}
 /** On a grid of `step` from `base`, allowing for binary floating point. */
 export function onStepGrid(value, base, step) {
     const steps = (value - base) / step;
@@ -448,7 +499,12 @@ function checkKindValue(field, value, mode) {
             return problem === null ? { ok: true, value } : { ok: false, message: problem };
         }
         case "richtext": {
-            const problem = richTextProblem(value, field.formats);
+            const problem = richTextProblem(value, field.formats) ?? (field.inline === true ? inlineProblem(value) : null);
+            return problem === null ? { ok: true, value } : { ok: false, message: problem };
+        }
+        case "productList":
+        case "collectionList": {
+            const problem = handleListProblem(field.kind, field.min, field.max, value);
             return problem === null ? { ok: true, value } : { ok: false, message: problem };
         }
         case "list":
@@ -460,6 +516,18 @@ function checkKindValue(field, value, mode) {
                     ok: false,
                     message: `must be one of ${field.options.map((option) => JSON.stringify(option)).join(", ")}`,
                 };
+        case "style": {
+            const problem = styleValueProblem(field.panels, value);
+            return problem === null ? { ok: true, value } : { ok: false, message: problem };
+        }
+        case "colorScheme":
+            return typeof value === "string" && COLOR_SCHEME_ID_PATTERN.test(value)
+                ? { ok: true, value }
+                : { ok: false, message: "must be a color scheme id: lowercase letters, digits and dashes" };
+        case "colorSchemes": {
+            const problem = colorSchemesProblem(value);
+            return problem === null ? { ok: true, value } : { ok: false, message: problem };
+        }
     }
 }
 /** A slot's `allow` list keeps the permitted types and reports every other child. */

package/dist/manifest-diff.js

@@ -28,14 +28,35 @@ export function diffThemeManifests(previous, next) {
         const after = nextSurfaces.get(surface.key);
         if (after === undefined)
             breaking(`surfaces.${surface.key}`, `surface "${surface.key}" was removed`);
-        else if (after.pageType !== surface.pageType) {
-            breaking(`surfaces.${surface.key}.pageType`, `surface "${surface.key}" renders "${after.pageType ?? "no page type"}" instead of "${surface.pageType ?? "no page type"}"`);
+        else {
+            if (after.pageType !== surface.pageType) {
+                breaking(`surfaces.${surface.key}.pageType`, `surface "${surface.key}" renders "${after.pageType ?? "no page type"}" instead of "${surface.pageType ?? "no page type"}"`);
+            }
+            compareCaps(surface, after, `surfaces.${surface.key}`, "sections", breaking, additive);
         }
     }
     for (const surface of next.surfaces) {
         if (!previous.surfaces.some((before) => before.key === surface.key))
             additive(`surfaces.${surface.key}`, `surface "${surface.key}" was added`);
     }
+    for (const area of previous.areas) {
+        const after = next.areas.find((candidate) => candidate.key === area.key);
+        if (after === undefined)
+            breaking(`areas.${area.key}`, `area "${area.key}" was removed: its saved document no longer renders`);
+        else
+            compareCaps(area, after, `areas.${area.key}`, "sections", breaking, additive);
+    }
+    for (const area of next.areas) {
+        if (!previous.areas.some((before) => before.key === area.key))
+            additive(`areas.${area.key}`, `area "${area.key}" was added`);
+    }
+    for (const scale of ["spacing", "widths"]) {
+        const after = next.style?.[scale] ?? {};
+        for (const key of Object.keys(previous.style?.[scale] ?? {})) {
+            if (!Object.hasOwn(after, key))
+                breaking(`style.${scale}.${key}`, `the theme no longer gives "${key}" a size: saved styles using it show none`);
+        }
+    }
     const settingFields = (manifest) => manifest.settings.flatMap((group) => group.fields);
     compareFields(settingFields(previous), settingFields(next), "settings", breaking, additive);
     for (const [locale, pack] of Object.entries(previous.content)) {
@@ -74,6 +95,29 @@ function compareComponents(previous, next, path, breaking, additive) {
         if (!previous.slots.some((before) => before.name === slot.name))
             additive(`${path}.slots.${slot.name}`, `slot "${slot.name}" was added`);
     }
+    const nextFixed = new Map((next.fixed ?? []).map((block) => [block.name, block]));
+    for (const block of previous.fixed ?? []) {
+        const after = nextFixed.get(block.name);
+        if (after === undefined)
+            breaking(`${path}.fixed.${block.name}`, `fixed block "${block.name}" was removed: its saved values are ignored`);
+        else if (after.type !== block.type)
+            breaking(`${path}.fixed.${block.name}.type`, `fixed block "${block.name}" is now a "${after.type}", not a "${block.type}": its saved values are ignored`);
+    }
+    for (const block of next.fixed ?? []) {
+        if (!(previous.fixed ?? []).some((before) => before.name === block.name))
+            additive(`${path}.fixed.${block.name}`, `fixed block "${block.name}" was added`);
+    }
+}
+/** A list's cap and required types: a lower cap hides saved instances; a new requirement only adds. */
+function compareCaps(previous, next, path, what, breaking, additive) {
+    if (next.max !== undefined && (previous.max === undefined || next.max < previous.max)) {
+        breaking(`${path}.max`, `now holds at most ${next.max} ${what}: saved ones past it are not rendered`);
+    }
+    for (const entry of next.required ?? []) {
+        if (!(previous.required ?? []).some((before) => before.type === entry.type)) {
+            additive(`${path}.required`, `"${entry.type}" is now required: a saved document that lacks it gains one`);
+        }
+    }
 }
 function compareSlots(previous, next, path, breaking, additive) {
     if (previous.multiple !== false && next.multiple === false) {
@@ -95,6 +139,7 @@ function compareSlots(previous, next, path, breaking, additive) {
     else if (previous.allow !== undefined) {
         additive(`${path}.allow`, "the slot now accepts any component");
     }
+    compareCaps(previous, next, path, "instances", breaking, additive);
 }
 function compareFields(previous, next, path, breaking, additive) {
     const nextFields = new Map(next.map((field) => [field.key, field]));
@@ -150,6 +195,22 @@ function compareKindRules(previous, next, path, breaking, additive) {
         else if (removed !== undefined && removed.length > 0)
             breaking(`${path}.formats`, `the field no longer allows ${removed.join(", ")}`);
     }
+    if ((previous.kind === "productList" || previous.kind === "collectionList") && next.kind === previous.kind) {
+        const before = previous;
+        const after = next;
+        if (after.max !== undefined && (before.max === undefined || after.max < before.max))
+            breaking(`${path}.max`, `the list now holds at most ${after.max}`);
+        if (after.min !== undefined && (before.min === undefined || after.min > before.min))
+            breaking(`${path}.min`, `the list now needs at least ${after.min}`);
+    }
+    if (previous.kind === "richtext" && next.kind === "richtext" && next.inline === true && previous.inline !== true) {
+        breaking(`${path}.inline`, "the field is now one line: saved text with several paragraphs, headings or lists no longer reads");
+    }
+    if (previous.kind === "style" && next.kind === "style") {
+        const removed = previous.panels.filter((panel) => !next.panels.includes(panel));
+        if (removed.length > 0)
+            breaking(`${path}.panels`, `the field no longer offers ${removed.join(", ")}: saved values for it are ignored`);
+    }
     if (previous.kind === "list" && next.kind === "list") {
         if (next.max !== undefined && (previous.max === undefined || next.max < previous.max))
             breaking(`${path}.max`, `the list now holds at most ${next.max} items`);