@plitzi/sdk-schema 0.30.19 → 0.31.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @plitzi/sdk-schema
 
+## 0.31.1
+
+### Patch Changes
+
+- v0.31.1
+- Updated dependencies
+  - @plitzi/sdk-shared@0.31.1
+  - @plitzi/sdk-style@0.31.1
+
+## 0.31.0
+
+### Minor Changes
+
+- v0.31.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @plitzi/sdk-shared@0.31.0
+  - @plitzi/sdk-style@0.31.0
+
 ## 0.30.19
 
 ### Patch Changes

package/dist/helpers/FlatMap.d.ts

@@ -1,3 +1,4 @@
+import { SchemaValidationResult } from './schemaValidator';
 import { Style, Element, Schema, DropPosition, SchemaVariable } from '@plitzi/sdk-shared';
 export type FlatMapProps = {
     flat?: Schema['flat'];
@@ -10,9 +11,7 @@ declare class FlatMap {
     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">>;
+    getElement: (elementId: Element["id"]) => Element<Record<string, unknown>>;
     cloneElements: (elementId: Element["id"], parentId?: Element["id"], rootId?: Element["id"], excludeRoot?: boolean) => {
         acum: Record<Element["id"], Element>;
         item?: Element;
@@ -34,16 +33,15 @@ declare class FlatMap {
         elementsStyle: Style;
         variables: SchemaVariable[];
     };
-    getElementVariables: (style: Style, elementId: Element["id"], flat?: Record<string, Element<Omit<{
-        [key: string]: unknown;
-    }, "subType">>>, variables?: SchemaVariable[]) => SchemaVariable[];
+    validate: () => SchemaValidationResult;
+    isValid: () => boolean;
+    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 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 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) => {
         acum: Record<Element["id"], Element>;
         item?: Element;
@@ -66,5 +64,8 @@ declare class FlatMap {
         variables: SchemaVariable[];
     };
     static getElementVariables: (schema: Schema, style: Style, elementId: Element["id"]) => SchemaVariable[];
+    static validate: (schema: Schema) => SchemaValidationResult;
+    static isValid: (schema: Schema) => boolean;
+    static assertValid: (schema: Schema, context?: string) => void;
 }
 export default FlatMap;

package/dist/helpers/FlatMap.mjs

@@ -1,10 +1,11 @@
-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";
+import { validateSchema as e } from "./schemaValidator.mjs";
+import { get as t, set as n } from "@plitzi/plitzi-ui/helpers";
+import { generateID as r } from "@plitzi/sdk-shared/helpers/utils";
+import { EMPTY_SCHEMA as i, VARIABLE_REGEX as a } from "@plitzi/sdk-shared/schema/schemaConstants";
+import { EMPTY_STYLE_SCHEMA as o } from "@plitzi/sdk-shared/style/styleConstants";
+import s from "@plitzi/sdk-style/helpers/calculateInheriting";
 //#region src/helpers/FlatMap.ts
-var o = class {
+var c = class {
 	flat;
 	variables;
 	constructor(e = {}) {
@@ -12,7 +13,7 @@ var o = class {
 		if (!t) throw Error("Flat is required");
 		this.flat = t, this.variables = n ?? [];
 	}
-	addElement = (n, r, i = "inside", a = {}) => {
+	addElement = (e, r, i = "inside", a = {}) => {
 		let o;
 		if (i !== "custom") {
 			if (i !== "inside") {
@@ -22,26 +23,26 @@ var o = class {
 			} 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) {
+		if (i !== "custom" && (this.flat[e.id] || !Array.isArray(t(o, "definition.items"))) || !this.isValidElement(e)) return !1;
+		switch (n(this.flat, e.id, e), 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);
+				let i = t(o, "definition.items", []);
+				if (i.splice(i.findIndex((e) => e === r), 0, e.id), !o) return !1;
+				n(this.flat, `${o.id}.definition.items`, i), n(this.flat, `${e.id}.definition.parentId`, o.id), n(this.flat, `${e.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);
+				let i = t(o, "definition.items", []);
+				if (i.splice(i.findIndex((e) => e === r) + 1, 0, e.id), !o) return !1;
+				n(this.flat, `${o.id}.definition.items`, i), n(this.flat, `${e.id}.definition.parentId`, o.id), n(this.flat, `${e.id}.definition.rootId`, o.definition.rootId);
 				break;
 			}
 			case "inside": {
-				let i = e(o, "definition.items", []);
+				let i = t(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);
+				n(this.flat, `${r}.definition.items`, [...i, e.id]), n(this.flat, `${e.id}.definition.parentId`, r), n(this.flat, `${e.id}.definition.rootId`, o.definition.rootId);
 				break;
 			}
 			case "custom": break;
@@ -52,19 +53,19 @@ var o = class {
 		}), !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;
+	moveElement = (e, r, i, a = "inside") => {
+		if (i === r || !this.flat[e]) 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;
+			let e = t(s, "definition.parentId");
+			if (!e) break;
 			if (s.id === i) return !1;
-			s = this.flat[t];
+			s = this.flat[e];
 		}
 		if (!s) return !1;
-		let c = e(this.flat, `${n}.definition.items`, []).filter((e) => e !== i);
+		let c = t(this.flat, `${e}.definition.items`, []).filter((e) => e !== i);
 		if ([
 			"left",
 			"top",
@@ -74,64 +75,64 @@ var o = class {
 			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 l = t(s, "definition.items", []);
+			s.id === e && (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);
+			["right", "bottom"].includes(a) && u++, l.splice(u, 0, i), n(this.flat, `${e}.definition.items`, c), n(this.flat, `${s.id}.definition.items`, l), n(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);
+			let a = t(this.flat, `${r}.definition.items`, []);
+			e === r && (a = c), a = [...a, i], n(this.flat, `${e}.definition.items`, c), n(this.flat, `${r}.definition.items`, a), n(this.flat, `${i}.definition.parentId`, r);
 		}
 		return !0;
 	};
-	getElement = (t) => e(this.flat, t);
-	cloneElements = (r, i = "", a = "", o = !1) => {
+	getElement = (e) => t(this.flat, e);
+	cloneElements = (e, i = "", a = "", o = !1) => {
 		let s = {
 			acum: {},
 			item: void 0
-		}, c = {}, l = this.flat[r];
+		}, c = {}, l = this.flat[e];
 		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 ? {
+		let u = [e, ...this.childTree(e)].reduce((e, t) => {
+			let n = this.flat[t];
+			return n ? (c[n.id] = r(n.id), a ? {
 				...e,
-				[r.id]: {
-					...r,
+				[n.id]: {
+					...n,
 					definition: {
-						...r.definition,
+						...n.definition,
 						rootId: a
 					}
 				}
 			} : {
 				...e,
-				[r.id]: r
+				[n.id]: n
 			}) : 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]];
+			let t = JSON.stringify(u);
+			t = Object.keys(c).reduce((e, t) => e.replace(new RegExp(t, "g"), c[t]), t), s.acum = JSON.parse(t), s.item = s.acum[c[e]];
 		} catch (e) {
 			return console.error("Error parsing elements", e), {
 				acum: {},
 				item: void 0
 			};
 		}
-		o && delete s.acum[c[r]];
+		o && delete s.acum[c[e]];
 		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;
+		return (!d || !Array.isArray(t(d, "definition.items"))) && (i = t(d, "definition.parentId", t(l, "definition.parentId"))), i && n(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");
+	removeElement = (e, r = !1) => {
+		let i = this.flat[e];
+		if (!i || i.definition.type === "page" && !r || r && t(i, "attributes.default", !1)) return !1;
+		let a = t(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;
+		let o = t(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;
+			let { definition: { items: t = [] } } = s;
+			n(s, "definition.items", t.filter((t) => t !== e)), this.flat[o] = s;
 		}
-		return delete this.flat[n], !0;
+		return delete this.flat[e], !0;
 	};
 	addVariables = (e) => {
 		if (e && e.length > 0) {
@@ -152,22 +153,22 @@ var o = class {
 		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 = [];
+	parentTree = (e) => {
+		let n = this.flat[e], 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));
+			if (t(n, "definition.type") === "page") {
+				let e = t(n, "attributes.layout"), i = t(n, "attributes.layoutContainer");
+				e && i && r.push(i, ...this.parentTree(i));
 			}
-			t !== n.id && r.push(n.id), n = e(this.flat, e(n, "definition.parentId"), void 0);
+			e !== n.id && r.push(n.id), n = t(this.flat, t(n, "definition.parentId"), void 0);
 		} while (n);
 		return r;
 	};
-	childTree = (t) => {
-		let n = this.flat[t];
+	childTree = (e) => {
+		let n = this.flat[e];
 		if (!n) return [];
-		let r = [], i = e(n, "definition.items");
+		let r = [], i = t(n, "definition.items");
 		return i && i.forEach((e) => r.push(e, ...this.childTree(e))), r;
 	};
 	isValidElement = (e) => {
@@ -177,57 +178,81 @@ var o = class {
 		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 = [];
+	flatAsTemplate = (e, r, i = !1) => {
+		let a = {
+			...o,
+			platform: {
+				desktop: {},
+				tablet: {},
+				mobile: {}
+			}
+		}, c = [];
 		if (!r) return {
 			elements: {
 				acum: {},
 				item: void 0
 			},
-			elementsStyle: s,
+			elementsStyle: a,
 			variables: c
 		};
-		let l = e(this.flat, r);
+		let l = t(this.flat, r);
 		if (!l) return {
 			elements: {
 				acum: {},
 				item: void 0
 			},
-			elementsStyle: s,
+			elementsStyle: a,
 			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]);
+		return u.item ? (Object.values(u.acum).forEach((t) => {
+			let { id: r } = t;
+			if (n(u.acum, `${r}.definition.rootId`, u.item?.id), s(t, t.definition.type, this.flat, e.platform, {}, { includeSelf: !0 }).tree.forEach((t) => {
+				let { displayMode: n, name: r } = t;
+				!(r in a.platform[n]) && r in e.platform[n] && (a.platform[n][r] = e.platform[n][r]);
 			}), this.variables.length > 0) {
-				let e = this.getElementVariables(n, r, u.acum);
-				c = [...c, ...e];
+				let t = this.getElementVariables(e, r, u.acum);
+				c = [...c, ...t];
 			}
-		}), t(u.acum, `${u.item.id}.definition.parentId`, null), o && delete u.acum[u.item.id], c.length > 1 && (c = [...new Set(c)]), {
+		}), n(u.acum, `${u.item.id}.definition.parentId`, null), i && delete u.acum[u.item.id], c.length > 1 && (c = [...new Set(c)]), {
 			elements: u,
-			elementsStyle: s,
+			elementsStyle: a,
 			variables: c
 		}) : {
 			elements: {
 				acum: {},
 				item: void 0
 			},
-			elementsStyle: s,
+			elementsStyle: a,
 			variables: c
 		};
 	};
-	getElementVariables = (t, n, i = this.flat, a = this.variables) => {
-		let o = [], s = e(i, `${n}.definition.styleSelectors`);
+	validate = () => e({
+		...i.schema,
+		flat: this.flat,
+		variables: this.variables
+	});
+	isValid = () => this.validate().valid;
+	assertValid = (t) => {
+		let n = e({
+			...i.schema,
+			flat: this.flat,
+			variables: this.variables
+		});
+		if (!n.valid) {
+			let e = `Invalid schema${t ? ` (${t})` : ""}: ${n.errors.map((e) => e.message).join("; ")}`;
+			throw Error(e);
+		}
+	};
+	getElementVariables = (e, n, r = this.flat, i = this.variables) => {
+		let o = [], s = t(r, `${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];
+		let c = new RegExp(a, "g");
+		return Object.values(s).filter(Boolean).forEach((t) => {
+			Object.values(e.platform).forEach((e) => {
+				let n = e[t];
 				n && [...JSON.stringify(n.attributes).matchAll(c)].forEach((e) => {
-					let t = a.find((t) => t.name === e[1] || t.name === e[2]);
+					let t = i.find((t) => t.name === e[1] || t.name === e[2]);
 					t && !o.find((e) => e.name === t.name) && o.push(t);
 				});
 			});
@@ -262,6 +287,15 @@ var o = class {
 			variables: i
 		}).getElementVariables(t, n);
 	};
+	static validate = (t) => e(t);
+	static isValid = (t) => e(t).valid;
+	static assertValid = (t, n) => {
+		let r = e(t);
+		if (!r.valid) {
+			let e = `Invalid schema${n ? ` (${n})` : ""}: ${r.errors.map((e) => e.message).join("; ")}`;
+			throw Error(e);
+		}
+	};
 };
 //#endregion
-export { o as default };
+export { c as default };

package/dist/helpers/schemaValidator.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from '@plitzi/sdk-shared';
+export type SchemaValidationOptions = {
+    baseElementId?: string;
+};
+export type SchemaValidationError = {
+    code: string;
+    message: string;
+    elementId?: string;
+    details?: unknown;
+};
+export type SchemaValidationResult = {
+    valid: boolean;
+    errors: SchemaValidationError[];
+    warnings: SchemaValidationError[];
+};
+export declare const validateSchema: (schema: Schema, options?: SchemaValidationOptions) => SchemaValidationResult;
+export declare const assertSchemaValid: (schema: Schema, options?: SchemaValidationOptions, context?: string) => void;
+export declare const isSchemaValid: (schema: Schema, options?: SchemaValidationOptions) => boolean;

package/dist/helpers/schemaValidator.mjs

@@ -0,0 +1,281 @@
+//#region src/helpers/schemaValidator.ts
+var e = (e) => {
+	let t = [], n = [], { flat: r, pages: i, pageFolders: a, variables: o } = e, s = (e) => !!r[e], c = (e) => r[e], l = () => !r || typeof r != "object" ? (t.push({
+		code: "INVALID_FLAT",
+		message: "Schema.flat must be a valid Record<string, Element>"
+	}), !1) : Array.isArray(i) ? Array.isArray(a) ? Array.isArray(o) ? !0 : (t.push({
+		code: "INVALID_VARIABLES",
+		message: "Schema.variables must be an array"
+	}), !1) : (t.push({
+		code: "INVALID_PAGE_FOLDERS",
+		message: "Schema.pageFolders must be an array"
+	}), !1) : (t.push({
+		code: "INVALID_PAGES",
+		message: "Schema.pages must be an array of element IDs"
+	}), !1), u = () => {
+		Object.entries(r).forEach(([e, r]) => {
+			if (!r) {
+				t.push({
+					code: "NULL_ELEMENT",
+					message: `Element with id "${e}" is null or undefined`,
+					elementId: e
+				});
+				return;
+			}
+			if (!r.id) {
+				t.push({
+					code: "MISSING_ID",
+					message: `Element at key "${e}" has no id property`
+				});
+				return;
+			}
+			if (r.id !== e && t.push({
+				code: "ID_MISMATCH",
+				message: `Element id "${r.id}" doesn't match flat key "${e}"`,
+				elementId: e
+			}), !r.definition) {
+				t.push({
+					code: "MISSING_DEFINITION",
+					message: "Element missing definition",
+					elementId: e
+				});
+				return;
+			}
+			let { definition: i, attributes: a } = r;
+			i.type || t.push({
+				code: "MISSING_TYPE",
+				message: "Element missing definition.type",
+				elementId: e
+			}), i.label === void 0 && t.push({
+				code: "MISSING_LABEL",
+				message: "Element missing definition.label",
+				elementId: e
+			}), i.rootId || t.push({
+				code: "MISSING_ROOT_ID",
+				message: "Element missing definition.rootId",
+				elementId: e
+			}), (!i.styleSelectors || typeof i.styleSelectors != "object") && t.push({
+				code: "MISSING_STYLE_SELECTORS",
+				message: "Element missing or invalid definition.styleSelectors",
+				elementId: e
+			}), a || n.push({
+				code: "MISSING_ATTRIBUTES",
+				message: "Element has no attributes",
+				elementId: e
+			}), i.items && (Array.isArray(i.items) ? i.items.forEach((n, r) => {
+				s(n) || t.push({
+					code: "ORPHANED_ITEM_REFERENCE",
+					message: `Element "${e}" references non-existent child "${n}" at items[${r}]`,
+					elementId: e,
+					details: {
+						childId: n,
+						index: r
+					}
+				});
+			}) : t.push({
+				code: "INVALID_ITEMS",
+				message: "Element.definition.items must be an array",
+				elementId: e
+			})), i.parentId && !s(i.parentId) && t.push({
+				code: "ORPHANED_PARENT_REFERENCE",
+				message: `Element "${e}" has parentId "${i.parentId}" but parent doesn't exist in flat`,
+				elementId: e,
+				details: { parentId: i.parentId }
+			});
+		});
+	}, d = () => {
+		Object.values(r).forEach((e) => {
+			if (!e?.definition) return;
+			let { id: n, definition: r } = e;
+			if (r.items && r.items.forEach((e) => {
+				let r = c(e);
+				r?.definition && r.definition.parentId !== n && t.push({
+					code: "PARENT_CHILD_MISMATCH",
+					message: `Element "${e}" is in "${n}".items but has parentId "${r.definition.parentId}"`,
+					elementId: e,
+					details: {
+						expectedParent: n,
+						actualParent: r.definition.parentId
+					}
+				});
+			}), r.parentId) {
+				let e = c(r.parentId);
+				if (!e?.definition) return;
+				let i = e.definition.items || [];
+				i.includes(n) || t.push({
+					code: "PARENT_CHILD_MISMATCH",
+					message: `Element "${n}" has parentId "${r.parentId}" but parent doesn't have it in items`,
+					elementId: n,
+					details: {
+						parentId: r.parentId,
+						parentItems: i
+					}
+				});
+			}
+		});
+	}, f = () => {
+		let e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), i = (r) => {
+			if (n.has(r)) return t.push({
+				code: "CIRCULAR_REFERENCE",
+				message: `Circular reference detected involving element "${r}"`,
+				elementId: r
+			}), !0;
+			if (e.has(r)) return !1;
+			e.add(r), n.add(r);
+			let a = c(r);
+			if (a?.definition?.items) {
+				for (let e of a.definition.items) if (i(e)) return n.delete(r), !0;
+			}
+			let o = /* @__PURE__ */ new Set(), s = a;
+			for (; s?.definition?.parentId;) {
+				if (o.has(s.id)) return t.push({
+					code: "CIRCULAR_PARENT_REFERENCE",
+					message: `Circular parent reference detected involving element "${s.id}"`,
+					elementId: s.id
+				}), !0;
+				o.add(s.id), s = c(s.definition.parentId);
+			}
+			return n.delete(r), !1;
+		};
+		Object.keys(r).forEach((t) => {
+			e.has(t) || i(t);
+		});
+	}, p = () => {
+		let e = /* @__PURE__ */ new Set(), r = 0;
+		i.forEach((n, i) => {
+			e.has(n) && t.push({
+				code: "DUPLICATE_PAGE",
+				message: `Duplicate page ID "${n}" in pages array at index ${i}`,
+				elementId: n
+			}), e.add(n);
+			let a = c(n);
+			if (!a) {
+				t.push({
+					code: "INVALID_PAGE_REFERENCE",
+					message: `Page ID "${n}" in pages array doesn't exist in flat`,
+					elementId: n
+				});
+				return;
+			}
+			a.definition.type !== "page" && t.push({
+				code: "INVALID_PAGE_TYPE",
+				message: `Element "${n}" in pages array has type "${a.definition.type}" instead of "page"`,
+				elementId: n
+			}), a.definition.rootId !== n && t.push({
+				code: "PAGE_ROOT_ID_MISMATCH",
+				message: `Page "${n}" has rootId "${a.definition.rootId}" instead of its own ID`,
+				elementId: n
+			}), a.attributes?.default && r++;
+		}), r === 0 && i.length > 0 ? n.push({
+			code: "NO_DEFAULT_PAGE",
+			message: "No default page found in schema"
+		}) : r > 1 && n.push({
+			code: "MULTIPLE_DEFAULT_PAGES",
+			message: `Found ${r} default pages, expected 1`
+		});
+	}, m = () => {
+		i.forEach((e) => {
+			let n = c(e);
+			if (!n) return;
+			let r = (n) => {
+				let i = c(n);
+				i?.definition && (i.definition.rootId !== e && t.push({
+					code: "ROOT_ID_MISMATCH",
+					message: `Element "${n}" has rootId "${i.definition.rootId}" but should be "${e}" (page's ID)`,
+					elementId: n,
+					details: {
+						expectedRootId: e,
+						actualRootId: i.definition.rootId
+					}
+				}), i.definition.items && i.definition.items.forEach((e) => r(e)));
+			};
+			n.definition.items && n.definition.items.forEach((e) => r(e));
+		});
+	}, h = () => {
+		let e = /* @__PURE__ */ new Set();
+		a.forEach((n, r) => {
+			if (!n.id) {
+				t.push({
+					code: "INVALID_FOLDER",
+					message: `Page folder at index ${r} has no id`
+				});
+				return;
+			}
+			e.has(n.id) && t.push({
+				code: "DUPLICATE_FOLDER",
+				message: `Duplicate folder ID "${n.id}"`,
+				elementId: n.id
+			}), e.add(n.id), n.parentId && (e.has(n.parentId) || t.push({
+				code: "ORPHANED_FOLDER_PARENT",
+				message: `Folder "${n.id}" has non-existent parent "${n.parentId}"`,
+				elementId: n.id,
+				details: { parentId: n.parentId }
+			}));
+		});
+	}, g = (e) => {
+		let t = /* @__PURE__ */ new Set(), a = (e) => {
+			if (t.has(e)) return;
+			t.add(e);
+			let n = c(e);
+			n?.definition?.items && n.definition.items.forEach((e) => a(e));
+		};
+		if (!e) i.forEach((e) => {
+			a(e);
+			let t = c(e);
+			t?.attributes?.layoutContainer && a(t.attributes.layoutContainer);
+		});
+		else if (e) {
+			a(e);
+			let t = c(e);
+			t?.attributes?.layoutContainer && a(t.attributes.layoutContainer);
+		}
+		Object.keys(r).forEach((e) => {
+			let r = c(e);
+			r && !t.has(e) && r.definition.type !== "page" && n.push({
+				code: "ORPHANED_ELEMENT",
+				message: `Element "${e}" is not reachable from any page`,
+				elementId: e
+			});
+		});
+	}, _ = () => {
+		let e = /* @__PURE__ */ new Set();
+		o.forEach((r, i) => {
+			if (!r.name) {
+				t.push({
+					code: "INVALID_VARIABLE",
+					message: `Variable at index ${i} has no name`
+				});
+				return;
+			}
+			e.has(r.name) && t.push({
+				code: "DUPLICATE_VARIABLE",
+				message: `Duplicate variable name "${r.name}"`,
+				details: { variableName: r.name }
+			}), e.add(r.name), r.type || n.push({
+				code: "MISSING_VARIABLE_TYPE",
+				message: `Variable "${r.name}" has no type`,
+				details: { variableName: r.name }
+			});
+		});
+	};
+	return { validate: (e) => {
+		let { baseElementId: r } = e ?? {};
+		return l() ? (u(), d(), f(), p(), m(), h(), g(r), _(), {
+			valid: t.length === 0,
+			errors: t,
+			warnings: n
+		}) : {
+			valid: !1,
+			errors: t,
+			warnings: n
+		};
+	} };
+}, t = (t, n) => e(t).validate(n), n = (e, n, r) => {
+	let i = t(e, n);
+	if (!i.valid) {
+		let e = `Invalid schema${r ? ` (${r})` : ""}: ${i.errors.map((e) => e.message).join("; ")}`;
+		throw Error(e);
+	}
+}, r = (e, n) => t(e, n).valid;
+//#endregion
+export { n as assertSchemaValid, r as isSchemaValid, t as validateSchema };

package/dist/index.d.ts

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

package/dist/index.mjs

@@ -1,3 +1,4 @@
-import e from "./helpers/FlatMap.mjs";
-import t, { SchemaActions as n } from "./SchemaReducer.mjs";
-export { e as FlatMap, n as SchemaActions, t as SchemaReducer };
+import { assertSchemaValid as e, isSchemaValid as t, validateSchema as n } from "./helpers/schemaValidator.mjs";
+import r from "./helpers/FlatMap.mjs";
+import i, { SchemaActions as a } from "./SchemaReducer.mjs";
+export { r as FlatMap, a as SchemaActions, i as SchemaReducer, e as assertSchemaValid, t as isSchemaValid, n as validateSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-schema",
-  "version": "0.30.19",
+  "version": "0.31.1",
   "license": "AGPL-3.0",
   "files": [
     "dist"
@@ -18,6 +18,10 @@
       "types": "./dist/helpers/FlatMap.d.ts",
       "import": "./dist/helpers/FlatMap.mjs"
     },
+    "./helpers/schemaValidator": {
+      "types": "./dist/helpers/schemaValidator.d.ts",
+      "import": "./dist/helpers/schemaValidator.mjs"
+    },
     "./index": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
@@ -36,15 +40,15 @@
     "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",
+    "@plitzi/plitzi-ui": "^1.6.9",
+    "@plitzi/sdk-shared": "0.31.1",
+    "@plitzi/sdk-style": "0.31.1",
     "prop-types": "^15.8.1"
   },
   "devDependencies": {
     "eslint": "^9.39.4",
     "typescript": "^6.0.3",
-    "vite": "^8.0.10",
-    "vitest": "^4.1.5"
+    "vite": "^8.0.14",
+    "vitest": "^4.1.7"
   }
 }