@plitzi/sdk-schema 0.30.19

package/dist/SchemaReducer.d.ts

@@ -0,0 +1,90 @@
+import { Element, PageFolder, Schema, SchemaVariable, DropPosition, Style } from '@plitzi/sdk-shared';
+export declare const SchemaActions: {
+    readonly SCHEMA_UPDATE: "SCHEMA_UPDATE";
+    readonly SCHEMA_ADD_PAGE: "SCHEMA_ADD_PAGE";
+    readonly SCHEMA_HOME_PAGE: "SCHEMA_HOME_PAGE";
+    readonly SCHEMA_UPDATE_PAGE: "SCHEMA_UPDATE_PAGE";
+    readonly SCHEMA_REMOVE_PAGE: "SCHEMA_REMOVE_PAGE";
+    readonly SCHEMA_ADD_PAGE_FOLDER: "SCHEMA_ADD_PAGE_FOLDER";
+    readonly SCHEMA_UPDATE_PAGE_FOLDER: "SCHEMA_UPDATE_PAGE_FOLDER";
+    readonly SCHEMA_REMOVE_PAGE_FOLDER: "SCHEMA_REMOVE_PAGE_FOLDER";
+    readonly SCHEMA_ADD_VARIABLE: "SCHEMA_ADD_VARIABLE";
+    readonly SCHEMA_UPDATE_VARIABLE: "SCHEMA_UPDATE_VARIABLE";
+    readonly SCHEMA_REMOVE_VARIABLE: "SCHEMA_REMOVE_VARIABLE";
+    readonly SCHEMA_ADD_ELEMENT: "SCHEMA_ADD_ELEMENT";
+    readonly SCHEMA_REMOVE_ELEMENT: "SCHEMA_REMOVE_ELEMENT";
+    readonly SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT";
+    readonly SCHEMA_CLONE_ELEMENT: "SCHEMA_CLONE_ELEMENT";
+    readonly SCHEMA_UPDATE_ELEMENT: "SCHEMA_UPDATE_ELEMENT";
+    readonly SCHEMA_ADD_TEMPLATE: "SCHEMA_ADD_TEMPLATE";
+    readonly SCHEMA_UPDATE_SETTINGS: "SCHEMA_UPDATE_SETTINGS";
+};
+export type SchemaReducerActionsBase = {
+    fromSubscriptions?: boolean;
+};
+export type SchemaReducerActions = SchemaReducerActionsBase & ({
+    type: 'SCHEMA_UPDATE';
+    schema: Schema;
+} | {
+    type: 'SCHEMA_ADD_PAGE';
+    page: Element;
+} | {
+    type: 'SCHEMA_HOME_PAGE';
+    pageId: string;
+} | {
+    type: 'SCHEMA_UPDATE_PAGE';
+    page: Element;
+} | {
+    type: 'SCHEMA_REMOVE_PAGE';
+    pageId: string;
+} | {
+    type: 'SCHEMA_ADD_PAGE_FOLDER';
+    pageFolder: PageFolder;
+} | {
+    type: 'SCHEMA_UPDATE_PAGE_FOLDER';
+    pageFolder: PageFolder;
+} | {
+    type: 'SCHEMA_REMOVE_PAGE_FOLDER';
+    pageFolderId: string;
+} | {
+    type: 'SCHEMA_ADD_VARIABLE';
+    variable: SchemaVariable;
+} | {
+    type: 'SCHEMA_UPDATE_VARIABLE';
+    variable: SchemaVariable;
+} | {
+    type: 'SCHEMA_REMOVE_VARIABLE';
+    name: string;
+} | {
+    type: 'SCHEMA_ADD_ELEMENT' | 'SCHEMA_ADD_TEMPLATE';
+    to: string;
+    data: Element;
+    dropPosition: DropPosition;
+    initialItems: Record<string, Element>;
+    variables?: SchemaVariable[];
+    style?: Style;
+} | {
+    type: 'SCHEMA_REMOVE_ELEMENT';
+    elementId: string;
+} | {
+    type: 'SCHEMA_MOVE_ELEMENT';
+    elementId: string;
+    from: string;
+    to: string;
+    dropPosition: DropPosition;
+} | {
+    type: 'SCHEMA_CLONE_ELEMENT';
+    to: string;
+    data: Element;
+    dropPosition: DropPosition;
+    initialItems: Record<string, Element>;
+} | {
+    type: 'SCHEMA_UPDATE_ELEMENT';
+    element: Element;
+} | {
+    type: 'SCHEMA_UPDATE_SETTINGS';
+    path: string;
+    value: string | number | boolean;
+});
+declare const SchemaReducer: (state: Schema, action: SchemaReducerActions) => Schema;
+export default SchemaReducer;

package/dist/SchemaReducer.mjs

@@ -0,0 +1,145 @@
+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";
+//#region src/SchemaReducer.ts
+var a = {
+	SCHEMA_UPDATE: "SCHEMA_UPDATE",
+	SCHEMA_ADD_PAGE: "SCHEMA_ADD_PAGE",
+	SCHEMA_HOME_PAGE: "SCHEMA_HOME_PAGE",
+	SCHEMA_UPDATE_PAGE: "SCHEMA_UPDATE_PAGE",
+	SCHEMA_REMOVE_PAGE: "SCHEMA_REMOVE_PAGE",
+	SCHEMA_ADD_PAGE_FOLDER: "SCHEMA_ADD_PAGE_FOLDER",
+	SCHEMA_UPDATE_PAGE_FOLDER: "SCHEMA_UPDATE_PAGE_FOLDER",
+	SCHEMA_REMOVE_PAGE_FOLDER: "SCHEMA_REMOVE_PAGE_FOLDER",
+	SCHEMA_ADD_VARIABLE: "SCHEMA_ADD_VARIABLE",
+	SCHEMA_UPDATE_VARIABLE: "SCHEMA_UPDATE_VARIABLE",
+	SCHEMA_REMOVE_VARIABLE: "SCHEMA_REMOVE_VARIABLE",
+	SCHEMA_ADD_ELEMENT: "SCHEMA_ADD_ELEMENT",
+	SCHEMA_REMOVE_ELEMENT: "SCHEMA_REMOVE_ELEMENT",
+	SCHEMA_MOVE_ELEMENT: "SCHEMA_MOVE_ELEMENT",
+	SCHEMA_CLONE_ELEMENT: "SCHEMA_CLONE_ELEMENT",
+	SCHEMA_UPDATE_ELEMENT: "SCHEMA_UPDATE_ELEMENT",
+	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
+		};
+		case a.SCHEMA_ADD_PAGE: {
+			let { page: e } = s;
+			return i(o, (t) => {
+				r(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 a.SCHEMA_UPDATE_PAGE: {
+			let { page: e } = s;
+			return i(o, (t) => {
+				r(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 a.SCHEMA_ADD_PAGE_FOLDER: {
+			let { pageFolder: e } = s;
+			return i(o, (t) => {
+				t.pageFolders.push(e);
+			});
+		}
+		case a.SCHEMA_UPDATE_PAGE_FOLDER: {
+			let { pageFolder: e } = s;
+			return i(o, (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) => {
+				t.pageFolders = t.pageFolders.filter((t) => t.id !== e);
+			});
+		}
+		case a.SCHEMA_ADD_VARIABLE: {
+			let { variable: e } = s;
+			return i(o, (t) => {
+				t.variables ||= [], t.variables.push(e);
+			});
+		}
+		case a.SCHEMA_UPDATE_VARIABLE: {
+			let { variable: e } = s;
+			return o.variables ? i(o, (t) => {
+				let n = t.variables.findIndex((t) => t.name === e.name);
+				t.variables[n] && (t.variables[n] = e);
+			}) : o;
+		}
+		case a.SCHEMA_REMOVE_VARIABLE: {
+			let { name: e } = s;
+			return o.variables ? i(o, (t) => {
+				t.variables = t.variables.filter((t) => t.name !== e);
+			}) : o;
+		}
+		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 a.SCHEMA_REMOVE_ELEMENT: {
+			let { elementId: t } = s;
+			return i(o, (n) => {
+				e.removeElement(n.flat, t);
+			});
+		}
+		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 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 a.SCHEMA_UPDATE_ELEMENT: {
+			let { element: e } = s;
+			return i(o, (t) => {
+				r(t.flat, e.id, 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);
+			});
+		}
+		default: return o;
+	}
+};
+//#endregion
+export { a as SchemaActions, o as default };

package/dist/helpers/FlatMap.d.ts

@@ -0,0 +1,70 @@
+import { Style, Element, Schema, DropPosition, SchemaVariable } from '@plitzi/sdk-shared';
+export type FlatMapProps = {
+    flat?: Schema['flat'];
+    variables?: Schema['variables'];
+};
+declare class FlatMap {
+    flat: Schema['flat'];
+    variables: Schema['variables'];
+    constructor(props?: FlatMapProps);
+    addElement: (data: Element, to: Element["id"], dropPosition?: DropPosition, initialItems?: Record<Element["id"], Element>) => boolean;
+    updateElement: (element?: Element) => boolean;
+    moveElement: (from: Element["id"], to: Element["id"], elementId: Element["id"], dropPosition?: DropPosition) => boolean;
+    getElement: (elementId: Element["id"]) => Element<Omit<{
+        [key: string]: unknown;
+    }, "subType">>;
+    cloneElements: (elementId: Element["id"], parentId?: Element["id"], rootId?: Element["id"], excludeRoot?: boolean) => {
+        acum: Record<Element["id"], Element>;
+        item?: Element;
+    };
+    removeElement: (elementId: Element["id"], removePage?: boolean) => boolean;
+    addVariables: (variables: Schema["variables"]) => boolean;
+    addVariable: (variable: SchemaVariable) => boolean;
+    updateVariable: (variable: SchemaVariable) => boolean;
+    removeVariables: (variables: string[]) => boolean;
+    removeVariable: (variable: string) => boolean;
+    parentTree: (elementId: Element["id"]) => string[];
+    childTree: (elementId: Element["id"]) => string[];
+    isValidElement: (element?: Partial<Element>) => boolean;
+    flatAsTemplate: (style: Style, elementId: Element["id"], excludeRoot?: boolean) => {
+        elements: {
+            acum: Record<Element["id"], Element>;
+            item?: Element;
+        };
+        elementsStyle: Style;
+        variables: SchemaVariable[];
+    };
+    getElementVariables: (style: Style, elementId: Element["id"], flat?: Record<string, Element<Omit<{
+        [key: string]: unknown;
+    }, "subType">>>, 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 updateElement: (flat: Schema["flat"], element: Element) => boolean;
+    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<Omit<{
+        [key: string]: unknown;
+    }, "subType">>;
+    static cloneElements: (flat: Schema["flat"], elementId: Element["id"], parentId?: Element["id"], rootId?: Element["id"], excludeRoot?: boolean) => {
+        acum: Record<Element["id"], Element>;
+        item?: Element;
+    };
+    static removeElement: (flat: Schema["flat"], elementId: Element["id"], removePage?: boolean) => boolean;
+    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;
+    static removeVariables: (schemaVariables: Schema["variables"], variables: string[]) => boolean;
+    static removeVariable: (schemaVariables: Schema["variables"], variable: string) => boolean;
+    static parentTree: (flat: Schema["flat"], elementId: Element["id"]) => string[];
+    static childTree: (flat: Schema["flat"], elementId: Element["id"]) => string[];
+    static isValidElement: (flat: Schema["flat"], element: Element) => boolean;
+    static flatAsTemplate: (schema: Schema, style: Style, elementId: Element["id"], excludeRoot?: boolean) => {
+        elements: {
+            acum: Record<Element["id"], Element>;
+            item?: Element;
+        };
+        elementsStyle: Style;
+        variables: SchemaVariable[];
+    };
+    static getElementVariables: (schema: Schema, style: Style, elementId: Element["id"]) => SchemaVariable[];
+}
+export default FlatMap;

package/dist/helpers/FlatMap.mjs

@@ -0,0 +1,267 @@
+import { get as e, set as t } from "@plitzi/plitzi-ui/helpers";
+import { generateID as n } from "@plitzi/sdk-shared/helpers/utils";
+import { VARIABLE_REGEX as r } from "@plitzi/sdk-shared/schema/schemaConstants";
+import { EMPTY_STYLE_SCHEMA as i } from "@plitzi/sdk-shared/style/styleConstants";
+import a from "@plitzi/sdk-style/helpers/calculateInheriting";
+//#region src/helpers/FlatMap.ts
+var o = class {
+	flat;
+	variables;
+	constructor(e = {}) {
+		let { flat: t, variables: n } = e;
+		if (!t) throw Error("Flat is required");
+		this.flat = t, this.variables = n ?? [];
+	}
+	addElement = (n, r, i = "inside", a = {}) => {
+		let o;
+		if (i !== "custom") {
+			if (i !== "inside") {
+				let e = this.flat[r];
+				if (!e) return !1;
+				e.definition.parentId && (o = this.flat[e.definition.parentId]);
+			} else o = this.flat[r];
+			if (!o) return !1;
+		}
+		if (i !== "custom" && (this.flat[n.id] || !Array.isArray(e(o, "definition.items"))) || !this.isValidElement(n)) return !1;
+		switch (t(this.flat, n.id, n), i) {
+			case "left":
+			case "top": {
+				let i = e(o, "definition.items", []);
+				if (i.splice(i.findIndex((e) => e === r), 0, n.id), !o) return !1;
+				t(this.flat, `${o.id}.definition.items`, i), t(this.flat, `${n.id}.definition.parentId`, o.id), t(this.flat, `${n.id}.definition.rootId`, o.definition.rootId);
+				break;
+			}
+			case "right":
+			case "bottom": {
+				let i = e(o, "definition.items", []);
+				if (i.splice(i.findIndex((e) => e === r) + 1, 0, n.id), !o) return !1;
+				t(this.flat, `${o.id}.definition.items`, i), t(this.flat, `${n.id}.definition.parentId`, o.id), t(this.flat, `${n.id}.definition.rootId`, o.definition.rootId);
+				break;
+			}
+			case "inside": {
+				let i = e(o, "definition.items", []);
+				if (!o) return !1;
+				t(this.flat, `${r}.definition.items`, [...i, n.id]), t(this.flat, `${n.id}.definition.parentId`, r), t(this.flat, `${n.id}.definition.rootId`, o.definition.rootId);
+				break;
+			}
+			case "custom": break;
+			default: return !1;
+		}
+		return Object.keys(a).length > 0 && Object.keys(a).forEach((e) => {
+			this.flat[e] = a[e];
+		}), !0;
+	};
+	updateElement = (e) => !e || !this.flat[e.id] ? !1 : (this.flat[e.id] = e, !0);
+	moveElement = (n, r, i, a = "inside") => {
+		if (i === r || !this.flat[n]) return !1;
+		let o = this.flat[r];
+		if (!o) return !1;
+		let s = this.flat[r];
+		for (; s;) {
+			let t = e(s, "definition.parentId");
+			if (!t) break;
+			if (s.id === i) return !1;
+			s = this.flat[t];
+		}
+		if (!s) return !1;
+		let c = e(this.flat, `${n}.definition.items`, []).filter((e) => e !== i);
+		if ([
+			"left",
+			"top",
+			"right",
+			"bottom"
+		].includes(a)) {
+			if (!o.definition.parentId) return !1;
+			let s = this.flat[o.definition.parentId];
+			if (!s) return !1;
+			let l = e(s, "definition.items", []);
+			s.id === n && (l = c);
+			let u = l.findIndex((e) => e === r);
+			["right", "bottom"].includes(a) && u++, l.splice(u, 0, i), t(this.flat, `${n}.definition.items`, c), t(this.flat, `${s.id}.definition.items`, l), t(this.flat, `${i}.definition.parentId`, s.id);
+		} else if (a === "inside") {
+			if (!this.flat[r]) return !1;
+			let a = e(this.flat, `${r}.definition.items`, []);
+			n === r && (a = c), a = [...a, i], t(this.flat, `${n}.definition.items`, c), t(this.flat, `${r}.definition.items`, a), t(this.flat, `${i}.definition.parentId`, r);
+		}
+		return !0;
+	};
+	getElement = (t) => e(this.flat, t);
+	cloneElements = (r, i = "", a = "", o = !1) => {
+		let s = {
+			acum: {},
+			item: void 0
+		}, c = {}, l = this.flat[r];
+		if (!l) return s;
+		let u = [r, ...this.childTree(r)].reduce((e, t) => {
+			let r = this.flat[t];
+			return r ? (c[r.id] = n(r.id), a ? {
+				...e,
+				[r.id]: {
+					...r,
+					definition: {
+						...r.definition,
+						rootId: a
+					}
+				}
+			} : {
+				...e,
+				[r.id]: r
+			}) : e;
+		}, {});
+		try {
+			let e = JSON.stringify(u);
+			e = Object.keys(c).reduce((e, t) => e.replace(new RegExp(t, "g"), c[t]), e), s.acum = JSON.parse(e), s.item = s.acum[c[r]];
+		} catch (e) {
+			return console.error("Error parsing elements", e), {
+				acum: {},
+				item: void 0
+			};
+		}
+		o && delete s.acum[c[r]];
+		let d = this.flat[i];
+		return (!d || !Array.isArray(e(d, "definition.items"))) && (i = e(d, "definition.parentId", e(l, "definition.parentId"))), i && t(s, "item.definition.parentId", i), s;
+	};
+	removeElement = (n, r = !1) => {
+		let i = this.flat[n];
+		if (!i || i.definition.type === "page" && !r || r && e(i, "attributes.default", !1)) return !1;
+		let a = e(i, "definition.items");
+		a && a.length > 0 && a.forEach((e) => this.removeElement(e));
+		let o = e(i, "definition.parentId"), s = o ? this.flat[o] : void 0;
+		if (o && s) {
+			let { definition: { items: e = [] } } = s;
+			t(s, "definition.items", e.filter((e) => e !== n)), this.flat[o] = s;
+		}
+		return delete this.flat[n], !0;
+	};
+	addVariables = (e) => {
+		if (e && e.length > 0) {
+			let t = e.filter((e) => !this.variables.find((t) => t.name === e.name));
+			return this.variables.push(...t), t.length > 0;
+		}
+		return !1;
+	};
+	addVariable = (e) => e ? this.addVariables([e]) : !1;
+	updateVariable = (e) => {
+		if (!e) return !1;
+		let t = this.variables.findIndex((e) => e.name === e.name);
+		return t === -1 ? !1 : (this.variables[t] = e, !0);
+	};
+	removeVariables = (e) => {
+		e = e.filter(Boolean);
+		let t = this.variables.length;
+		return this.variables = this.variables.filter((t) => e.includes(t.name)), t !== this.variables.length;
+	};
+	removeVariable = (e) => this.removeVariables([e]);
+	parentTree = (t) => {
+		let n = this.flat[t], r = [];
+		if (!n) return r;
+		do {
+			if (e(n, "definition.type") === "page") {
+				let t = e(n, "attributes.layout"), i = e(n, "attributes.layoutContainer");
+				t && i && r.push(i, ...this.parentTree(i));
+			}
+			t !== n.id && r.push(n.id), n = e(this.flat, e(n, "definition.parentId"), void 0);
+		} while (n);
+		return r;
+	};
+	childTree = (t) => {
+		let n = this.flat[t];
+		if (!n) return [];
+		let r = [], i = e(n, "definition.items");
+		return i && i.forEach((e) => r.push(e, ...this.childTree(e))), r;
+	};
+	isValidElement = (e) => {
+		if (!e) return !1;
+		let { id: t, attributes: n, definition: r } = e;
+		if (!t || !r || !n) return !1;
+		let { type: i, label: a, styleSelectors: o, rootId: s } = r;
+		return !(!i || a === void 0 || typeof o != "object" || s === void 0);
+	};
+	flatAsTemplate = (n, r, o = !1) => {
+		let s = i, c = [];
+		if (!r) return {
+			elements: {
+				acum: {},
+				item: void 0
+			},
+			elementsStyle: s,
+			variables: c
+		};
+		let l = e(this.flat, r);
+		if (!l) return {
+			elements: {
+				acum: {},
+				item: void 0
+			},
+			elementsStyle: s,
+			variables: c
+		};
+		let u = this.cloneElements(r, l.definition.parentId);
+		return u.item ? (Object.values(u.acum).forEach((e) => {
+			let { id: r } = e;
+			if (t(u.acum, `${r}.definition.rootId`, u.item?.id), a(e, void 0, this.flat, n.platform, {}, { includeSelf: !0 }).tree.forEach((e) => {
+				let { displayMode: t, name: r } = e;
+				!(r in s.platform[t]) && r in n.platform[t] && (s.platform[t][r] = n.platform[t][r]);
+			}), this.variables.length > 0) {
+				let e = this.getElementVariables(n, r, u.acum);
+				c = [...c, ...e];
+			}
+		}), t(u.acum, `${u.item.id}.definition.parentId`, null), o && delete u.acum[u.item.id], c.length > 1 && (c = [...new Set(c)]), {
+			elements: u,
+			elementsStyle: s,
+			variables: c
+		}) : {
+			elements: {
+				acum: {},
+				item: void 0
+			},
+			elementsStyle: s,
+			variables: c
+		};
+	};
+	getElementVariables = (t, n, i = this.flat, a = this.variables) => {
+		let o = [], s = e(i, `${n}.definition.styleSelectors`);
+		if (!s) return o;
+		let c = new RegExp(r, "g");
+		return Object.values(s).filter(Boolean).forEach((e) => {
+			Object.values(t.platform).forEach((t) => {
+				let n = t[e];
+				n && [...JSON.stringify(n.attributes).matchAll(c)].forEach((e) => {
+					let t = a.find((t) => t.name === e[1] || t.name === e[2]);
+					t && !o.find((e) => e.name === t.name) && o.push(t);
+				});
+			});
+		}), o;
+	};
+	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 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 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);
+	static removeVariables = (e, t) => this.getInstance({ variables: e }).removeVariables(t);
+	static removeVariable = (e, t) => this.getInstance({ variables: e }).removeVariable(t);
+	static parentTree = (e, t) => this.getInstance({ flat: e }).parentTree(t);
+	static childTree = (e, t) => this.getInstance({ flat: e }).childTree(t);
+	static isValidElement = (e, t) => this.getInstance({ flat: e }).isValidElement(t);
+	static flatAsTemplate = (e, t, n, r = !1) => {
+		let { flat: i, variables: a } = e;
+		return this.getInstance({
+			flat: i,
+			variables: a
+		}).flatAsTemplate(t, n, r);
+	};
+	static getElementVariables = (e, t, n) => {
+		let { flat: r, variables: i } = e;
+		return this.getInstance({
+			flat: r,
+			variables: i
+		}).getElementVariables(t, n);
+	};
+};
+//#endregion
+export { o as default };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { default as FlatMap } from './helpers/FlatMap';
+import { default as SchemaReducer } from './SchemaReducer';
+export * from './SchemaReducer';
+export * from './helpers/FlatMap';
+export { FlatMap, SchemaReducer };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import e from "./helpers/FlatMap.mjs";
+import t, { SchemaActions as n } from "./SchemaReducer.mjs";
+export { e as FlatMap, n as SchemaActions, t as SchemaReducer };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@plitzi/sdk-schema",
+  "version": "0.30.19",
+  "license": "AGPL-3.0",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./SchemaReducer": {
+      "types": "./dist/SchemaReducer.d.ts",
+      "import": "./dist/SchemaReducer.mjs"
+    },
+    "./helpers/FlatMap": {
+      "types": "./dist/helpers/FlatMap.d.ts",
+      "import": "./dist/helpers/FlatMap.mjs"
+    },
+    "./index": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "type": "module",
+  "sideEffects": false,
+  "scripts": {
+    "lint": "eslint ./src",
+    "typecheck": "tsc -p tsconfig.app.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "build:dev": "vite build --mode development --minify false && node ../sdk-shared/scripts/generate-exports.mjs",
+    "build:dev-watch": "vite build --mode development --watch --minify false",
+    "build:prod": "vite build && node ../sdk-shared/scripts/generate-exports.mjs"
+  },
+  "dependencies": {
+    "@plitzi/plitzi-ui": "^1.6.2",
+    "@plitzi/sdk-shared": "0.30.19",
+    "@plitzi/sdk-style": "0.30.19",
+    "prop-types": "^15.8.1"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.4",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.10",
+    "vitest": "^4.1.5"
+  }
+}