@plitzi/sdk-schema 0.33.2 → 0.34.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @plitzi/sdk-schema
 
+## 0.34.1
+
+### Patch Changes
+
+- v0.34.1
+- Updated dependencies
+  - @plitzi/sdk-shared@0.34.1
+  - @plitzi/sdk-style@0.34.1
+
+## 0.34.0
+
+### Minor Changes
+
+- v0.34.0
+
+### Patch Changes
+
+- Updated dependencies [5aceda0]
+- Updated dependencies
+- Updated dependencies [5aceda0]
+  - @plitzi/sdk-shared@0.34.0
+  - @plitzi/sdk-style@0.34.0
+
 ## 0.33.2
 
 ### Patch Changes

package/dist/SchemaReducer.d.ts

@@ -1,4 +1,4 @@
-import { Element, PageFolder, Schema, SchemaVariable, DropPosition, Style } from '@plitzi/sdk-shared';
+import { Element, PageFolder, ReducerActionOrigin, Schema, SchemaVariable, DropPosition, Style } from '@plitzi/sdk-shared';
 export declare const SchemaActions: {
     readonly SCHEMA_UPDATE: "SCHEMA_UPDATE";
     readonly SCHEMA_ADD_PAGE: "SCHEMA_ADD_PAGE";
@@ -16,13 +16,12 @@ export declare const SchemaActions: {
     readonly SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT";
     readonly SCHEMA_CLONE_ELEMENT: "SCHEMA_CLONE_ELEMENT";
     readonly SCHEMA_UPDATE_ELEMENT: "SCHEMA_UPDATE_ELEMENT";
+    readonly SCHEMA_RENAME_ELEMENT: "SCHEMA_RENAME_ELEMENT";
     readonly SCHEMA_UPDATE_ELEMENTS: "SCHEMA_UPDATE_ELEMENTS";
     readonly SCHEMA_ADD_TEMPLATE: "SCHEMA_ADD_TEMPLATE";
     readonly SCHEMA_UPDATE_SETTINGS: "SCHEMA_UPDATE_SETTINGS";
 };
-export type SchemaReducerActionsBase = {
-    fromSubscriptions?: boolean;
-};
+export type SchemaReducerActionsBase = ReducerActionOrigin;
 export type SchemaReducerActions = SchemaReducerActionsBase & ({
     type: 'SCHEMA_UPDATE';
     schema: Schema;
@@ -82,6 +81,10 @@ export type SchemaReducerActions = SchemaReducerActionsBase & ({
 } | {
     type: 'SCHEMA_UPDATE_ELEMENT';
     element: Element;
+} | {
+    type: 'SCHEMA_RENAME_ELEMENT';
+    elementId: string;
+    id: string;
 } | {
     type: 'SCHEMA_UPDATE_ELEMENTS';
     elements: Element[];

package/dist/SchemaReducer.mjs

@@ -1,8 +1,13 @@
-import e from "./helpers/FlatMap.mjs";
-import { get as t, has as n, set as r } from "@plitzi/plitzi-ui/helpers";
-import { produce as i } from "immer";
+import { remapCollidingIds as e, takenIds as t } from "./helpers/elementId.mjs";
+import n from "./helpers/FlatMap.mjs";
+import { get as r, has as i, set as a } from "@plitzi/plitzi-ui/helpers";
+import { produce as o } from "immer";
 //#region src/SchemaReducer.ts
-var a = {
+var s = (e, t) => {
+	if (t.length === 0) return;
+	let n = t.filter((t) => e.variables && !e.variables.find((e) => e.name === t.name));
+	a(e, "variables", [...e.variables ?? [], ...n]);
+}, c = {
 	SCHEMA_UPDATE: "SCHEMA_UPDATE",
 	SCHEMA_ADD_PAGE: "SCHEMA_ADD_PAGE",
 	SCHEMA_HOME_PAGE: "SCHEMA_HOME_PAGE",
@@ -19,134 +24,147 @@ var a = {
 	SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT",
 	SCHEMA_CLONE_ELEMENT: "SCHEMA_CLONE_ELEMENT",
 	SCHEMA_UPDATE_ELEMENT: "SCHEMA_UPDATE_ELEMENT",
+	SCHEMA_RENAME_ELEMENT: "SCHEMA_RENAME_ELEMENT",
 	SCHEMA_UPDATE_ELEMENTS: "SCHEMA_UPDATE_ELEMENTS",
 	SCHEMA_ADD_TEMPLATE: "SCHEMA_ADD_TEMPLATE",
 	SCHEMA_UPDATE_SETTINGS: "SCHEMA_UPDATE_SETTINGS"
-}, o = (o, s) => {
-	switch (s.type) {
-		case a.SCHEMA_UPDATE: return {
-			...o,
-			...s.schema
+}, l = (l, u) => {
+	switch (u.type) {
+		case c.SCHEMA_UPDATE: return {
+			...l,
+			...u.schema
 		};
-		case a.SCHEMA_ADD_PAGE: {
-			let { page: e } = s;
-			return i(o, (t) => {
-				r(t, "flat", {
+		case c.SCHEMA_ADD_PAGE: {
+			let { page: e } = u;
+			return o(l, (t) => {
+				a(t, "flat", {
 					...t.flat,
 					[e.id]: e
 				}), t.pages.push(e.id);
 			});
 		}
-		case a.SCHEMA_HOME_PAGE: {
-			let { flat: e, pages: n } = o, { pageId: a } = s, c;
-			return n.forEach((n) => {
-				if (c) return;
-				let r = e[n];
-				t(r, "attributes.default", !1) && (c = r);
-			}), c ? i(o, (e) => {
-				r(e.flat, `${a}.attributes.default`, !0), r(e.flat, `${c.id}.attributes.default`, !1);
-			}) : i(o, (e) => {
-				r(e.flat, `${a}.attributes.default`, !0);
+		case c.SCHEMA_HOME_PAGE: {
+			let { flat: e, pages: t } = l, { pageId: n } = u, i;
+			return t.forEach((t) => {
+				if (i) return;
+				let n = e[t];
+				r(n, "attributes.default", !1) && (i = n);
+			}), i ? o(l, (e) => {
+				a(e.flat, `${n}.attributes.default`, !0), a(e.flat, `${i.id}.attributes.default`, !1);
+			}) : o(l, (e) => {
+				a(e.flat, `${n}.attributes.default`, !0);
 			});
 		}
-		case a.SCHEMA_UPDATE_PAGE: {
-			let { page: e } = s;
-			return i(o, (t) => {
-				r(t.flat, e.id, e);
+		case c.SCHEMA_UPDATE_PAGE: {
+			let { page: e } = u;
+			return o(l, (t) => {
+				a(t.flat, e.id, e);
 			});
 		}
-		case a.SCHEMA_REMOVE_PAGE: {
-			let { pageId: t } = s;
-			return i(o, (n) => {
-				e.removeElement(n.flat, t, !0), n.pages = n.pages.filter((e) => e !== t);
+		case c.SCHEMA_REMOVE_PAGE: {
+			let { pageId: e } = u;
+			return o(l, (t) => {
+				n.removeElement(t.flat, e, !0), t.pages = t.pages.filter((t) => t !== e);
 			});
 		}
-		case a.SCHEMA_ADD_PAGE_FOLDER: {
-			let { pageFolder: e } = s;
-			return i(o, (t) => {
+		case c.SCHEMA_ADD_PAGE_FOLDER: {
+			let { pageFolder: e } = u;
+			return o(l, (t) => {
 				t.pageFolders.push(e);
 			});
 		}
-		case a.SCHEMA_UPDATE_PAGE_FOLDER: {
-			let { pageFolder: e } = s;
-			return i(o, (t) => {
+		case c.SCHEMA_UPDATE_PAGE_FOLDER: {
+			let { pageFolder: e } = u;
+			return o(l, (t) => {
 				let n = t.pageFolders.findIndex((t) => t.id === e.id);
 				n !== -1 && (t.pageFolders[n] = e);
 			});
 		}
-		case a.SCHEMA_REMOVE_PAGE_FOLDER: {
-			let { pageFolderId: e } = s;
-			return i(o, (t) => {
+		case c.SCHEMA_REMOVE_PAGE_FOLDER: {
+			let { pageFolderId: e } = u;
+			return o(l, (t) => {
 				t.pageFolders = t.pageFolders.filter((t) => t.id !== e);
 			});
 		}
-		case a.SCHEMA_ADD_VARIABLE: {
-			let { variable: e } = s;
-			return i(o, (t) => {
+		case c.SCHEMA_ADD_VARIABLE: {
+			let { variable: e } = u;
+			return o(l, (t) => {
 				t.variables ||= [], t.variables.push(e);
 			});
 		}
-		case a.SCHEMA_UPDATE_VARIABLE: {
-			let { variable: e } = s;
-			return o.variables ? i(o, (t) => {
+		case c.SCHEMA_UPDATE_VARIABLE: {
+			let { variable: e } = u;
+			return l.variables ? o(l, (t) => {
 				let n = t.variables.findIndex((t) => t.name === e.name);
 				t.variables[n] && (t.variables[n] = e);
-			}) : o;
+			}) : l;
 		}
-		case a.SCHEMA_REMOVE_VARIABLE: {
-			let { name: e } = s;
-			return o.variables ? i(o, (t) => {
+		case c.SCHEMA_REMOVE_VARIABLE: {
+			let { name: e } = u;
+			return l.variables ? o(l, (t) => {
 				t.variables = t.variables.filter((t) => t.name !== e);
-			}) : o;
+			}) : l;
 		}
-		case a.SCHEMA_ADD_TEMPLATE:
-		case a.SCHEMA_ADD_ELEMENT: {
-			let { to: t, data: n, dropPosition: a, initialItems: c, variables: l = [] } = s;
-			return i(o, (i) => {
-				if (e.addElement(i.flat, n, t, a, c), l.length > 0) {
-					let e = l.filter((e) => i.variables && !i.variables.find((t) => t.name === e.name));
-					r(i, "variables", [...i.variables ?? [], ...e]);
-				}
+		case c.SCHEMA_ADD_ELEMENT: {
+			let { to: e, data: t, dropPosition: r, initialItems: i, variables: a = [] } = u;
+			return o(l, (o) => {
+				n.addElement(o.flat, t, e, r, i), s(o, a);
 			});
 		}
-		case a.SCHEMA_REMOVE_ELEMENT: {
-			let { elementId: t } = s;
-			return i(o, (n) => {
-				e.removeElement(n.flat, t);
+		case c.SCHEMA_ADD_TEMPLATE: {
+			let { to: r, data: i, dropPosition: a, initialItems: c, variables: d = [] } = u;
+			return o(l, (o) => {
+				let l = structuredClone({
+					[i.id]: i,
+					...c
+				}), u = t(o.flat), f = e(l, (e) => u.has(e))[i.id] ?? i.id, { [f]: p, ...m } = l;
+				n.addElement(o.flat, p, r, a, m), s(o, d);
 			});
 		}
-		case a.SCHEMA_MOVE_ELEMENT: {
-			let { from: t, to: n, elementId: r, dropPosition: a } = s;
-			return i(o, (i) => {
-				e.moveElement(i.flat, t, n, r, a);
+		case c.SCHEMA_REMOVE_ELEMENT: {
+			let { elementId: e } = u;
+			return o(l, (t) => {
+				n.removeElement(t.flat, e);
 			});
 		}
-		case a.SCHEMA_CLONE_ELEMENT: {
-			let { to: t, data: n, dropPosition: r, initialItems: a } = s;
-			return i(o, (i) => {
-				e.addElement(i.flat, n, t, r, a);
+		case c.SCHEMA_MOVE_ELEMENT: {
+			let { from: e, to: t, elementId: r, dropPosition: i } = u;
+			return o(l, (a) => {
+				n.moveElement(a.flat, e, t, r, i);
 			});
 		}
-		case a.SCHEMA_UPDATE_ELEMENT: {
-			let { element: t } = s;
-			return i(o, (n) => {
-				e.updateElement(n.flat, t);
+		case c.SCHEMA_CLONE_ELEMENT: {
+			let { to: e, data: t, dropPosition: r, initialItems: i } = u;
+			return o(l, (a) => {
+				n.addElement(a.flat, t, e, r, i);
 			});
 		}
-		case a.SCHEMA_UPDATE_ELEMENTS: {
-			let { elements: t } = s;
-			return i(o, (n) => {
-				t.forEach((t) => e.updateElement(n.flat, t));
+		case c.SCHEMA_UPDATE_ELEMENT: {
+			let { element: e } = u;
+			return o(l, (t) => {
+				n.updateElement(t.flat, e);
 			});
 		}
-		case a.SCHEMA_UPDATE_SETTINGS: {
-			let { path: e, value: t } = s;
-			return i(o, (i) => {
-				e && n(o.settings, e) ? r(i.settings, e, t) : e || r(i, "settings", t);
+		case c.SCHEMA_RENAME_ELEMENT: {
+			let { elementId: e, id: t } = u;
+			return o(l, (r) => {
+				n.renameElement(r, e, t);
 			});
 		}
-		default: return o;
+		case c.SCHEMA_UPDATE_ELEMENTS: {
+			let { elements: e } = u;
+			return o(l, (t) => {
+				e.forEach((e) => n.updateElement(t.flat, e));
+			});
+		}
+		case c.SCHEMA_UPDATE_SETTINGS: {
+			let { path: e, value: t } = u;
+			return o(l, (n) => {
+				e && i(l.settings, e) ? a(n.settings, e, t) : e || a(n, "settings", t);
+			});
+		}
+		default: return l;
 	}
 };
 //#endregion
-export { a as SchemaActions, o as default };
+export { c as SchemaActions, l as default };

package/dist/helpers/FlatMap.d.ts

@@ -1,29 +1,69 @@
 import { SchemaValidationResult } from './schemaValidator';
+import { MintElementId } from './elementId';
 import { Style, Element, Schema, DropPosition, SchemaVariable } from '@plitzi/sdk-shared';
+/** An element on its way in. Its id is the name it will answer to, and leaving it out asks this map to mint one. */
+export type ElementInput = Omit<Element, 'id'> & {
+    id?: Element['id'];
+};
 export type FlatMapProps = {
     flat?: Schema['flat'];
     variables?: Schema['variables'];
+    /**
+     * The document's page list. Given, a page rename rewrites it too — a page renamed without it is a page the space
+     * no longer lists. Left out for a map that holds no pages (a segment, a template being cut).
+     */
+    pages?: Schema['pages'];
+    /**
+     * How an id is minted for an element nobody named. Defaults to the random minter, which is what a live document
+     * wants: the builder and the MCP write concurrently, and a counter has two writers pick the same name. An
+     * offline author or a test passes a positional one and gets output it can diff.
+     */
+    mintId?: MintElementId;
 };
 declare class FlatMap {
     flat: Schema['flat'];
     variables: Schema['variables'];
+    pages: Schema['pages'];
+    mintId: MintElementId;
     constructor(props?: FlatMapProps);
-    addElement: (data: Element, to: Element["id"], dropPosition?: DropPosition, initialItems?: Record<Element["id"], Element>) => boolean;
-    /** Refuses a rename onto an unusable idRef: two elements answering to the same name make every binding and
-     *  interaction written against it resolve to whichever one is found first. Only a change is checked, so an
-     *  element already stored with a bad ref stays editable.
-     *
-     *  A rename that IS accepted carries its wiring with it: the idRef is the key bindings and interactions target,
-     *  so every reference to the old name across the space is repointed here. Doing it at the single point every
-     *  writer goes through is what keeps a rename from silently unwiring the element. */
+    /** A free id for a new element of `type`, minted through this map's minter and unique against what it holds. */
+    nextId: (type: string, alsoTaken?: (candidate: string) => boolean) => string;
+    /** Inserts an element, minting its id when the caller did not name it. Nothing else in the codebase mints an
+     *  element id: every writer goes through here, so "every element has a name" is true by construction. */
+    addElement: (input: ElementInput, to: Element["id"], dropPosition?: DropPosition, initialItems?: Record<Element["id"], Element>) => boolean;
+    /** Replaces a stored element with an edited copy of itself. The id is its identity, not a field an update may
+     *  carry a new value for — changing the name is `renameElement`, which is a document-wide operation. */
     updateElement: (element?: Element) => boolean;
+    /**
+     * Renames an element, carrying its wiring with it.
+     *
+     * The id IS the name — the `flat` key, what the tree points at, the `<type>_<id>` a binding reads and the target
+     * an interaction fires on — so a rename that only rewrote the key would silently unwire the element and every
+     * reference to it. `repointIds` rewrites all of them in one pass; doing it at the single point every writer goes
+     * through is what makes a readable id safe to change.
+     *
+     * Returns the ids of every element the rename touched (under their new names), which a caller broadcasting the
+     * change has to publish: the one element it renamed is almost never the whole of what moved.
+     */
+    renameElement: (from: Element["id"], to: Element["id"]) => Element["id"][] | false;
+    /** Why this element cannot be renamed to `id` (charset or a clash), or null when the name is free. */
+    renameConflict: (from: Element["id"], id: string) => string | null;
     moveElement: (from: Element["id"], to: Element["id"], elementId: Element["id"], dropPosition?: DropPosition) => boolean;
     getElement: (elementId: Element["id"]) => Element<Record<string, unknown>>;
-    /** Every idRef currently in use, so a newly minted one stays unique across the space. */
-    takenIdRefs: () => Set<string>;
-    /** Why an idRef cannot be used here (charset or a clash), or null when it is free. `ignoreElementId` exempts the
-     *  element being edited, so re-saving an element its own ref is not a conflict. */
-    idRefConflict: (idRef: string, ignoreElementId?: Element["id"]) => string | null;
+    /** Every id currently in use, so a newly minted one stays unique across the document. */
+    takenIds: () => Set<string>;
+    /** Why an id cannot be used here (charset or a clash), or null when it is free. `ignoreElementId` exempts the
+     *  element being edited, so re-saving an element its own name is not a conflict. */
+    elementIdConflict: (id: string, ignoreElementId?: Element["id"]) => string | null;
+    /**
+     * Copies a subtree onto fresh names.
+     *
+     * Every id in the copy is minted here and every reference inside it repointed structurally, field by field. It is
+     * emphatically NOT a string replace over the serialized tree, which is what this used to be: that only ever
+     * worked because an id was 24 improbable hex characters, and with an id that reads like `hero` it would rewrite
+     * the word inside labels, prose, class names and content. References pointing OUT of the subtree are left alone,
+     * so a copy keeps reading the data source it was cloned next to.
+     */
     cloneElements: (elementId: Element["id"], parentId?: Element["id"], rootId?: Element["id"], excludeRoot?: boolean) => {
         acum: Record<Element["id"], Element>;
         item?: Element;
@@ -50,8 +90,9 @@ declare class FlatMap {
     assertValid: (context?: string) => void;
     getElementVariables: (style: Style, elementId: Element["id"], flat?: Record<string, Element<Record<string, unknown>>>, variables?: SchemaVariable[]) => SchemaVariable[];
     static getInstance: (props: FlatMapProps) => FlatMap;
-    static addElement: (flat: Schema["flat"], data: Element, to: Element["id"], dropPosition?: DropPosition, initialItems?: Record<Element["id"], Element>) => boolean;
+    static addElement: (flat: Schema["flat"], data: ElementInput, to: Element["id"], dropPosition?: DropPosition, initialItems?: Record<Element["id"], Element>) => boolean;
     static updateElement: (flat: Schema["flat"], element: Element) => boolean;
+    static renameElement: (schema: Pick<Schema, "flat" | "pages">, from: Element["id"], to: Element["id"]) => false | string[];
     static moveElement: (flat: Schema["flat"], from: Element["id"], to: Element["id"], elementId: Element["id"], dropPosition?: DropPosition) => boolean;
     static getElement: (flat: Schema["flat"], elementId: Element["id"]) => Element<Record<string, unknown>>;
     static cloneElements: (flat: Schema["flat"], elementId: Element["id"], parentId?: Element["id"], rootId?: Element["id"], excludeRoot?: boolean) => {
@@ -59,8 +100,8 @@ declare class FlatMap {
         item?: Element;
     };
     static removeElement: (flat: Schema["flat"], elementId: Element["id"], removePage?: boolean) => boolean;
-    static takenIdRefs: (flat: Schema["flat"]) => Set<string>;
-    static idRefConflict: (flat: Schema["flat"], idRef: string, ignoreElementId?: Element["id"]) => string | null;
+    static takenIds: (flat: Schema["flat"]) => Set<string>;
+    static elementIdConflict: (flat: Schema["flat"], id: string, ignoreElementId?: Element["id"]) => string | null;
     static addVariables: (schemaVariables: Schema["variables"], variables: Schema["variables"]) => boolean;
     static addVariable: (schemaVariables: Schema["variables"], variable: SchemaVariable) => boolean;
     static updateVariable: (schemaVariables: Schema["variables"], variable: SchemaVariable) => boolean;