@plitzi/sdk-schema 0.37.8 → 0.37.10

package/dist/SchemaReducer.d.ts

@@ -1,4 +1,4 @@
-import { Element, PageFolder, ReducerActionOrigin, Schema, SchemaVariable, DropPosition, Style } from '@plitzi/sdk-shared';
+import { Element, PageFolder, ReducerActionOrigin, Schema, SnippetStyle, SchemaFlag, SchemaVariable, DropPosition, SpaceComponent, SpaceComponentDeclaration } from '@plitzi/sdk-shared';
 export declare const SchemaActions: {
     readonly SCHEMA_UPDATE: "SCHEMA_UPDATE";
     readonly SCHEMA_ADD_PAGE: "SCHEMA_ADD_PAGE";
@@ -11,6 +11,8 @@ export declare const SchemaActions: {
     readonly SCHEMA_ADD_VARIABLE: "SCHEMA_ADD_VARIABLE";
     readonly SCHEMA_UPDATE_VARIABLE: "SCHEMA_UPDATE_VARIABLE";
     readonly SCHEMA_REMOVE_VARIABLE: "SCHEMA_REMOVE_VARIABLE";
+    readonly SCHEMA_SET_FLAG: "SCHEMA_SET_FLAG";
+    readonly SCHEMA_REMOVE_FLAG: "SCHEMA_REMOVE_FLAG";
     readonly SCHEMA_ADD_ELEMENT: "SCHEMA_ADD_ELEMENT";
     readonly SCHEMA_REMOVE_ELEMENT: "SCHEMA_REMOVE_ELEMENT";
     readonly SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT";
@@ -18,8 +20,12 @@ export declare const SchemaActions: {
     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_ADD_SNIPPET: "SCHEMA_ADD_SNIPPET";
     readonly SCHEMA_UPDATE_SETTINGS: "SCHEMA_UPDATE_SETTINGS";
+    readonly SCHEMA_ADD_COMPONENT: "SCHEMA_ADD_COMPONENT";
+    readonly SCHEMA_UPDATE_COMPONENT: "SCHEMA_UPDATE_COMPONENT";
+    readonly SCHEMA_REMOVE_COMPONENT: "SCHEMA_REMOVE_COMPONENT";
+    readonly SCHEMA_DETACH_INSTANCE: "SCHEMA_DETACH_INSTANCE";
 };
 export type SchemaReducerActionsBase = ReducerActionOrigin;
 export type SchemaReducerActions = SchemaReducerActionsBase & ({
@@ -56,13 +62,20 @@ export type SchemaReducerActions = SchemaReducerActionsBase & ({
     type: 'SCHEMA_REMOVE_VARIABLE';
     name: string;
 } | {
-    type: 'SCHEMA_ADD_ELEMENT' | 'SCHEMA_ADD_TEMPLATE';
+    type: 'SCHEMA_SET_FLAG';
+    name: string;
+    flag: SchemaFlag;
+} | {
+    type: 'SCHEMA_REMOVE_FLAG';
+    name: string;
+} | {
+    type: 'SCHEMA_ADD_ELEMENT' | 'SCHEMA_ADD_SNIPPET';
     to: string;
     data: Element;
     dropPosition: DropPosition;
     initialItems: Record<string, Element>;
     variables?: SchemaVariable[];
-    style?: Style;
+    style?: SnippetStyle;
 } | {
     type: 'SCHEMA_REMOVE_ELEMENT';
     elementId: string;
@@ -92,6 +105,23 @@ export type SchemaReducerActions = SchemaReducerActionsBase & ({
     type: 'SCHEMA_UPDATE_SETTINGS';
     path: string;
     value: string | number | boolean;
+} | {
+    type: 'SCHEMA_ADD_COMPONENT';
+    component: SpaceComponent;
+    from?: {
+        elementId: Element['id'];
+        instanceId: Element['id'];
+    };
+} | {
+    type: 'SCHEMA_UPDATE_COMPONENT';
+    componentId: SpaceComponent['id'];
+    declaration: SpaceComponentDeclaration;
+} | {
+    type: 'SCHEMA_REMOVE_COMPONENT';
+    componentId: SpaceComponent['id'];
+} | {
+    type: 'SCHEMA_DETACH_INSTANCE';
+    instanceId: Element['id'];
 });
 declare const SchemaReducer: (state: Schema, action: SchemaReducerActions) => Schema;
 export default SchemaReducer;

package/dist/SchemaReducer.mjs

@@ -1,13 +1,13 @@
-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";
+import e from "./helpers/FlatMap.mjs";
+import { addComponent as t, detachInstance as n, flatMapOf as r, removeComponent as i, renameElement as a, updateComponent as o } from "./helpers/components.mjs";
+import { get as s, has as c, set as l } from "@plitzi/plitzi-ui/helpers";
+import { produce as u } from "immer";
 //#region src/SchemaReducer.ts
-var s = (e, t) => {
+var d = (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 = {
+	l(e, "variables", [...e.variables ?? [], ...n]);
+}, f = {
 	SCHEMA_UPDATE: "SCHEMA_UPDATE",
 	SCHEMA_ADD_PAGE: "SCHEMA_ADD_PAGE",
 	SCHEMA_HOME_PAGE: "SCHEMA_HOME_PAGE",
@@ -19,6 +19,8 @@ var s = (e, t) => {
 	SCHEMA_ADD_VARIABLE: "SCHEMA_ADD_VARIABLE",
 	SCHEMA_UPDATE_VARIABLE: "SCHEMA_UPDATE_VARIABLE",
 	SCHEMA_REMOVE_VARIABLE: "SCHEMA_REMOVE_VARIABLE",
+	SCHEMA_SET_FLAG: "SCHEMA_SET_FLAG",
+	SCHEMA_REMOVE_FLAG: "SCHEMA_REMOVE_FLAG",
 	SCHEMA_ADD_ELEMENT: "SCHEMA_ADD_ELEMENT",
 	SCHEMA_REMOVE_ELEMENT: "SCHEMA_REMOVE_ELEMENT",
 	SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT",
@@ -26,145 +28,190 @@ var s = (e, t) => {
 	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"
-}, l = (l, u) => {
-	switch (u.type) {
-		case c.SCHEMA_UPDATE: return {
-			...l,
-			...u.schema
+	SCHEMA_ADD_SNIPPET: "SCHEMA_ADD_SNIPPET",
+	SCHEMA_UPDATE_SETTINGS: "SCHEMA_UPDATE_SETTINGS",
+	SCHEMA_ADD_COMPONENT: "SCHEMA_ADD_COMPONENT",
+	SCHEMA_UPDATE_COMPONENT: "SCHEMA_UPDATE_COMPONENT",
+	SCHEMA_REMOVE_COMPONENT: "SCHEMA_REMOVE_COMPONENT",
+	SCHEMA_DETACH_INSTANCE: "SCHEMA_DETACH_INSTANCE"
+}, p = (p, m) => {
+	switch (m.type) {
+		case f.SCHEMA_UPDATE: return {
+			...p,
+			...m.schema
 		};
-		case c.SCHEMA_ADD_PAGE: {
-			let { page: e } = u;
-			return o(l, (t) => {
-				a(t, "flat", {
+		case f.SCHEMA_ADD_PAGE: {
+			let { page: e } = m;
+			return u(p, (t) => {
+				l(t, "flat", {
 					...t.flat,
 					[e.id]: e
 				}), t.pages.push(e.id);
 			});
 		}
-		case c.SCHEMA_HOME_PAGE: {
-			let { flat: e, pages: t } = l, { pageId: n } = u, i;
+		case f.SCHEMA_HOME_PAGE: {
+			let { flat: e, pages: t } = p, { pageId: n } = m, r;
 			return t.forEach((t) => {
-				if (i) return;
+				if (r) 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);
+				s(n, "attributes.default", !1) && (r = n);
+			}), r ? u(p, (e) => {
+				l(e.flat, `${n}.attributes.default`, !0), l(e.flat, `${r.id}.attributes.default`, !1);
+			}) : u(p, (e) => {
+				l(e.flat, `${n}.attributes.default`, !0);
 			});
 		}
-		case c.SCHEMA_UPDATE_PAGE: {
-			let { page: e } = u;
-			return o(l, (t) => {
-				a(t.flat, e.id, e);
+		case f.SCHEMA_UPDATE_PAGE: {
+			let { page: e } = m;
+			return u(p, (t) => {
+				l(t.flat, e.id, e);
 			});
 		}
-		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 f.SCHEMA_REMOVE_PAGE: {
+			let { pageId: t } = m;
+			return u(p, (n) => {
+				e.removeElement(n.flat, t, !0), n.pages = n.pages.filter((e) => e !== t);
 			});
 		}
-		case c.SCHEMA_ADD_PAGE_FOLDER: {
-			let { pageFolder: e } = u;
-			return o(l, (t) => {
+		case f.SCHEMA_ADD_PAGE_FOLDER: {
+			let { pageFolder: e } = m;
+			return u(p, (t) => {
 				t.pageFolders.push(e);
 			});
 		}
-		case c.SCHEMA_UPDATE_PAGE_FOLDER: {
-			let { pageFolder: e } = u;
-			return o(l, (t) => {
+		case f.SCHEMA_UPDATE_PAGE_FOLDER: {
+			let { pageFolder: e } = m;
+			return u(p, (t) => {
 				let n = t.pageFolders.findIndex((t) => t.id === e.id);
 				n !== -1 && (t.pageFolders[n] = e);
 			});
 		}
-		case c.SCHEMA_REMOVE_PAGE_FOLDER: {
-			let { pageFolderId: e } = u;
-			return o(l, (t) => {
+		case f.SCHEMA_REMOVE_PAGE_FOLDER: {
+			let { pageFolderId: e } = m;
+			return u(p, (t) => {
 				t.pageFolders = t.pageFolders.filter((t) => t.id !== e);
 			});
 		}
-		case c.SCHEMA_ADD_VARIABLE: {
-			let { variable: e } = u;
-			return o(l, (t) => {
+		case f.SCHEMA_ADD_VARIABLE: {
+			let { variable: e } = m;
+			return u(p, (t) => {
 				t.variables ||= [], t.variables.push(e);
 			});
 		}
-		case c.SCHEMA_UPDATE_VARIABLE: {
-			let { variable: e } = u;
-			return l.variables ? o(l, (t) => {
+		case f.SCHEMA_UPDATE_VARIABLE: {
+			let { variable: e } = m;
+			return p.variables ? u(p, (t) => {
 				let n = t.variables.findIndex((t) => t.name === e.name);
 				t.variables[n] && (t.variables[n] = e);
-			}) : l;
+			}) : p;
 		}
-		case c.SCHEMA_REMOVE_VARIABLE: {
-			let { name: e } = u;
-			return l.variables ? o(l, (t) => {
+		case f.SCHEMA_REMOVE_VARIABLE: {
+			let { name: e } = m;
+			return p.variables ? u(p, (t) => {
 				t.variables = t.variables.filter((t) => t.name !== e);
-			}) : l;
+			}) : p;
 		}
-		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 f.SCHEMA_SET_FLAG: {
+			let { name: e, flag: t } = m;
+			return u(p, (n) => {
+				n.flags = {
+					...n.flags,
+					[e]: 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 f.SCHEMA_REMOVE_FLAG: {
+			let { name: e } = m;
+			return !p.flags || !Object.hasOwn(p.flags, e) ? p : u(p, (t) => {
+				let { [e]: n, ...r } = t.flags ?? {};
+				t.flags = r;
 			});
 		}
-		case c.SCHEMA_REMOVE_ELEMENT: {
-			let { elementId: e } = u;
-			return o(l, (t) => {
-				n.removeElement(t.flat, e);
+		case f.SCHEMA_ADD_ELEMENT: {
+			let { to: e, data: t, dropPosition: n, initialItems: i, variables: a = [] } = m;
+			return u(p, (o) => {
+				r(o, e)?.addElement(t, e, n, i), d(o, 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 f.SCHEMA_ADD_SNIPPET: {
+			let { to: e, data: t, dropPosition: n, initialItems: i, variables: a = [] } = m;
+			return u(p, (o) => {
+				let { [t.id]: s, ...c } = structuredClone({
+					...i,
+					[t.id]: t
+				});
+				r(o, e)?.addElement(s, e, n, c) && d(o, a);
 			});
 		}
-		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 f.SCHEMA_REMOVE_ELEMENT: {
+			let { elementId: e } = m;
+			return u(p, (t) => {
+				r(t, e)?.removeElement(e);
 			});
 		}
-		case c.SCHEMA_UPDATE_ELEMENT: {
-			let { element: e } = u;
-			return o(l, (t) => {
-				n.updateElement(t.flat, e);
+		case f.SCHEMA_MOVE_ELEMENT: {
+			let { from: e, to: t, elementId: n, dropPosition: i } = m;
+			return u(p, (a) => {
+				let o = r(a, n);
+				o && Object.hasOwn(o.flat, t) && o.moveElement(e, t, n, i);
 			});
 		}
-		case c.SCHEMA_RENAME_ELEMENT: {
-			let { elementId: e, id: t } = u;
-			return o(l, (r) => {
-				n.renameElement(r, e, t);
+		case f.SCHEMA_CLONE_ELEMENT: {
+			let { to: e, data: t, dropPosition: n, initialItems: i } = m;
+			return u(p, (a) => {
+				r(a, e)?.addElement(t, e, n, i);
 			});
 		}
-		case c.SCHEMA_UPDATE_ELEMENTS: {
-			let { elements: e } = u;
-			return o(l, (t) => {
-				e.forEach((e) => n.updateElement(t.flat, e));
+		case f.SCHEMA_UPDATE_ELEMENT: {
+			let { element: e } = m;
+			return u(p, (t) => {
+				r(t, e.id)?.updateElement(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);
+		case f.SCHEMA_RENAME_ELEMENT: {
+			let { elementId: e, id: t } = m;
+			return u(p, (n) => {
+				a(n, e, t);
 			});
 		}
-		default: return l;
+		case f.SCHEMA_UPDATE_ELEMENTS: {
+			let { elements: e } = m;
+			return u(p, (t) => {
+				e.forEach((e) => r(t, e.id)?.updateElement(e));
+			});
+		}
+		case f.SCHEMA_UPDATE_SETTINGS: {
+			let { path: e, value: t } = m;
+			return u(p, (n) => {
+				e && c(p.settings, e) ? l(n.settings, e, t) : e || l(n, "settings", t);
+			});
+		}
+		case f.SCHEMA_ADD_COMPONENT: {
+			let { component: e, from: n } = m;
+			return u(p, (r) => {
+				t(r, structuredClone(e), n);
+			});
+		}
+		case f.SCHEMA_UPDATE_COMPONENT: {
+			let { componentId: e, declaration: t } = m;
+			return u(p, (n) => {
+				o(n, e, t);
+			});
+		}
+		case f.SCHEMA_REMOVE_COMPONENT: {
+			let { componentId: e } = m;
+			return u(p, (t) => {
+				i(t, e);
+			});
+		}
+		case f.SCHEMA_DETACH_INSTANCE: {
+			let { instanceId: e } = m;
+			return u(p, (t) => {
+				n(t, e);
+			});
+		}
+		default: return p;
 	}
 };
 //#endregion
-export { c as SchemaActions, l as default };
+export { f as SchemaActions, p as default };

package/dist/helpers/FlatMap.d.ts

@@ -9,9 +9,14 @@ export type FlatMapProps = {
     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).
+     * no longer lists. Left out for a map that holds no pages (a component's tree, a snippet being cut).
      */
     pages?: Schema['pages'];
+    /**
+     * The ids the rest of the document holds, for a map over one of its trees: ids are one namespace across the space's
+     * `flat` and every component's, so a name free in this tree may still be taken in another.
+     */
+    takenElsewhere?: (id: Element['id']) => boolean;
     /**
      * 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
@@ -24,6 +29,7 @@ declare class FlatMap {
     variables: Schema['variables'];
     pages: Schema['pages'];
     mintId: MintElementId;
+    takenElsewhere: (id: Element['id']) => boolean;
     constructor(props?: FlatMapProps);
     /** 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;
@@ -79,7 +85,7 @@ declare class FlatMap {
     removeVariables: (variables: string[]) => boolean;
     removeVariable: (variable: string) => boolean;
     isValidElement: (element?: Partial<Element>) => boolean;
-    flatAsTemplate: (style: Style, elementId: Element["id"], excludeRoot?: boolean) => {
+    flatAsSnippet: (style: Style, elementId: Element["id"], excludeRoot?: boolean) => {
         elements: {
             acum: Record<Element["id"], Element>;
             item?: Element;
@@ -102,7 +108,7 @@ declare class FlatMap {
     static addVariable: (schemaVariables: Schema["variables"], variable: SchemaVariable) => boolean;
     static updateVariable: (schemaVariables: Schema["variables"], variable: SchemaVariable) => boolean;
     static removeVariable: (schemaVariables: Schema["variables"], variable: string) => boolean;
-    static flatAsTemplate: (schema: Schema, style: Style, elementId: Element["id"], excludeRoot?: boolean) => {
+    static flatAsSnippet: (schema: Schema, style: Style, elementId: Element["id"], excludeRoot?: boolean) => {
         elements: {
             acum: Record<Element["id"], Element>;
             item?: Element;

package/dist/helpers/FlatMap.mjs

@@ -9,21 +9,22 @@ var d = class {
 	variables;
 	pages;
 	mintId;
+	takenElsewhere;
 	constructor(e = {}) {
-		let { flat: t, variables: r, pages: i, mintId: a } = e;
+		let { flat: t, variables: r, pages: i, mintId: a, takenElsewhere: o } = e;
 		if (!t) throw Error("Flat is required");
-		this.flat = t, this.variables = r ?? [], this.pages = i ?? [], this.mintId = a ?? n;
+		this.flat = t, this.variables = r ?? [], this.pages = i ?? [], this.mintId = a ?? n, this.takenElsewhere = o ?? (() => !1);
 	}
 	nextId = (e, t = () => !1) => {
 		let n = i(this.flat);
-		return this.mintId(e, (e) => n.has(e) || t(e));
+		return this.mintId(e, (e) => n.has(e) || this.takenElsewhere(e) || t(e));
 	};
 	addElement = (e, n, r = "inside", i = {}) => {
 		let a = e.id ? e : {
 			...e,
 			id: this.nextId(e.definition.type)
-		};
-		if (!this.isValidElement(a) || !t(this.flat, [a, ...Object.values(i)])) return !1;
+		}, o = [a, ...Object.values(i)];
+		if (!this.isValidElement(a) || !t(this.flat, o) || o.some((e) => this.takenElsewhere(e.id))) return !1;
 		if (r !== "custom") {
 			let e = this.placement(n, r, [a.id]);
 			if (!e) return !1;
@@ -47,7 +48,7 @@ var d = class {
 		});
 	};
 	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;
+	renameElement = (t, n) => this.flat[t] ? t === n ? [] : e(this.flat, n) || this.takenElsewhere(n) ? !1 : r(this.flat, { [t]: n }, this.pages) : !1;
 	moveElement = (e, t, n, r = "inside") => {
 		let i = this.flat[e], a = this.flat[n];
 		if (!i || !a || n === t || s(this.flat, t).includes(n)) return !1;
@@ -65,7 +66,7 @@ var d = class {
 		if (!u) return c;
 		let d = [e, ...o(this.flat, e)], f = i(this.flat);
 		for (let e of d) {
-			let t = a(e, (e) => f.has(e));
+			let t = a(e, (e) => f.has(e) || this.takenElsewhere(e));
 			f.add(t), l[e] = t;
 		}
 		let p = {};
@@ -110,7 +111,7 @@ var d = class {
 		let { type: i, label: a, styleSelectors: o, rootId: s } = r;
 		return !(!i || a === void 0 || typeof o != "object" || s === void 0);
 	};
-	flatAsTemplate = (e, t, n = !1) => {
+	flatAsSnippet = (e, t, n = !1) => {
 		let r = {
 			...l,
 			platform: {
@@ -187,12 +188,12 @@ var d = class {
 	static addVariable = (e, t) => this.getInstance({ variables: e }).addVariable(t);
 	static updateVariable = (e, t) => this.getInstance({ variables: e }).updateVariable(t);
 	static removeVariable = (e, t) => this.getInstance({ variables: e }).removeVariable(t);
-	static flatAsTemplate = (e, t, n, r = !1) => {
+	static flatAsSnippet = (e, t, n, r = !1) => {
 		let { flat: i, variables: a } = e;
 		return this.getInstance({
 			flat: i,
 			variables: a
-		}).flatAsTemplate(t, n, r);
+		}).flatAsSnippet(t, n, r);
 	};
 };
 //#endregion

package/dist/helpers/components.d.ts

@@ -0,0 +1,68 @@
+import { default as FlatMap } from './FlatMap';
+import { MintElementId } from './elementId';
+import { Element, Schema, SpaceComponent, SpaceComponentDeclaration } from '@plitzi/sdk-shared';
+/** The parts of a schema that hold elements: the pages' tree and every component's. */
+export type ElementDocument = Pick<Schema, 'flat' | 'pages' | 'components'>;
+/** One tree of a document: the space's own `flat`, or the one of the component named. */
+export type ElementTree = {
+    flat: Schema['flat'];
+    componentId?: SpaceComponent['id'];
+};
+/**
+ * Attributes an instance already answers to, so a prop may not be called one of them: a prop IS an attribute of the
+ * instance, and a prop named `referenceId` would be the instance pointing at another component.
+ */
+export declare const RESERVED_PROP_NAMES: ReadonlySet<string>;
+/** Why `name` cannot be a prop, phrased for a person, or null when it can. */
+export declare const propNameProblem: (name: string) => string | null;
+export declare const treesOf: (schema: Pick<Schema, "flat" | "components">) => ElementTree[];
+/** The tree `id` lives in. Ids are one namespace across the document, so there is at most one. */
+export declare const treeOf: (schema: Pick<Schema, "flat" | "components">, id: Element["id"]) => ElementTree | undefined;
+/** Every element id the document holds, in any tree. */
+export declare const documentIds: (schema: Pick<Schema, "flat" | "components">) => Set<Element["id"]>;
+/**
+ * A `FlatMap` over the tree that holds `id`, held to the ids every other tree holds.
+ *
+ * What lets an element edit carry nothing but the element: its id already says which tree it is in, so the writers
+ * of a space — the builder's reducer and the server's model — resolve the tree here and edit it as they always have.
+ */
+export declare const flatMapOf: (schema: ElementDocument, id: Element["id"], mintId?: MintElementId) => FlatMap | undefined;
+/** The component declared under `componentId`, if any: a key read off a document cannot be trusted to be there. */
+export declare const componentNamed: (schema: Pick<Schema, "components">, componentId: SpaceComponent["id"]) => SpaceComponent | undefined;
+/** Whether `element` is an instance — of `componentId`, when one is named. */
+export declare const isInstance: (element: Element, componentId?: SpaceComponent["id"]) => boolean;
+/** Every instance of a component, wherever it is placed: on a page, in a layout or inside another component. */
+export declare const instancesOf: (schema: Pick<Schema, "flat" | "components">, componentId: SpaceComponent["id"]) => Element[];
+/**
+ * Renames an element wherever it is, carrying every reference to it — in any tree.
+ *
+ * The element's own tree is rewritten by `FlatMap`, as a rename always was; the others are rewritten too, because a
+ * page can name an element of a component as little as a component can name a page, and the declarations name their
+ * roots and slots. Returns the ids of everything it touched, under their new names.
+ */
+export declare const renameElement: (schema: ElementDocument, from: Element["id"], to: Element["id"]) => Element["id"][] | false;
+/**
+ * Declares a component.
+ *
+ * With `from`, the component is made OF an element already in the document: the subtree leaves its tree for the
+ * component's, and an instance named `from.instanceId` takes its place, so the page renders what it rendered. Without
+ * it, the component brings its own tree. Both sides of a live document apply the same call and arrive at the same
+ * document, which is why the instance's name is the caller's to give. Returns false, changing nothing, when the
+ * component cannot be declared — a name taken, a tree that is not one, a declaration its tree does not bear out.
+ */
+export declare const addComponent: (schema: ElementDocument, component: SpaceComponent, from?: {
+    elementId: Element["id"];
+    instanceId: Element["id"];
+}) => boolean;
+/** Changes what a component declares — never its tree, which is edited element by element like any other. */
+export declare const updateComponent: (schema: Pick<Schema, "components">, componentId: SpaceComponent["id"], declaration: SpaceComponentDeclaration) => boolean;
+/** Removes a component nothing places any more. One still placed is refused: its instances would render nothing. */
+export declare const removeComponent: (schema: Pick<Schema, "flat" | "components">, componentId: SpaceComponent["id"]) => boolean;
+/**
+ * Replaces an instance with a copy of what its component renders, which is then the page's own to edit.
+ *
+ * The copy takes names derived from the component's (`card` → `card-2`), each the first one free in the document,
+ * so every side of a live document that applies it arrives at the same names. What filled the instance's slots goes
+ * into the copies of those slots. Refused when a child has no slot to go to. Returns the copy's root id.
+ */
+export declare const detachInstance: (schema: ElementDocument, instanceId: Element["id"]) => Element["id"] | false;