@plitzi/sdk-schema 0.33.1 → 0.34.0

package/dist/helpers/FlatMap.mjs

@@ -1,7 +1,6 @@
-import { idRefConflict as e, idRefsUsable as t, remapClonedRefs as n, repointIdRefs as r, takenIdRefs as i } from "./idRef.mjs";
-import { validateSchema as a } from "./schemaValidator.mjs";
-import { get as o, set as s } from "@plitzi/plitzi-ui/helpers";
-import { generateID as c } from "@plitzi/sdk-shared/helpers/utils";
+import { elementIdConflict as e, elementIdsFree as t, randomElementId as n, repointIds as r, takenIds as i, uniqueElementId as a } from "./elementId.mjs";
+import { validateSchema as o } from "./schemaValidator.mjs";
+import { get as s, set as c } from "@plitzi/plitzi-ui/helpers";
 import { EMPTY_SCHEMA as l, VARIABLE_REGEX as u } from "@plitzi/sdk-shared/schema/schemaConstants";
 import { EMPTY_STYLE_SCHEMA as d } from "@plitzi/sdk-shared/style/styleConstants";
 import f from "@plitzi/sdk-style/helpers/calculateInheriting";
@@ -9,41 +8,50 @@ import f from "@plitzi/sdk-style/helpers/calculateInheriting";
 var p = class {
 	flat;
 	variables;
+	pages;
+	mintId;
 	constructor(e = {}) {
-		let { flat: t, variables: n } = e;
+		let { flat: t, variables: r, pages: i, mintId: a } = e;
 		if (!t) throw Error("Flat is required");
-		this.flat = t, this.variables = n ?? [];
+		this.flat = t, this.variables = r ?? [], this.pages = i ?? [], this.mintId = a ?? n;
 	}
+	nextId = (e, t = () => !1) => {
+		let n = this.takenIds();
+		return this.mintId(e, (e) => n.has(e) || t(e));
+	};
 	addElement = (e, n, r = "inside", i = {}) => {
-		let a;
+		let a = e.id ? e : {
+			...e,
+			id: this.nextId(e.definition.type)
+		}, o;
 		if (r !== "custom") {
 			if (r !== "inside") {
 				let e = this.flat[n];
 				if (!e) return !1;
-				e.definition.parentId && (a = this.flat[e.definition.parentId]);
-			} else a = this.flat[n];
-			if (!a) return !1;
+				e.definition.parentId && (o = this.flat[e.definition.parentId]);
+			} else o = this.flat[n];
+			if (!o) return !1;
 		}
-		if (r !== "custom" && (this.flat[e.id] || !Array.isArray(o(a, "definition.items"))) || !this.isValidElement(e) || !t(this.flat, [e, ...Object.values(i)])) return !1;
-		switch (s(this.flat, e.id, e), r) {
+		if (r !== "custom" && !Array.isArray(s(o, "definition.items")) || !this.isValidElement(a) || !t(this.flat, [a, ...Object.values(i)])) return !1;
+		switch (c(this.flat, a.id, a), r) {
 			case "left":
 			case "top": {
-				let t = o(a, "definition.items", []);
-				if (t.splice(t.findIndex((e) => e === n), 0, e.id), !a) return !1;
-				s(this.flat, `${a.id}.definition.items`, t), s(this.flat, `${e.id}.definition.parentId`, a.id), s(this.flat, `${e.id}.definition.rootId`, a.definition.rootId);
+				let e = s(o, "definition.items", []);
+				if (e.splice(e.findIndex((e) => e === n), 0, a.id), !o) return !1;
+				c(this.flat, `${o.id}.definition.items`, e), c(this.flat, `${a.id}.definition.parentId`, o.id), c(this.flat, `${a.id}.definition.rootId`, o.definition.rootId);
 				break;
 			}
 			case "right":
 			case "bottom": {
-				let t = o(a, "definition.items", []);
-				if (t.splice(t.findIndex((e) => e === n) + 1, 0, e.id), !a) return !1;
-				s(this.flat, `${a.id}.definition.items`, t), s(this.flat, `${e.id}.definition.parentId`, a.id), s(this.flat, `${e.id}.definition.rootId`, a.definition.rootId);
+				let e = s(o, "definition.items", []);
+				if (e.splice(e.findIndex((e) => e === n) + 1, 0, a.id), !o) return !1;
+				c(this.flat, `${o.id}.definition.items`, e), c(this.flat, `${a.id}.definition.parentId`, o.id), c(this.flat, `${a.id}.definition.rootId`, o.definition.rootId);
 				break;
 			}
 			case "inside": {
-				let t = o(a, "definition.items", []);
-				if (!a) return !1;
-				s(this.flat, `${n}.definition.items`, [...t, e.id]), s(this.flat, `${e.id}.definition.parentId`, n), s(this.flat, `${e.id}.definition.rootId`, a.definition.rootId);
+				let e = s(o, "definition.items", []);
+				if (!o) return !1;
+				c(this.flat, `${n}.definition.items`, [...e, a.id]), c(this.flat, `${a.id}.definition.parentId`, n), c(this.flat, `${a.id}.definition.rootId`, o.definition.rootId);
 				break;
 			}
 			case "custom": break;
@@ -53,24 +61,22 @@ var p = class {
 			this.flat[e] = i[e];
 		}), !0;
 	};
-	updateElement = (e) => {
-		if (!e || !this.flat[e.id]) return !1;
-		let n = this.flat[e.id].idRef, i = e.idRef !== n;
-		return i && !t(this.flat, [e]) ? !1 : i && n && e.idRef ? (this.flat[e.id] = structuredClone(e), r(this.flat, { [n]: e.idRef }), !0) : (this.flat[e.id] = e, !0);
-	};
+	updateElement = (e) => !e || !this.flat[e.id] ? !1 : (this.flat[e.id] = e, !0);
+	renameElement = (t, n) => this.flat[t] ? t === n ? [] : !e(this.flat, n) && r(this.flat, { [t]: n }, this.pages) : !1;
+	renameConflict = (t, n) => e(this.flat, n, t);
 	moveElement = (e, t, n, r = "inside") => {
 		if (n === t || !this.flat[e]) return !1;
 		let i = this.flat[t];
 		if (!i) return !1;
 		let a = this.flat[t];
 		for (; a;) {
-			let e = o(a, "definition.parentId");
+			let e = s(a, "definition.parentId");
 			if (!e) break;
 			if (a.id === n) return !1;
 			a = this.flat[e];
 		}
 		if (!a) return !1;
-		let c = o(this.flat, `${e}.definition.items`, []).filter((e) => e !== n);
+		let o = s(this.flat, `${e}.definition.items`, []).filter((e) => e !== n);
 		if ([
 			"left",
 			"top",
@@ -80,64 +86,49 @@ var p = class {
 			if (!i.definition.parentId) return !1;
 			let a = this.flat[i.definition.parentId];
 			if (!a) return !1;
-			let l = o(a, "definition.items", []);
-			a.id === e && (l = c);
+			let l = s(a, "definition.items", []);
+			a.id === e && (l = o);
 			let u = l.findIndex((e) => e === t);
-			["right", "bottom"].includes(r) && u++, l.splice(u, 0, n), s(this.flat, `${e}.definition.items`, c), s(this.flat, `${a.id}.definition.items`, l), s(this.flat, `${n}.definition.parentId`, a.id);
+			["right", "bottom"].includes(r) && u++, l.splice(u, 0, n), c(this.flat, `${e}.definition.items`, o), c(this.flat, `${a.id}.definition.items`, l), c(this.flat, `${n}.definition.parentId`, a.id);
 		} else if (r === "inside") {
 			if (!this.flat[t]) return !1;
-			let r = o(this.flat, `${t}.definition.items`, []);
-			e === t && (r = c), r = [...r, n], s(this.flat, `${e}.definition.items`, c), s(this.flat, `${t}.definition.items`, r), s(this.flat, `${n}.definition.parentId`, t);
+			let r = s(this.flat, `${t}.definition.items`, []);
+			e === t && (r = o), r = [...r, n], c(this.flat, `${e}.definition.items`, o), c(this.flat, `${t}.definition.items`, r), c(this.flat, `${n}.definition.parentId`, t);
 		}
 		return !0;
 	};
-	getElement = (e) => o(this.flat, e);
-	takenIdRefs = () => i(this.flat);
-	idRefConflict = (t, n) => e(this.flat, t, n);
-	cloneElements = (e, t = "", r = "", i = !1) => {
-		let a = {
+	getElement = (e) => s(this.flat, e);
+	takenIds = () => i(this.flat);
+	elementIdConflict = (t, n) => e(this.flat, t, n);
+	cloneElements = (e, t = "", n = "", i = !1) => {
+		let o = {
 			acum: {},
 			item: void 0
 		}, l = {}, u = this.flat[e];
-		if (!u) return a;
-		let d = this.takenIdRefs(), f = [e, ...this.childTree(e)].reduce((e, t) => {
-			let n = this.flat[t];
-			return n ? (l[n.id] = c(n.id), r ? {
-				...e,
-				[n.id]: {
-					...n,
-					definition: {
-						...n.definition,
-						rootId: r
-					}
-				}
-			} : {
-				...e,
-				[n.id]: n
-			}) : e;
-		}, {});
-		try {
-			let t = JSON.stringify(f);
-			t = Object.keys(l).reduce((e, t) => e.replace(new RegExp(t, "g"), l[t]), t), a.acum = JSON.parse(t), a.item = a.acum[l[e]], n(a.acum, (e) => d.has(e));
-		} catch (e) {
-			return console.error("Error parsing elements", e), {
-				acum: {},
-				item: void 0
-			};
+		if (!u) return o;
+		let d = [e, ...this.childTree(e)].filter((e) => this.flat[e] !== void 0), f = this.takenIds();
+		for (let e of d) {
+			let t = a(e, (e) => f.has(e));
+			f.add(t), l[e] = t;
+		}
+		let p = {};
+		for (let e of d) {
+			let t = structuredClone(this.flat[e]);
+			n && (t.definition.rootId = n), p[e] = t;
 		}
-		i && delete a.acum[l[e]];
-		let p = this.flat[t];
-		return (!p || !Array.isArray(o(p, "definition.items"))) && (t = o(p, "definition.parentId", o(u, "definition.parentId"))), t && s(a, "item.definition.parentId", t), a;
+		r(p, l), o.acum = p, o.item = p[l[e]], i && delete o.acum[l[e]];
+		let m = this.flat[t];
+		return (!m || !Array.isArray(s(m, "definition.items"))) && (t = s(m, "definition.parentId", s(u, "definition.parentId"))), t && c(o, "item.definition.parentId", t), o;
 	};
 	removeElement = (e, t = !1) => {
 		let n = this.flat[e];
-		if (!n || n.definition.type === "page" && !t || t && o(n, "attributes.default", !1)) return !1;
-		let r = o(n, "definition.items");
+		if (!n || n.definition.type === "page" && !t || t && s(n, "attributes.default", !1)) return !1;
+		let r = s(n, "definition.items");
 		r && r.length > 0 && r.forEach((e) => this.removeElement(e));
-		let i = o(n, "definition.parentId"), a = i ? this.flat[i] : void 0;
+		let i = s(n, "definition.parentId"), a = i ? this.flat[i] : void 0;
 		if (i && a) {
 			let { definition: { items: t = [] } } = a;
-			s(a, "definition.items", t.filter((t) => t !== e)), this.flat[i] = a;
+			c(a, "definition.items", t.filter((t) => t !== e)), this.flat[i] = a;
 		}
 		return delete this.flat[e], !0;
 	};
@@ -164,18 +155,18 @@ var p = class {
 		let t = this.flat[e], n = [];
 		if (!t) return n;
 		do {
-			if (o(t, "definition.type") === "page") {
-				let e = o(t, "attributes.layout"), r = o(t, "attributes.layoutContainer");
+			if (s(t, "definition.type") === "page") {
+				let e = s(t, "attributes.layout"), r = s(t, "attributes.layoutContainer");
 				e && r && n.push(r, ...this.parentTree(r));
 			}
-			e !== t.id && n.push(t.id), t = o(this.flat, o(t, "definition.parentId"), void 0);
+			e !== t.id && n.push(t.id), t = s(this.flat, s(t, "definition.parentId"), void 0);
 		} while (t);
 		return n;
 	};
 	childTree = (e) => {
 		let t = this.flat[e];
 		if (!t) return [];
-		let n = [], r = o(t, "definition.items");
+		let n = [], r = s(t, "definition.items");
 		return r && r.forEach((e) => n.push(e, ...this.childTree(e))), n;
 	};
 	isValidElement = (e) => {
@@ -202,7 +193,7 @@ var p = class {
 			elementsStyle: r,
 			variables: i
 		};
-		let a = o(this.flat, t);
+		let a = s(this.flat, t);
 		if (!a) return {
 			elements: {
 				acum: {},
@@ -211,18 +202,18 @@ var p = class {
 			elementsStyle: r,
 			variables: i
 		};
-		let c = this.cloneElements(t, a.definition.parentId);
-		return c.item ? (Object.values(c.acum).forEach((t) => {
+		let o = this.cloneElements(t, a.definition.parentId);
+		return o.item ? (Object.values(o.acum).forEach((t) => {
 			let { id: n } = t;
-			if (s(c.acum, `${n}.definition.rootId`, c.item?.id), f(t, t.definition.type, this.flat, e.platform, {}, { includeSelf: !0 }).tree.forEach((t) => {
+			if (c(o.acum, `${n}.definition.rootId`, o.item?.id), f(t, t.definition.type, this.flat, e.platform, {}, { includeSelf: !0 }).tree.forEach((t) => {
 				let { displayMode: n, name: i } = t;
 				!(i in r.platform[n]) && i in e.platform[n] && (r.platform[n][i] = e.platform[n][i]);
 			}), this.variables.length > 0) {
-				let t = this.getElementVariables(e, n, c.acum);
+				let t = this.getElementVariables(e, n, o.acum);
 				i = [...i, ...t];
 			}
-		}), s(c.acum, `${c.item.id}.definition.parentId`, null), n && delete c.acum[c.item.id], i.length > 1 && (i = [...new Set(i)]), {
-			elements: c,
+		}), c(o.acum, `${o.item.id}.definition.parentId`, null), n && delete o.acum[o.item.id], i.length > 1 && (i = [...new Set(i)]), {
+			elements: o,
 			elementsStyle: r,
 			variables: i
 		}) : {
@@ -234,14 +225,14 @@ var p = class {
 			variables: i
 		};
 	};
-	validate = () => a({
+	validate = () => o({
 		...l.schema,
 		flat: this.flat,
 		variables: this.variables
 	});
 	isValid = () => this.validate().valid;
 	assertValid = (e) => {
-		let t = a({
+		let t = o({
 			...l.schema,
 			flat: this.flat,
 			variables: this.variables
@@ -252,13 +243,13 @@ var p = class {
 		}
 	};
 	getElementVariables = (e, t, n = this.flat, r = this.variables) => {
-		let i = [], a = o(n, `${t}.definition.styleSelectors`);
+		let i = [], a = s(n, `${t}.definition.styleSelectors`);
 		if (!a) return i;
-		let s = new RegExp(u, "g");
+		let o = new RegExp(u, "g");
 		return Object.values(a).filter(Boolean).forEach((t) => {
 			Object.values(e.platform).forEach((e) => {
 				let n = e[t];
-				n && [...JSON.stringify(n.attributes).matchAll(s)].forEach((e) => {
+				n && [...JSON.stringify(n.attributes).matchAll(o)].forEach((e) => {
 					let t = r.find((t) => t.name === e[1] || t.name === e[2]);
 					t && !i.find((e) => e.name === t.name) && i.push(t);
 				});
@@ -268,12 +259,16 @@ var p = class {
 	static getInstance = (e) => new this(e);
 	static addElement = (e, t, n, r = "inside", i = {}) => this.getInstance({ flat: e }).addElement(t, n, r, i);
 	static updateElement = (e, t) => this.getInstance({ flat: e }).updateElement(t);
+	static renameElement = (e, t, n) => this.getInstance({
+		flat: e.flat,
+		pages: e.pages
+	}).renameElement(t, n);
 	static moveElement = (e, t, n, r, i = "inside") => this.getInstance({ flat: e }).moveElement(t, n, r, i);
 	static getElement = (e, t) => this.getInstance({ flat: e }).getElement(t);
 	static cloneElements = (e, t, n = "", r = "", i = !1) => this.getInstance({ flat: e }).cloneElements(t, n, r, i);
 	static removeElement = (e, t, n = !1) => this.getInstance({ flat: e }).removeElement(t, n);
-	static takenIdRefs = (e) => this.getInstance({ flat: e }).takenIdRefs();
-	static idRefConflict = (e, t, n) => this.getInstance({ flat: e }).idRefConflict(t, n);
+	static takenIds = (e) => this.getInstance({ flat: e }).takenIds();
+	static elementIdConflict = (e, t, n) => this.getInstance({ flat: e }).elementIdConflict(t, n);
 	static addVariables = (e, t) => this.getInstance({ variables: e }).addVariables(t);
 	static addVariable = (e, t) => this.getInstance({ variables: e }).addVariable(t);
 	static updateVariable = (e, t) => this.getInstance({ variables: e }).updateVariable(t);
@@ -296,10 +291,10 @@ var p = class {
 			variables: i
 		}).getElementVariables(t, n);
 	};
-	static validate = (e) => a(e);
-	static isValid = (e) => a(e).valid;
+	static validate = (e) => o(e);
+	static isValid = (e) => o(e).valid;
 	static assertValid = (e, t) => {
-		let n = a(e);
+		let n = o(e);
 		if (!n.valid) {
 			let e = `Invalid schema${t ? ` (${t})` : ""}: ${n.errors.map((e) => e.message).join("; ")}`;
 			throw Error(e);

package/dist/helpers/elementId.d.ts

@@ -0,0 +1,73 @@
+import { Element, Schema } from '@plitzi/sdk-shared';
+/** True when an element id is well formed: it starts with a letter and then carries letters, numbers, hyphens and
+ *  underscores. Leading letter keeps a source `<type>_<id>` a valid twig identifier. A '.' would split the
+ *  `<type>_<id>.<field>` source path, an interaction target lookup, and the lodash paths `flat` is read and written
+ *  through (`get(flat, id)`, `set(flat, \`${id}.definition.rootId\`)`) — so it is not allowed. A source name uses
+ *  the first '_' as separator between `<type>` and `<id>` (element types are camelCase with no underscore), so
+ *  underscores inside the id are unambiguous. A hyphen is allowed too: a source doubles as a twig token, and
+ *  `processTwig` resolves a hyphenated `<type>_<id>` through `_context` subscript access. */
+export declare const isValidElementId: (id: string) => boolean;
+/** What a person typed, as an id this document can hold. Anything outside the charset becomes a hyphen, runs
+ *  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. */
+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. */
+export declare const elementIdConflict: (flat: Record<Element["id"], Element>, id: string, ignoreElementId?: Element["id"]) => string | null;
+/** Whether every id a write brings INTO a document is free: well formed, not already stored, and not repeated
+ *  inside the incoming set — which `elementIdConflict` cannot see on its own, because those elements are not in
+ *  `flat` yet. For a rename, where the element IS stored, call `elementIdConflict` with the new name directly. */
+export declare const elementIdsFree: (flat: Record<Element["id"], Element>, elements: Element[]) => boolean;
+/** How a document mints an id for an element nobody named. Injected rather than chosen here: a live document wants
+ *  uniqueness with no coordination between writers, an authored one wants byte-identical output when re-run, and
+ *  the difference is the caller's to state. See `randomElementId` and `positionalElementId`. */
+export type MintElementId = (type: string, isTaken: (candidate: string) => boolean) => string;
+/** The live-editing minter: `<type>-<4 random chars>`. Random, not positional, because the builder and the MCP
+ *  write concurrently — a counter has two collaborators mint `heading-3` and one of the two writes refused at the
+ *  merge, which is the worst moment to discover it. At the scale of a document four characters are plenty, and the
+ *  name is a default the author renames. */
+export declare const randomElementId: MintElementId;
+/** The offline-authoring minter: `<type>-<n>`, incrementing until `isTaken` says it is free. Deterministic, so a
+ *  seed or a transformer re-run writes the same document it wrote last time and a diff against a committed copy
+ *  stays empty. The hyphen sits between two alphanumeric runs, so it is valid and readable. */
+export declare const positionalElementId: MintElementId;
+/**
+ * `desired` when it is free, else the next number after it — the readable answer to a name collision.
+ *
+ * A copy of `hero` is `hero-2`, not `container-7`: the whole value of a name is that the copy still says what it
+ * is. A name that ALREADY ends in a number counts on from it rather than stacking another one, so a derived
+ * `container-1` meeting a `container-1` becomes `container-2` and not `container-1-2`. Names degrading this way is
+ * the one cost of a readable unique key, and it is cheaper than the alternative.
+ */
+export declare const uniqueElementId: (desired: string, isTaken: (candidate: string) => boolean) => string;
+/**
+ * Apply a renaming (old id → new id) across a set of elements: every reference written against the old name, and
+ * the elements' own identity.
+ *
+ * This is what makes an id both readable and safe to change. It is a field-by-field pass, never a string replace
+ * over the serialized tree: an id is short and human-readable, so replacing "card-1" everywhere would rewrite it
+ * inside labels, prose, class names and content. So each kind of reference is rewritten where it lives —
+ * structure (`flat` key, `parentId`, `items`, `rootId`, `pages`), the attributes that point at another element,
+ * a binding's `source` and the tokens embedded in its transformers and conditions, and an interaction's target
+ * and params.
+ *
+ * An id absent from the map is left alone, so references leaving this set keep pointing outward, which is what
+ * callers want. `pages` is rewritten in place when given — a page rename is not complete without it.
+ *
+ * Returns the ids, under their new names, of every element it actually wrote to. A caller broadcasting the rename
+ * publishes that set: the element being renamed is almost never the whole of what moved.
+ */
+export declare const repointIds: (flat: Record<Element["id"], Element>, map: Record<Element["id"], Element["id"]>, pages?: Schema["pages"]) => Element["id"][];
+/**
+ * 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
+ * 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.
+ */
+export declare const remapCollidingIds: (elements: Record<Element["id"], Element>, isTaken: (candidate: string) => boolean) => Record<Element["id"], Element["id"]>;

package/dist/helpers/elementId.mjs

@@ -0,0 +1,114 @@
+//#region src/helpers/elementId.ts
+var e = /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9_])?$/, t = (t) => e.test(t), n = (e) => e.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[^A-Za-z]+/, "").replace(/-+$/, ""), r = (e) => new Set(Object.keys(e)), i = (e, n, r) => t(n) ? e[n] && n !== r ? `"${n}" is already used by another element here` : null : `"${n}" is not a valid name: start with a letter, then letters, numbers, hyphens and underscores`, a = (e, t) => {
+	let n = /* @__PURE__ */ new Set();
+	for (let r of t) {
+		if (n.has(r.id) || i(e, r.id)) return !1;
+		n.add(r.id);
+	}
+	return !0;
+}, o = (e) => e.replace(/[^A-Za-z0-9]/g, "") || "element", s = "abcdefghijklmnopqrstuvwxyz0123456789", c = (e, t) => {
+	let n = o(e);
+	for (let e = 0; e < 100; e += 1) {
+		let e = "";
+		for (let t = 0; t < 4; t += 1) e += s[Math.floor(Math.random() * s.length)];
+		if (!t(`${n}-${e}`)) return `${n}-${e}`;
+	}
+	return l(e, t);
+}, l = (e, t) => {
+	let n = o(e), r = 1;
+	for (; t(`${n}-${r}`);) r += 1;
+	return `${n}-${r}`;
+}, u = (e, t) => {
+	if (!t(e)) return e;
+	let n = /^(.*[A-Za-z0-9])-(\d+)$/.exec(e), r = n ? n[1] : e, i = n ? Number(n[2]) + 1 : 2;
+	for (; t(`${r}-${i}`);) i += 1;
+	return `${r}-${i}`;
+}, d = {
+	page: [{ attribute: "layout" }, { attribute: "layoutContainer" }],
+	reference: [{
+		attribute: "referenceId",
+		when: (e) => e.referenceType === "element"
+	}],
+	link: [{
+		attribute: "href",
+		when: (e) => e.mode === "page"
+	}]
+}, f = { navigate: [{
+	param: "url",
+	when: (e) => e.urlType === "page"
+}] }, p = (e, t) => {
+	let n = e.indexOf("."), r = n === -1 ? e : e.slice(0, n), i = r.indexOf("_");
+	if (i === -1) return e;
+	let a = t[r.slice(i + 1)];
+	return a ? `${r.slice(0, i + 1)}${a}${n === -1 ? "" : e.slice(n)}` : e;
+}, m = /([A-Za-z][A-Za-z0-9]*)_([A-Za-z][A-Za-z0-9_-]*)/g, h = (e, t) => e.replace(m, (e, n, r) => {
+	let i = t[r];
+	return i ? `${n}_${i}` : e;
+}), g = (e, t) => {
+	let n = !1;
+	if (Array.isArray(e)) return e.forEach((r, i) => {
+		if (typeof r == "string") {
+			let a = h(r, t);
+			a !== r && (e[i] = a, n = !0);
+			return;
+		}
+		n = g(r, t) || n;
+	}), n;
+	if (!e || typeof e != "object") return !1;
+	let r = e;
+	for (let [e, i] of Object.entries(r)) {
+		if (typeof i == "string") {
+			let a = h(i, t);
+			a !== i && (r[e] = a, n = !0);
+			continue;
+		}
+		n = g(i, t) || n;
+	}
+	return n;
+}, _ = (e, t, n) => {
+	let r = Object.entries(t).filter(([e, t]) => e !== t);
+	if (r.length === 0) return [];
+	let i = (e) => t[e] ?? e, a = /* @__PURE__ */ new Set();
+	for (let n of Object.values(e)) {
+		let e = !1;
+		t[n.id] && (n.id = t[n.id], e = !0);
+		let { definition: r, attributes: o } = n;
+		t[r.rootId] && (r.rootId = t[r.rootId], e = !0), r.parentId && t[r.parentId] && (r.parentId = t[r.parentId], e = !0), r.items?.some((e) => t[e]) && (r.items = r.items.map(i), e = !0);
+		for (let { attribute: n, when: i } of d[r.type] ?? []) {
+			let r = o[n];
+			typeof r == "string" && t[r] && (!i || i(o)) && (o[n] = t[r], 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);
+		}
+		for (let n of Object.values(r.interactions ?? {})) {
+			n.elementId && t[n.elementId] && (n.elementId = t[n.elementId], e = !0);
+			for (let { param: r, when: i } of f[n.action] ?? []) {
+				let a = n.params[r];
+				typeof a == "string" && t[a] && (!i || i(n.params)) && (n.params[r] = t[a], e = !0);
+			}
+			g(n.params, t) && (e = !0), n.when && g(n.when, t) && (e = !0);
+		}
+		e && a.add(n.id);
+	}
+	let o = r.filter(([t]) => e[t] !== void 0), s = o.map(([t, n]) => [n, e[t]]);
+	for (let [t] of o) delete e[t];
+	for (let [t, n] of s) e[t] = n;
+	return n && n.forEach((e, r) => {
+		t[e] && (n[r] = t[e]);
+	}), [...a];
+}, v = (e, t) => {
+	let n = {}, r = /* @__PURE__ */ new Set();
+	for (let i of Object.values(e)) {
+		if (!t(i.id)) {
+			r.add(i.id);
+			continue;
+		}
+		let a = u(i.id, (n) => t(n) || r.has(n) || e[n] !== void 0);
+		r.add(a), n[i.id] = a;
+	}
+	return _(e, n), n;
+};
+//#endregion
+export { i as elementIdConflict, a as elementIdsFree, t as isValidElementId, l as positionalElementId, c as randomElementId, v as remapCollidingIds, _ as repointIds, n as slugifyElementId, r as takenIds, u as uniqueElementId };

package/dist/helpers/schemaValidator.d.ts

@@ -1,6 +1,14 @@
 import { Schema } from '@plitzi/sdk-shared';
 export type SchemaValidationOptions = {
     baseElementId?: string;
+    /**
+     * Element type → the source name it publishes under.
+     *
+     * Without it a binding's source can only be half-checked: the type half is compared against the types that
+     * happen to be in this document, so a typo'd id is caught only when some element of that same type is present,
+     * and a prefix that is simply the wrong word for the element it names is never caught at all.
+     */
+    sourceTypes?: Record<string, string>;
 };
 export type SchemaValidationError = {
     code: string;