@plitzi/sdk-schema 0.37.8 → 0.37.10

package/dist/helpers/components.mjs

@@ -0,0 +1,130 @@
+import { isValidElementId as e, repointIds as t, uniqueElementId as n } from "./elementId.mjs";
+import { descendants as r } from "./elementTree.mjs";
+import i from "./FlatMap.mjs";
+import { jsonCopy as a } from "@plitzi/sdk-shared/history";
+//#region src/helpers/components.ts
+var o = /* @__PURE__ */ new Set([
+	"referenceType",
+	"referenceId",
+	"slot",
+	"className",
+	"style",
+	"children",
+	"ref",
+	"id"
+]), s = /^[A-Za-z][A-Za-z0-9_]*$/, c = (e) => s.test(e) ? o.has(e) ? `"${e}" is an attribute every instance already has` : null : `"${e}" is not a valid prop name: start with a letter, then letters, numbers and underscores — it is read as {{ props.${e} }}`, l = (e) => [{ flat: e.flat }, ...Object.values(e.components).map((e) => ({
+	flat: e.flat,
+	componentId: e.id
+}))], u = (e, t) => l(e).find((e) => Object.hasOwn(e.flat, t)), d = (e) => new Set(l(e).flatMap((e) => Object.keys(e.flat))), f = (e, t, n) => {
+	let r = u(e, t);
+	if (!r) return;
+	let a = l(e).filter((e) => e.flat !== r.flat);
+	return new i({
+		flat: r.flat,
+		pages: r.componentId ? void 0 : e.pages,
+		mintId: n,
+		takenElsewhere: (e) => a.some((t) => Object.hasOwn(t.flat, e))
+	});
+}, p = (e, t) => Object.hasOwn(e.components, t) ? e.components[t] : void 0, m = (e, t) => e.definition.type === "reference" && e.attributes.referenceType === "component" && (t === void 0 || e.attributes.referenceId === t), h = (e, t) => l(e).flatMap((e) => Object.values(e.flat).filter((e) => m(e, t))), g = (e, n, r) => {
+	let i = f(e, n);
+	if (!i) return !1;
+	let a = i.renameElement(n, r);
+	if (!a || n === r) return a;
+	for (let o of l(e)) o.flat !== i.flat && a.push(...t(o.flat, { [n]: r }));
+	for (let t of Object.values(e.components)) t.rootId === n && (t.rootId = r), t.slots?.includes(n) && (t.slots = t.slots.map((e) => e === n ? r : e));
+	return [...new Set(a)];
+}, _ = (e, t) => {
+	for (let t of Object.keys(e.props ?? {})) {
+		let e = c(t);
+		if (e) return e;
+	}
+	let n = (e.slots ?? []).find((e) => !Object.hasOwn(t, e));
+	return n ? `slot "${n}" is not an element of the component` : null;
+}, v = (e, t, n) => ({
+	id: t,
+	attributes: {
+		referenceType: "component",
+		referenceId: e.id
+	},
+	definition: {
+		label: e.label ?? e.id,
+		type: "reference",
+		items: [],
+		bindings: {},
+		parentId: n.definition.parentId,
+		rootId: n.definition.rootId,
+		styleSelectors: { base: "" },
+		initialState: { visibility: !0 }
+	}
+}), y = (t, n, i) => {
+	if (!e(n.id) || Object.hasOwn(t.components, n.id)) return !1;
+	if (!i) {
+		let e = n.flat[n.rootId], r = d(t);
+		return !e || e.definition.parentId || Object.keys(n.flat).some((e) => r.has(e)) || _(n, n.flat) ? !1 : (t.components[n.id] = n, !0);
+	}
+	let { elementId: a, instanceId: o } = i, s = u(t, a), c = s?.flat[a], l = c?.definition.parentId ? s?.flat[c.definition.parentId] : void 0;
+	if (!s || !c || !l?.definition.items || !e(o) || d(t).has(o)) return !1;
+	let f = {};
+	for (let e of [a, ...r(s.flat, a)]) {
+		let { parentId: t, ...n } = s.flat[e].definition;
+		f[e] = {
+			...s.flat[e],
+			definition: {
+				...n,
+				...e === a ? {} : { parentId: t },
+				rootId: a
+			}
+		};
+	}
+	let p = {
+		...n,
+		rootId: a,
+		flat: f
+	};
+	if (_(p, f)) return !1;
+	for (let e of Object.keys(f)) delete s.flat[e];
+	return s.flat[o] = v(p, o, c), l.definition.items = l.definition.items.map((e) => e === a ? o : e), t.components[p.id] = p, !0;
+}, b = (e, t, n) => {
+	let r = p(e, t);
+	return !r || _({
+		...r,
+		...n
+	}, r.flat) ? !1 : (e.components[t] = {
+		...r,
+		...n
+	}, !0);
+}, x = (e, t) => !Object.hasOwn(e.components, t) || h(e, t).length > 0 ? !1 : (delete e.components[t], !0), S = (e, i) => {
+	let o = u(e, i), s = o?.flat[i], { referenceId: c } = s?.attributes ?? {}, l = s && m(s) && typeof c == "string" ? p(e, c) : void 0, f = s?.definition.parentId ? o?.flat[s.definition.parentId] : void 0;
+	if (!o || !s || !l || !f?.definition.items) return !1;
+	let h = s.definition.items ?? [], g = (e) => {
+		let { slot: t } = o.flat[e].attributes;
+		return typeof t == "string" ? t : l.slots?.[0];
+	};
+	if (h.some((e) => !l.slots?.includes(g(e) ?? ""))) return !1;
+	let _ = d(e);
+	_.delete(i);
+	let v = [l.rootId, ...r(l.flat, l.rootId)], y = {};
+	for (let e of v) y[e] = n(e, (e) => _.has(e)), _.add(y[e]);
+	let b = {};
+	for (let e of v) {
+		let t = a(l.flat[e]);
+		t.definition.rootId = s.definition.rootId, b[e] = t;
+	}
+	t(b, y);
+	let x = b[y[l.rootId]];
+	x.definition.parentId = s.definition.parentId;
+	for (let e of h) {
+		let t = b[y[g(e) ?? ""]], n = o.flat[e], { slot: r, ...i } = n.attributes;
+		o.flat[e] = {
+			...n,
+			attributes: i,
+			definition: {
+				...n.definition,
+				parentId: t.id
+			}
+		}, t.definition.items = [...t.definition.items ?? [], e];
+	}
+	return Object.assign(o.flat, b), delete o.flat[i], f.definition.items = f.definition.items.map((e) => e === i ? x.id : e), x.id;
+};
+//#endregion
+export { o as RESERVED_PROP_NAMES, y as addComponent, p as componentNamed, S as detachInstance, d as documentIds, f as flatMapOf, h as instancesOf, m as isInstance, c as propNameProblem, x as removeComponent, g as renameElement, u as treeOf, l as treesOf, b as updateComponent };

package/dist/helpers/elementId.d.ts

@@ -11,9 +11,9 @@ export declare const isValidElementId: (id: string) => boolean;
  *  collapse, and a leading non-letter is dropped — so a name is editable as prose in the builder's tree and still
  *  lands as a valid key. Empty when nothing usable survives, which the caller reports rather than storing. */
 export declare const slugifyElementId: (value: string) => string;
-/** Every id currently in use, so a new one can be checked or minted against it. Uniqueness is per DOCUMENT — a
- *  space schema, and each segment separately — which is what makes a lookup a `flat` key access. A segment used on
- *  several pages repeats its ids in the rendered tree; `rootId`/`referenceId` are what tell those apart. */
+/** Every id in use in one tree, so a new one can be checked or minted against it. Uniqueness spans the DOCUMENT —
+ *  the space's `flat` and every component's (`documentIds`) — which is what makes a lookup a `flat` key access. A
+ *  component placed several times repeats its ids in the rendered tree; each instance's scope tells those apart. */
 export declare const takenIds: (flat: Record<Element["id"], Element>) => Set<string>;
 /** Why `id` cannot be used in this document, phrased for a person, or null when it is free and well formed.
  *  `ignoreElementId` exempts the element being edited, so re-saving an element its own id is not a conflict. */
@@ -66,7 +66,7 @@ export declare const repointIds: (flat: Record<Element["id"], Element>, map: Rec
  * Renames only the elements of an incoming set whose names this document has already taken, and repoints the set's
  * own references onto the new names.
  *
- * What a template drop and a cross-document paste both need. Renaming everything would be simpler and worse: the
+ * What a snippet drop and a cross-document paste both need. Renaming everything would be simpler and worse: the
  * names an author gave the template are the reason it is readable, and a document that had no `hero` should get
  * one called `hero`. Returns the renaming it applied, so a caller can report what it had to change.
  */

package/dist/helpers/elementId.mjs

@@ -78,6 +78,8 @@ var e = /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9_])?$/, t = (t) => e.test(t), n = (
 			let r = o[n];
 			typeof r == "string" && t[r] && (!i || i(o)) && (o[n] = t[r], e = !0);
 		}
+		let { slot: s } = o;
+		typeof s == "string" && t[s] && (o.slot = t[s], e = !0);
 		for (let n of Object.values(r.bindings ?? {})) for (let r of n) {
 			let n = p(r.source, t);
 			n !== r.source && (r.source = n, e = !0), r.transformers && g(r.transformers, t) && (e = !0), r.when && g(r.when, t) && (e = !0);

package/dist/helpers/fitSnippet.d.ts

@@ -0,0 +1,32 @@
+import { Element, Schema, SnippetStyle, Style } from '@plitzi/sdk-shared';
+type Elements = Record<Element['id'], Element>;
+/**
+ * A snippet, fitted to the space it is about to enter: its elements and its classes under names that are free there.
+ *
+ * A snippet arrives from a document nobody here has seen, and the names it brought may not be free — dropping the same
+ * snippet twice is enough. Only what collides changes, and everything that pointed at it is repointed with it: the
+ * names an author gave are why the snippet reads well, and a space with no `hero` should get one called `hero`.
+ *
+ * - An element whose id the space holds is renamed (`remapCollidingIds`).
+ * - A class the space uses for something else is renamed, in the snippet's style and on the elements that wear it, so
+ *   the space's own `.card` is not restyled by the snippet's. One that says the same is shared.
+ * - Rules for an element type, and tokens, are left for the merge (`mergeSnippetStyle`), which adds what the space
+ *   lacks and keeps what it has.
+ *
+ * Decided once, where somebody dropped it, and carried by the insert from there: the editor, the server it is saved to
+ * and every collaborator it is broadcast to then insert the same names, and one that stopped being free on the way is
+ * refused there rather than stored under another name. Copied first: the snippet belongs to whoever passed it.
+ */
+declare const fitSnippet: (space: {
+    schema: Pick<Schema, "flat" | "components">;
+    style: Pick<Style, "platform">;
+}, snippet: {
+    data: Element;
+    initialItems?: Elements;
+    style?: SnippetStyle;
+}) => {
+    data: Element;
+    initialItems: Elements;
+    style?: SnippetStyle;
+};
+export default fitSnippet;

package/dist/helpers/fitSnippet.mjs

@@ -0,0 +1,71 @@
+import { remapCollidingIds as e } from "./elementId.mjs";
+import { documentIds as t } from "./components.mjs";
+import { isDisplayMode as n } from "@plitzi/sdk-shared/style/displayModes";
+import { sameSelector as r, selectorsOf as i } from "@plitzi/sdk-shared/style/snippetStyle";
+import a from "@plitzi/sdk-style/helpers/processSelector";
+//#region src/helpers/fitSnippet.ts
+var o = (e, t) => {
+	let n = 2;
+	for (; t.has(`${e}-${n}`);) n += 1;
+	return `${e}-${n}`;
+}, s = (e, t) => {
+	let n = /* @__PURE__ */ new Set([...i(e), ...i(t)]), a = /* @__PURE__ */ new Map();
+	return i(t).forEach((s) => {
+		if (Object.values(t).find((e) => Object.hasOwn(e, s))?.[s]?.type === "element" || !i(e).has(s) || r(s, e, t)) return;
+		let c = o(s, n);
+		n.add(c), a.set(s, c);
+	}), a;
+}, c = (e, t, n) => {
+	let r = t !== e.name, i = Object.fromEntries(Object.entries(e.attributes).map(([e, t]) => {
+		if (!t.ancestors || !Object.keys(t.ancestors).some((e) => n.has(e))) return [e, t];
+		r = !0;
+		let i = Object.fromEntries(Object.entries(t.ancestors).map(([e, t]) => [n.get(e) ?? e, t]));
+		return [e, {
+			...t,
+			ancestors: i
+		}];
+	}));
+	if (!r) return e;
+	let o = {
+		...e,
+		name: t,
+		attributes: i
+	};
+	return {
+		...o,
+		cache: a(o)
+	};
+}, l = (e, t) => {
+	if (t.size === 0) return e;
+	let r = { ...e.platform };
+	return Object.keys(r).filter(n).forEach((e) => {
+		r[e] = Object.fromEntries(Object.entries(r[e]).map(([e, n]) => {
+			let r = t.get(e) ?? e;
+			return [r, c(n, r, t)];
+		}));
+	}), {
+		...e,
+		platform: r
+	};
+}, u = (e, t) => {
+	Object.values(e).forEach((e) => {
+		let { styleSelectors: n } = e.definition;
+		Object.keys(n).forEach((e) => {
+			n[e] = n[e].split(/\s+/).map((e) => t.get(e) ?? e).join(" ");
+		});
+	});
+}, d = (n, r) => {
+	let i = structuredClone({
+		...r.initialItems,
+		[r.data.id]: r.data
+	}), a = t(n.schema), o = e(i, (e) => a.has(e)), c = r.style ? s(n.style.platform, r.style.platform) : /* @__PURE__ */ new Map();
+	u(i, c);
+	let { [o[r.data.id] ?? r.data.id]: d, ...f } = i;
+	return {
+		data: d,
+		initialItems: f,
+		style: r.style && l(r.style, c)
+	};
+};
+//#endregion
+export { d as default };

package/dist/helpers/schemaValidator.d.ts

@@ -1,5 +1,6 @@
 import { Schema } from '@plitzi/sdk-shared';
 export type SchemaValidationOptions = {
+    /** Validates `flat` as a fragment hung off this element — a component's tree — instead of as the pages' tree. */
     baseElementId?: string;
     /**
      * Element type → the source name it publishes under.
@@ -14,6 +15,8 @@ export type SchemaValidationError = {
     code: string;
     message: string;
     elementId?: string;
+    /** The component whose tree the error is in; absent for the pages' tree. */
+    componentId?: string;
     details?: unknown;
 };
 export type SchemaValidationResult = {