@shop-on/theme-contract 0.4.0 → 0.6.0

package/dist/ops.js

@@ -0,0 +1,442 @@
+import { STORE_SLUG_RE, invalidTemplateId } from "./store-path.js";
+import { z } from "zod";
+//#region src/ops.ts
+const MAX_PATH_DEPTH = 24;
+const MAX_SEGMENT_LENGTH = 64;
+const MAX_BATCH_OPS = 200;
+const MAX_BATCH_BYTES = 65536;
+const ROOT_FIELDS = {
+	settings: "settings",
+	template: "templates",
+	group: "groups"
+};
+const FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/** Template keys the store carries beside the document; the server never holds them. */
+const TEMPLATE_NON_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["section_groups"]);
+/** A group's document is exactly these; `name`, `type`, `defaults` are not. */
+const GROUP_DOCUMENT_KEYS = /* @__PURE__ */ new Set(["sections", "order"]);
+function isPlainObject(x) {
+	if (x === null || typeof x !== "object" || Array.isArray(x)) return false;
+	const proto = Object.getPrototypeOf(x);
+	return proto === Object.prototype || proto === null;
+}
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((x, i) => deepEqual(x, b[i]));
+	}
+	if (isPlainObject(a)) {
+		if (!isPlainObject(b)) return false;
+		const ka = Object.keys(a);
+		if (ka.length !== Object.keys(b).length) return false;
+		return ka.every((k) => Object.hasOwn(b, k) && deepEqual(a[k], b[k]));
+	}
+	return false;
+}
+/** Where an op lands relative to the order-bearing containers it passes. */
+function shapeOf(p) {
+	if (p[0] === "settings") return { kind: "settings" };
+	if (p.length === 2) return { kind: "entry" };
+	let container = {
+		path: p.slice(0, 2),
+		childKey: "sections",
+		orderKey: "order"
+	};
+	let i = 2;
+	for (;;) {
+		const seg = p[i];
+		const last = i === p.length - 1;
+		if (seg === container.orderKey && last) return {
+			kind: "order",
+			container
+		};
+		if (seg === container.childKey) {
+			if (last) return {
+				kind: "children",
+				container
+			};
+			const childId = p[i + 1];
+			if (i + 2 === p.length) return {
+				kind: "child",
+				container,
+				childId
+			};
+			container = {
+				path: p.slice(0, i + 2),
+				childKey: "blocks",
+				orderKey: "block_order"
+			};
+			i += 2;
+			continue;
+		}
+		return {
+			kind: "field",
+			container
+		};
+	}
+}
+function toDocPath(p) {
+	const field = ROOT_FIELDS[p[0]];
+	if (!field || p.length < 2) return null;
+	return [field, ...p.slice(1)];
+}
+function getAt(root, docPath) {
+	let node = root;
+	for (const seg of docPath) {
+		if (!isPlainObject(node) || !Object.hasOwn(node, seg)) return { found: false };
+		node = node[seg];
+	}
+	return {
+		found: true,
+		value: node
+	};
+}
+const UNCHANGED = Symbol("unchanged");
+/** `createMap`: a child set may create its missing parent `sections` / `blocks` map. */
+function writeAt(node, docPath, i, op, createMap) {
+	if (!isPlainObject(node)) return UNCHANGED;
+	const key = docPath[i];
+	if (i === docPath.length - 1) {
+		if (Object.hasOwn(op, "v")) {
+			if (Object.hasOwn(node, key) && node[key] === op.v) return UNCHANGED;
+			return {
+				...node,
+				[key]: op.v
+			};
+		}
+		if (!Object.hasOwn(node, key)) return UNCHANGED;
+		const { [key]: _removed, ...rest } = node;
+		return rest;
+	}
+	const missing = !Object.hasOwn(node, key);
+	if (missing && !(createMap && i === docPath.length - 2)) return UNCHANGED;
+	const child = writeAt(missing ? {} : node[key], docPath, i + 1, op, createMap);
+	if (child === UNCHANGED) return UNCHANGED;
+	return {
+		...node,
+		[key]: child
+	};
+}
+function applyOne(doc, op) {
+	if (op.p.some((seg) => FORBIDDEN_KEYS.has(seg))) return doc;
+	const docPath = toDocPath(op.p);
+	if (!docPath) return doc;
+	const out = writeAt(doc, docPath, 0, op, Object.hasOwn(op, "v") && shapeOf(op.p).kind === "child");
+	return out === UNCHANGED ? doc : out;
+}
+const pathKey = (p) => p.join("\0");
+function isPrefix(prefix, p) {
+	return prefix.length <= p.length && prefix.every((seg, i) => seg === p[i]);
+}
+/**
+* Applies a batch copy-on-write along each op's path, then normalises every
+* container the batch touched: drops order ids with no node, strips static
+* block ids, and re-appends ids that were in that order when the batch began,
+* still have a node and were not deleted by the batch. Ids never in the prior
+* order stay out: presets hide content by omitting it from `order`.
+*/
+function applyOps(doc, ops) {
+	if (ops.length === 0) return doc;
+	const touched = /* @__PURE__ */ new Map();
+	const deleted = /* @__PURE__ */ new Set();
+	const wholeSets = [];
+	const touch = (container) => {
+		const key = pathKey(container.path);
+		if (!touched.has(key)) touched.set(key, {
+			container,
+			prior: null,
+			replaced: false
+		});
+	};
+	for (const op of ops) {
+		const isSet = Object.hasOwn(op, "v");
+		const shape = shapeOf(op.p);
+		if (shape.kind === "settings" || shape.kind === "field") continue;
+		if (shape.kind === "entry") {
+			if (isSet) {
+				wholeSets.push(op.p);
+				touch({
+					path: op.p,
+					childKey: "sections",
+					orderKey: "order"
+				});
+			}
+			continue;
+		}
+		touch(shape.container);
+		if (shape.kind === "child") {
+			const childPath = [
+				...shape.container.path,
+				shape.container.childKey,
+				shape.childId
+			];
+			if (isSet) {
+				wholeSets.push(childPath);
+				touch({
+					path: childPath,
+					childKey: "blocks",
+					orderKey: "block_order"
+				});
+			} else deleted.add(pathKey(childPath));
+		}
+	}
+	for (const t of touched.values()) {
+		t.replaced = wholeSets.some((set) => isPrefix(set, t.container.path));
+		if (t.replaced) continue;
+		const docPath = toDocPath(t.container.path);
+		const node = docPath ? getAt(doc, docPath) : { found: false };
+		if (node.found && isPlainObject(node.value) && Array.isArray(node.value[t.container.orderKey])) t.prior = node.value[t.container.orderKey];
+	}
+	let out = doc;
+	for (const op of ops) out = applyOne(out, op);
+	for (const t of touched.values()) out = normalise(out, t, deleted);
+	return out;
+}
+function normalise(doc, t, deleted) {
+	const { path, childKey, orderKey } = t.container;
+	const docPath = toDocPath(path);
+	if (!docPath) return doc;
+	const node = getAt(doc, docPath);
+	if (!node.found || !isPlainObject(node.value)) return doc;
+	const order = node.value[orderKey];
+	if (!Array.isArray(order)) return doc;
+	const children = isPlainObject(node.value[childKey]) ? node.value[childKey] : {};
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	const keep = (id) => typeof id === "string" && !seen.has(id) && Object.hasOwn(children, id) && isPlainObject(children[id]) && children[id].static !== true;
+	for (const id of order) if (keep(id)) {
+		seen.add(id);
+		result.push(id);
+	}
+	if (t.prior && !t.replaced) {
+		for (const id of t.prior) if (keep(id) && !deleted.has(pathKey([
+			...path,
+			childKey,
+			id
+		]))) {
+			seen.add(id);
+			result.push(id);
+		}
+	}
+	if (result.length === order.length && result.every((id, i) => id === order[i])) return doc;
+	return applyOne(doc, {
+		p: [...path, orderKey],
+		v: result
+	});
+}
+function unionKeys(a, b) {
+	const keys = Object.keys(b);
+	for (const k of Object.keys(a)) if (!Object.hasOwn(b, k)) keys.push(k);
+	return keys;
+}
+function diffLeafMap(path, a, b, ops) {
+	if (a === b) return;
+	for (const k of unionKeys(a, b)) if (!Object.hasOwn(b, k)) ops.push({ p: [...path, k] });
+	else if (!Object.hasOwn(a, k) || !deepEqual(a[k], b[k])) ops.push({
+		p: [...path, k],
+		v: b[k]
+	});
+}
+function diffNode(path, a, b, childKey, orderKey, ops, isDocumentKey = () => true) {
+	if (a === b) return;
+	let orderOp = null;
+	for (const key of unionKeys(a, b)) {
+		if (!isDocumentKey(key)) continue;
+		const av = a[key];
+		const bv = b[key];
+		if (av === bv) continue;
+		const p = [...path, key];
+		let op = null;
+		if (!Object.hasOwn(b, key)) op = { p };
+		else if (key === childKey && isPlainObject(av) && isPlainObject(bv)) diffChildren(p, av, bv, ops);
+		else if (key === childKey && !Object.hasOwn(a, key) && isPlainObject(bv) && Object.keys(bv).length > 0) diffChildren(p, {}, bv, ops);
+		else if (key === "settings" && isPlainObject(av) && isPlainObject(bv)) diffLeafMap(p, av, bv, ops);
+		else if (!Object.hasOwn(a, key) || !deepEqual(av, bv)) op = {
+			p,
+			v: bv
+		};
+		if (!op) continue;
+		if (key === orderKey) orderOp = op;
+		else ops.push(op);
+	}
+	if (orderOp) ops.push(orderOp);
+}
+function diffChildren(path, a, b, ops) {
+	for (const id of unionKeys(a, b)) if (!Object.hasOwn(b, id)) ops.push({ p: [...path, id] });
+	else if (!Object.hasOwn(a, id)) ops.push({
+		p: [...path, id],
+		v: b[id]
+	});
+	else if (isPlainObject(a[id]) && isPlainObject(b[id])) diffNode([...path, id], a[id], b[id], "blocks", "block_order", ops);
+	else if (!deepEqual(a[id], b[id])) ops.push({
+		p: [...path, id],
+		v: b[id]
+	});
+}
+function documentOf(root, entry) {
+	const out = {};
+	for (const [k, v] of Object.entries(entry)) if (isDocumentKey(root, k)) out[k] = v;
+	return out;
+}
+function isDocumentKey(root, key) {
+	return root === "group" ? GROUP_DOCUMENT_KEYS.has(key) : !TEMPLATE_NON_DOCUMENT_KEYS.has(key);
+}
+function diffEntries(root, a, b, ops) {
+	if (a === b) return;
+	for (const id of unionKeys(a, b)) if (!Object.hasOwn(b, id)) ops.push({ p: [root, id] });
+	else if (!Object.hasOwn(a, id)) ops.push({
+		p: [root, id],
+		v: documentOf(root, b[id])
+	});
+	else diffNode([root, id], a[id], b[id], "sections", "order", ops, (k) => isDocumentKey(root, k));
+}
+/**
+* The ops that turn `prev` into `next`. Setting values, `order` and
+* `block_order` are leaves (set whole); an added node is set whole, a removed
+* one is one delete, a changed one is recursed. Short-circuits on `===`.
+*/
+function diffDocument(prev, next) {
+	if (prev === next) return [];
+	const ops = [];
+	diffLeafMap(["settings"], prev.settings, next.settings, ops);
+	diffEntries("template", prev.templates, next.templates, ops);
+	diffEntries("group", prev.groups, next.groups, ops);
+	return ops;
+}
+/** The ops that restore `prev` at exactly the paths `ops` touched. */
+function invertOps(prev, ops) {
+	const seen = /* @__PURE__ */ new Set();
+	const paths = [];
+	for (const op of ops) {
+		const key = pathKey(op.p);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		paths.push(op.p);
+	}
+	paths.sort((a, b) => a.length - b.length);
+	return paths.map((p) => {
+		const docPath = toDocPath(p);
+		const at = docPath ? getAt(prev, docPath) : { found: false };
+		return at.found ? {
+			p,
+			v: at.value
+		} : { p };
+	});
+}
+const encoder = new TextEncoder();
+/** The entries `ops` write, added to `into` when given (a log read batch by
+*  batch). */
+function touchedEntries(ops, into = {
+	settings: false,
+	templates: /* @__PURE__ */ new Set(),
+	groups: /* @__PURE__ */ new Set()
+}) {
+	for (const { p } of ops) if (p[0] === "settings") into.settings = true;
+	else if (p[0] === "template") into.templates.add(p[1]);
+	else into.groups.add(p[1]);
+	return into;
+}
+const BODY_ENVELOPE_BYTES = 512;
+/**
+* Splits ops into batches within the op and byte caps, keeping their order:
+* `diffDocument` emits a container's new nodes before its order, so an order
+* op never lands in an earlier batch than its nodes. An op larger than the cap
+* travels alone (and the server refuses it).
+*/
+function chunkOps(ops, maxBytes = MAX_BATCH_BYTES, maxOps = 200) {
+	const budget = maxBytes - BODY_ENVELOPE_BYTES;
+	const chunks = [];
+	let current = [];
+	let bytes = 2;
+	for (const op of ops) {
+		const size = encoder.encode(JSON.stringify(op)).length + 1;
+		if (current.length > 0 && (current.length >= maxOps || bytes + size > budget)) {
+			chunks.push(current);
+			current = [];
+			bytes = 2;
+		}
+		current.push(op);
+		bytes += size;
+	}
+	if (current.length > 0) chunks.push(current);
+	return chunks;
+}
+const Segment = z.string().min(1).max(64).refine((s) => s.trim() === s, "segment must not be padded").refine((s) => !FORBIDDEN_KEYS.has(s), "forbidden segment");
+function hasForbiddenKey(value) {
+	const stack = [value];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (Array.isArray(node)) stack.push(...node);
+		else if (node !== null && typeof node === "object") for (const [k, v] of Object.entries(node)) {
+			if (FORBIDDEN_KEYS.has(k)) return true;
+			stack.push(v);
+		}
+	}
+	return false;
+}
+const isIdList = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+/** A section or block, or a whole entry: an object whose children (if any)
+*  are nodes and whose order (if any) is a list of ids, all the way down. The
+*  theme renders what the draft holds, so one malformed node must never land:
+*  it would break every page of the install for every peer. */
+function isContainer(v, childKey, orderKey) {
+	if (!isPlainObject(v)) return false;
+	if (Object.hasOwn(v, orderKey) && !isIdList(v[orderKey])) return false;
+	if (!Object.hasOwn(v, childKey)) return true;
+	const children = v[childKey];
+	return isPlainObject(children) && Object.values(children).every((c) => isContainer(c, "blocks", "block_order"));
+}
+function validValue(p, v) {
+	switch (shapeOf(p).kind) {
+		case "settings":
+		case "field": return null;
+		case "order": return isIdList(v) ? null : "order must be a list of ids";
+		case "entry": return isContainer(v, "sections", "order") ? null : "an entry must be a template or group";
+		case "child": return isContainer(v, "blocks", "block_order") ? null : "a node must be an object";
+		case "children": return isPlainObject(v) && Object.values(v).every((c) => isContainer(c, "blocks", "block_order")) ? null : "children must be an object of nodes";
+	}
+}
+const OpSchema = z.object({
+	p: z.array(Segment).min(2).max(24),
+	v: z.unknown().optional()
+}).strict().superRefine((op, ctx) => {
+	const [root, id] = op.p;
+	const fail = (message) => ctx.addIssue({
+		code: "custom",
+		message,
+		path: ["p"]
+	});
+	if (root === "settings") {
+		if (op.p.length !== 2) fail("a settings path is one segment deep");
+	} else if (root === "template") {
+		if (invalidTemplateId(id) || id === "__seeded") fail("invalid template id");
+	} else if (root === "group") {
+		if (!STORE_SLUG_RE.test(id)) fail("invalid group type");
+	} else fail("unknown root");
+	if (!Object.hasOwn(op, "v")) return;
+	if (hasForbiddenKey(op.v)) ctx.addIssue({
+		code: "custom",
+		message: "forbidden key in value",
+		path: ["v"]
+	});
+	const invalid = validValue(op.p, op.v);
+	if (invalid) ctx.addIssue({
+		code: "custom",
+		message: invalid,
+		path: ["v"]
+	});
+});
+/** The body of `POST /draft/ops`. The byte cap is the route's body limit. */
+const OpBatchBodySchema = z.object({
+	clientId: z.string().min(1).max(64),
+	batchNo: z.number().int().positive(),
+	batchId: z.string().min(1).max(64),
+	ops: z.array(OpSchema).min(1).max(200)
+}).strict();
+//#endregion
+export { MAX_BATCH_BYTES, MAX_BATCH_OPS, MAX_PATH_DEPTH, MAX_SEGMENT_LENGTH, OpBatchBodySchema, OpSchema, applyOps, chunkOps, diffDocument, invertOps, touchedEntries };

package/dist/richtext.d.ts

@@ -1,4 +1,27 @@
 //#region src/richtext.d.ts
 export declare const RICHTEXT_ALLOWED_TAGS: readonly ["p", "h1", "h2", "h3", "h4", "h5", "h6", "strong", "em", "u", "a", "span", "mark", "ul", "ol", "li", "br", "img", "table", "thead", "tbody", "tfoot", "tr", "th", "td"];
 export type RichtextTag = (typeof RICHTEXT_ALLOWED_TAGS)[number];
+export declare const RICHTEXT_SANITIZE_CONFIG: {
+  ALLOWED_TAGS: ("a" | "br" | "em" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "img" | "li" | "mark" | "ol" | "p" | "span" | "strong" | "table" | "tbody" | "td" | "tfoot" | "th" | "thead" | "tr" | "u" | "ul")[];
+  ALLOWED_ATTR: string[];
+  ALLOWED_URI_REGEXP: RegExp;
+  ADD_URI_SAFE_ATTR: string[];
+  FORBID_ATTR: string[];
+};
+/** The slice of a DOMPurify instance the hooks need, so this package carries
+ *  no DOM dependency. */
+export interface RichTextPurifier {
+  addHook(entryPoint: string, hook: (...args: unknown[]) => void): void;
+}
+/** Registers the two hooks `RICHTEXT_SANITIZE_CONFIG` relies on. Call once per
+ *  DOMPurify instance, before its first `sanitize`. */
+export declare function registerRichTextHooks(purify: RichTextPurifier): void;
+export declare const RICHTEXT_FIELD_TAGS: {
+  readonly richtext: readonly ["p", "h1", "h2", "h3", "h4", "h5", "h6", "strong", "em", "u", "a", "ul", "ol", "li", "br"];
+  readonly inline_richtext: readonly ["strong", "em", "a"];
+};
+/** Strip inline-token sentinel delimiters from a string. */
+export declare function stripInlineTokenSentinels(value: string): string;
+/** True when a rich-text value would put something on screen. */
+export declare function hasRichText(html: string | null | undefined): html is string;
 //#endregion

package/dist/richtext.js

@@ -26,5 +26,119 @@ const RICHTEXT_ALLOWED_TAGS = [
 	"th",
 	"td"
 ];
+const RICHTEXT_SANITIZE_CONFIG = {
+	ALLOWED_TAGS: [...RICHTEXT_ALLOWED_TAGS],
+	ALLOWED_ATTR: [
+		"href",
+		"rel",
+		"target",
+		"data-color",
+		"data-bg-color",
+		"data-page-ref",
+		"data-dyn",
+		"data-label",
+		"data-mention",
+		"src",
+		"alt",
+		"title",
+		"width",
+		"height",
+		"colspan",
+		"rowspan"
+	],
+	ALLOWED_URI_REGEXP: /^(?:https?:|mailto:|tel:|\/(?!\/)|#)/i,
+	ADD_URI_SAFE_ATTR: [
+		"width",
+		"height",
+		"colspan",
+		"rowspan",
+		"data-dyn",
+		"data-label",
+		"data-mention"
+	],
+	FORBID_ATTR: [
+		"class",
+		"style",
+		"id"
+	]
+};
+const COLOR_STYLE_RE = /^(color|background-color)\s*:\s*(#[0-9a-fA-F]{3,8})\s*;?\s*$/;
+const STYLE_TO_DATA_ATTR = {
+	color: "data-color",
+	"background-color": "data-bg-color"
+};
+const EXTERNAL_HTTP_RE = /^https?:/i;
+const REWRITABLE_TAGS = /* @__PURE__ */ new Set(["SPAN", "MARK"]);
+const ELEMENT_NODE = 1;
+/** Registers the two hooks `RICHTEXT_SANITIZE_CONFIG` relies on. Call once per
+*  DOMPurify instance, before its first `sanitize`. */
+function registerRichTextHooks(purify) {
+	purify.addHook("uponSanitizeElement", (raw) => {
+		const node = raw;
+		if (node.nodeType !== ELEMENT_NODE) return;
+		if (!REWRITABLE_TAGS.has(node.tagName)) return;
+		const style = node.getAttribute("style");
+		if (!style) return;
+		const match = style.match(COLOR_STYLE_RE);
+		if (!match) return;
+		node.removeAttribute("style");
+		node.setAttribute(STYLE_TO_DATA_ATTR[match[1]], match[2]);
+	});
+	purify.addHook("uponSanitizeAttribute", (rawNode, rawData) => {
+		const node = rawNode;
+		const data = rawData;
+		if (data.attrName === "data-page-ref" && node.tagName !== "A") {
+			data.keepAttr = false;
+			return;
+		}
+		if ((data.attrName === "data-dyn" || data.attrName === "data-label" || data.attrName === "data-mention") && node.tagName !== "SPAN") {
+			data.keepAttr = false;
+			return;
+		}
+		if (node.tagName !== "A") return;
+		if (data.attrName !== "href") return;
+		if (!EXTERNAL_HTTP_RE.test(data.attrValue)) return;
+		node.setAttribute("rel", "noopener noreferrer nofollow");
+		node.setAttribute("target", "_blank");
+	});
+}
+const RICHTEXT_FIELD_TAGS = {
+	richtext: [
+		"p",
+		"h1",
+		"h2",
+		"h3",
+		"h4",
+		"h5",
+		"h6",
+		"strong",
+		"em",
+		"u",
+		"a",
+		"ul",
+		"ol",
+		"li",
+		"br"
+	],
+	inline_richtext: [
+		"strong",
+		"em",
+		"a"
+	]
+};
+const INLINE_TOKEN_DELIMITERS = /[]/g;
+/** Strip inline-token sentinel delimiters from a string. */
+function stripInlineTokenSentinels(value) {
+	return value.replace(INLINE_TOKEN_DELIMITERS, "");
+}
+const EMBEDDED_RE = /<(img|iframe|video|hr)\b/i;
+const TAG_RE = /<[^>]*>/g;
+const NBSP_RE = /&nbsp;|&#160;| /gi;
+/** True when a rich-text value would put something on screen. */
+function hasRichText(html) {
+	if (!html) return false;
+	if (EMBEDDED_RE.test(html)) return true;
+	return html.replace(TAG_RE, " ").replace(NBSP_RE, " ").trim() !== "";
+}
 //#endregion
-export { RICHTEXT_ALLOWED_TAGS };
+export { RICHTEXT_ALLOWED_TAGS, RICHTEXT_FIELD_TAGS, RICHTEXT_SANITIZE_CONFIG, hasRichText, registerRichTextHooks, stripInlineTokenSentinels };