@prismicio/types-internal 4.6.0 → 4.7.0-pr.36.885e913

package/dist/model/diff/utils.js

@@ -0,0 +1,40 @@
+//#region src/model/diff/utils.ts
+/**
+* Zips two objects together by their keys, creating an object with
+* both left and right values for each key.
+*/
+function zipObjects(objLeft, objRight) {
+	return [...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {})))].reduce((acc, key) => {
+		const left = objLeft?.[key];
+		const right = objRight?.[key];
+		return {
+			...acc,
+			[key]: {
+				left,
+				right
+			}
+		};
+	}, {});
+}
+/**
+* Returns true if the object has at least one key.
+*/
+function isNotEmpty(obj) {
+	return Boolean(Object.keys(obj).length);
+}
+/**
+* Converts an array to a record using the provided key function.
+*/
+function toRecord(arr, key) {
+	return arr.reduce((acc, entry) => {
+		const k = key(entry);
+		return {
+			...acc,
+			[k]: entry
+		};
+	}, {});
+}
+//#endregion
+export { isNotEmpty, toRecord, zipObjects };
+
+//# sourceMappingURL=utils.js.map

package/dist/model/diff/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/model/diff/utils.ts"],"sourcesContent":["/**\n * Zips two objects together by their keys, creating an object with\n * both left and right values for each key.\n */\nexport function zipObjects<A, B = A>(\n\tobjLeft?: Partial<Record<string, A>> | undefined,\n\tobjRight?: Partial<Record<string, B>> | undefined,\n): Partial<Record<string, { left?: A | undefined; right?: B | undefined }>> {\n\tconst allKeys = [...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {})))]\n\n\treturn allKeys.reduce<Record<string, { left?: A | undefined; right?: B | undefined }>>(\n\t\t(acc, key) => {\n\t\t\tconst left = objLeft?.[key]\n\t\t\tconst right = objRight?.[key]\n\t\t\treturn {\n\t\t\t\t...acc,\n\t\t\t\t[key]: { left, right },\n\t\t\t}\n\t\t},\n\t\t{},\n\t)\n}\n\n/**\n * Returns true if the object has at least one key.\n */\nexport function isNotEmpty<A extends object>(obj: A): boolean {\n\treturn Boolean(Object.keys(obj).length)\n}\n\n/**\n * Converts an array to a record using the provided key function.\n */\nexport function toRecord<A extends object>(\n\tarr: ReadonlyArray<A>,\n\tkey: (obj: A) => string,\n): Record<string, A> {\n\treturn arr.reduce<Record<string, A>>((acc, entry) => {\n\t\tconst k = key(entry)\n\t\treturn {\n\t\t\t...acc,\n\t\t\t[k]: entry,\n\t\t}\n\t}, {})\n}\n"],"mappings":";;;;;AAIA,SAAgB,WACf,SACA,UAC2E;CAG3E,OAAO,CAFU,GAAG,IAAI,IAAI,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,OAAO,KAAK,YAAY,CAAC,CAAC,CAAC,CAAC,CAE7E,CAAC,CAAC,QACb,KAAK,QAAQ;EACb,MAAM,OAAO,UAAU;EACvB,MAAM,QAAQ,WAAW;EACzB,OAAO;GACN,GAAG;IACF,MAAM;IAAE;IAAM;GAAM;EACtB;CACD,GACA,CAAC,CACF;AACD;;;;AAKA,SAAgB,WAA6B,KAAiB;CAC7D,OAAO,QAAQ,OAAO,KAAK,GAAG,CAAC,CAAC,MAAM;AACvC;;;;AAKA,SAAgB,SACf,KACA,KACoB;CACpB,OAAO,IAAI,QAA2B,KAAK,UAAU;EACpD,MAAM,IAAI,IAAI,KAAK;EACnB,OAAO;GACN,GAAG;IACF,IAAI;EACN;CACD,GAAG,CAAC,CAAC;AACN"}

package/dist/model/diff/variation.d.ts

@@ -0,0 +1,15 @@
+import { SharedSliceModelVariation } from "../slice.js";
+import { Diff } from "./changes.js";
+import { NestableWidgetDiff, SlicePrimaryWidgetDiff } from "./widgets.js";
+//#region src/model/diff/variation.d.ts
+type VariationDiffMetadata = Omit<SharedSliceModelVariation, "primary" | "items">;
+type VariationDiff = Diff<SharedSliceModelVariation, Partial<VariationDiffMetadata> & {
+  primary?: Record<string, SlicePrimaryWidgetDiff>;
+  items?: Record<string, NestableWidgetDiff>;
+}>;
+declare const VariationDiffComparator: {
+  compare(variationA?: SharedSliceModelVariation, variationB?: SharedSliceModelVariation): VariationDiff | undefined;
+};
+//#endregion
+export { VariationDiff, VariationDiffComparator, VariationDiffMetadata };
+//# sourceMappingURL=variation.d.ts.map

package/dist/model/diff/variation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variation.d.ts","names":[],"sources":["../../../src/model/diff/variation.ts"],"mappings":";;;;KAYY,wBAAwB,KAAK;KAC7B,gBAAgB,KAC3B,2BACA,QAAQ;EACP,UAAU,eAAe;EACzB,QAAQ,eAAe;;cAsGZ;EACZ,QAAO,aACO,2BAAyB,aACzB,4BACX"}

package/dist/model/diff/variation.js

@@ -0,0 +1,92 @@
+import "./changes.js";
+import { isNotEmpty, zipObjects } from "./utils.js";
+import "../group.js";
+//#region src/model/diff/variation.ts
+function compareVariationMeta(variationA, variationB) {
+	const zippedVariations = zipObjects(variationA, variationB);
+	return Object.entries(zippedVariations).reduce((acc, [key, value]) => {
+		if (key === "primary" || key === "items") return acc;
+		if (value?.left === value?.right) return acc;
+		return {
+			...acc,
+			[key]: value?.right
+		};
+	}, {});
+}
+function compareWidgets(widgetsA, widgetsB) {
+	const zippedWidgets = zipObjects(widgetsA, widgetsB);
+	const diffWidgets = Object.entries(zippedWidgets).reduce((acc, [widgetKey, widgetValue]) => {
+		if (JSON.stringify(widgetValue?.left) === JSON.stringify(widgetValue?.right)) return acc;
+		const changes = (() => {
+			if (!widgetValue?.left && !widgetValue?.right) return;
+			if (widgetValue?.left && !widgetValue.right) return { op: "removed" };
+			if (!widgetValue?.left && widgetValue?.right) {
+				if (widgetValue.right?.type === "Group") {
+					const group = {
+						...widgetValue.right,
+						config: {
+							...widgetValue.right.config,
+							fields: {}
+						}
+					};
+					group.config.fields = compareWidgets(void 0, widgetValue.right.config?.fields) || {};
+					return {
+						op: "added",
+						value: group
+					};
+				}
+				return {
+					op: "added",
+					value: widgetValue.right
+				};
+			}
+			if (widgetValue.right?.type === "Group") {
+				const group = {
+					...widgetValue.right,
+					config: {
+						...widgetValue.right.config,
+						fields: {}
+					}
+				};
+				group.config.fields = compareWidgets(widgetValue.left?.type === "Group" ? widgetValue.left?.config?.fields : void 0, widgetValue.right.config?.fields) || {};
+				return {
+					op: "updated",
+					value: group
+				};
+			}
+			return {
+				op: "updated",
+				value: widgetValue.right
+			};
+		})();
+		if (!changes) return acc;
+		return {
+			...acc,
+			[widgetKey]: changes
+		};
+	}, {});
+	return isNotEmpty(diffWidgets) ? diffWidgets : void 0;
+}
+const VariationDiffComparator = { compare(variationA, variationB) {
+	if (variationA && !variationB) return { op: "removed" };
+	if (!variationA && variationB) return {
+		op: "added",
+		value: variationB
+	};
+	const diffMeta = compareVariationMeta(variationA, variationB);
+	const diffPrimary = compareWidgets(variationA?.primary, variationB?.primary);
+	const diffItems = compareWidgets(variationA?.items, variationB?.items);
+	const diffVariation = {
+		...diffMeta,
+		...diffPrimary ? { primary: diffPrimary } : {},
+		...diffItems ? { items: diffItems } : {}
+	};
+	if (isNotEmpty(diffVariation)) return {
+		op: "updated",
+		value: diffVariation
+	};
+} };
+//#endregion
+export { VariationDiffComparator };
+
+//# sourceMappingURL=variation.js.map

package/dist/model/diff/variation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variation.js","names":[],"sources":["../../../src/model/diff/variation.ts"],"sourcesContent":["import type { GroupModel } from \"../group\"\nimport { GroupFieldType } from \"../group\"\nimport type { NestableModel } from \"../nestable\"\nimport type { SharedSliceModelVariation } from \"../slice\"\nimport { type Diff, DiffOperation } from \"./changes\"\nimport { isNotEmpty, zipObjects } from \"./utils\"\nimport type {\n\tGroupWidgetWithFieldsDiff,\n\tNestableWidgetDiff,\n\tSlicePrimaryWidgetDiff,\n} from \"./widgets\"\n\nexport type VariationDiffMetadata = Omit<SharedSliceModelVariation, \"primary\" | \"items\">\nexport type VariationDiff = Diff<\n\tSharedSliceModelVariation,\n\tPartial<VariationDiffMetadata> & {\n\t\tprimary?: Record<string, SlicePrimaryWidgetDiff>\n\t\titems?: Record<string, NestableWidgetDiff>\n\t}\n>\n\nfunction compareVariationMeta(\n\tvariationA?: SharedSliceModelVariation,\n\tvariationB?: SharedSliceModelVariation,\n): Partial<VariationDiffMetadata> {\n\tconst zippedVariations = zipObjects(variationA, variationB)\n\n\treturn Object.entries(zippedVariations).reduce((acc, [key, value]) => {\n\t\tif (key === \"primary\" || key === \"items\") return acc\n\n\t\tif (value?.left === value?.right) return acc\n\t\treturn { ...acc, [key]: value?.right }\n\t}, {})\n}\n\nfunction compareWidgets<TWidget extends NestableModel | GroupModel>(\n\twidgetsA?: { [key: string]: TWidget },\n\twidgetsB?: { [key: string]: TWidget },\n):\n\t| Record<string, TWidget extends GroupModel ? SlicePrimaryWidgetDiff : NestableWidgetDiff>\n\t| undefined {\n\tconst zippedWidgets = zipObjects(widgetsA, widgetsB)\n\n\tconst diffWidgets = Object.entries(zippedWidgets).reduce((acc, [widgetKey, widgetValue]) => {\n\t\tif (JSON.stringify(widgetValue?.left) === JSON.stringify(widgetValue?.right)) return acc\n\n\t\tconst changes = (() => {\n\t\t\tif (!widgetValue?.left && !widgetValue?.right) return\n\n\t\t\tif (widgetValue?.left && !widgetValue.right) {\n\t\t\t\treturn {\n\t\t\t\t\top: DiffOperation.Removed,\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (!widgetValue?.left && widgetValue?.right) {\n\t\t\t\tif (widgetValue.right?.type === GroupFieldType) {\n\t\t\t\t\tconst group: GroupWidgetWithFieldsDiff = {\n\t\t\t\t\t\t...widgetValue.right,\n\t\t\t\t\t\tconfig: {\n\t\t\t\t\t\t\t...widgetValue.right.config,\n\t\t\t\t\t\t\tfields: {},\n\t\t\t\t\t\t},\n\t\t\t\t\t}\n\t\t\t\t\t// On added groups, this basically marks all fields in the group as added\n\t\t\t\t\tgroup.config.fields = compareWidgets(undefined, widgetValue.right.config?.fields) || {}\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\top: DiffOperation.Added,\n\t\t\t\t\t\tvalue: group,\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn {\n\t\t\t\t\top: DiffOperation.Added,\n\t\t\t\t\tvalue: widgetValue.right,\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (widgetValue.right?.type === GroupFieldType) {\n\t\t\t\tconst group: GroupWidgetWithFieldsDiff = {\n\t\t\t\t\t...widgetValue.right,\n\t\t\t\t\tconfig: {\n\t\t\t\t\t\t...widgetValue.right.config,\n\t\t\t\t\t\tfields: {},\n\t\t\t\t\t},\n\t\t\t\t}\n\t\t\t\t// On updated groups, this also compares the fields inside the group\n\t\t\t\tgroup.config.fields =\n\t\t\t\t\tcompareWidgets(\n\t\t\t\t\t\twidgetValue.left?.type === GroupFieldType\n\t\t\t\t\t\t\t? widgetValue.left?.config?.fields\n\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\twidgetValue.right.config?.fields,\n\t\t\t\t\t) || {}\n\n\t\t\t\treturn {\n\t\t\t\t\top: DiffOperation.Updated,\n\t\t\t\t\tvalue: group,\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Updated,\n\t\t\t\tvalue: widgetValue.right,\n\t\t\t}\n\t\t})()\n\n\t\tif (!changes) return acc\n\n\t\treturn {\n\t\t\t...acc,\n\t\t\t[widgetKey]: changes,\n\t\t}\n\t}, {})\n\n\treturn isNotEmpty(diffWidgets) ? diffWidgets : undefined\n}\n\nexport const VariationDiffComparator = {\n\tcompare(\n\t\tvariationA?: SharedSliceModelVariation,\n\t\tvariationB?: SharedSliceModelVariation,\n\t): VariationDiff | undefined {\n\t\tif (variationA && !variationB)\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Removed,\n\t\t\t}\n\t\tif (!variationA && variationB) {\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Added,\n\t\t\t\tvalue: variationB,\n\t\t\t}\n\t\t}\n\n\t\tconst diffMeta = compareVariationMeta(variationA, variationB)\n\n\t\tconst diffPrimary = compareWidgets(variationA?.primary, variationB?.primary)\n\t\tconst diffItems = compareWidgets(variationA?.items, variationB?.items)\n\n\t\tconst diffVariation = {\n\t\t\t...diffMeta,\n\t\t\t...(diffPrimary ? { primary: diffPrimary } : {}),\n\t\t\t...(diffItems ? { items: diffItems } : {}),\n\t\t}\n\n\t\tif (isNotEmpty(diffVariation)) {\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Updated,\n\t\t\t\tvalue: diffVariation,\n\t\t\t}\n\t\t}\n\t\treturn undefined\n\t},\n}\n"],"mappings":";;;;AAqBA,SAAS,qBACR,YACA,YACiC;CACjC,MAAM,mBAAmB,WAAW,YAAY,UAAU;CAE1D,OAAO,OAAO,QAAQ,gBAAgB,CAAC,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;EACrE,IAAI,QAAQ,aAAa,QAAQ,SAAS,OAAO;EAEjD,IAAI,OAAO,SAAS,OAAO,OAAO,OAAO;EACzC,OAAO;GAAE,GAAG;IAAM,MAAM,OAAO;EAAM;CACtC,GAAG,CAAC,CAAC;AACN;AAEA,SAAS,eACR,UACA,UAGY;CACZ,MAAM,gBAAgB,WAAW,UAAU,QAAQ;CAEnD,MAAM,cAAc,OAAO,QAAQ,aAAa,CAAC,CAAC,QAAQ,KAAK,CAAC,WAAW,iBAAiB;EAC3F,IAAI,KAAK,UAAU,aAAa,IAAI,MAAM,KAAK,UAAU,aAAa,KAAK,GAAG,OAAO;EAErF,MAAM,iBAAiB;GACtB,IAAI,CAAC,aAAa,QAAQ,CAAC,aAAa,OAAO;GAE/C,IAAI,aAAa,QAAQ,CAAC,YAAY,OACrC,OAAO,EACN,IAAA,UACD;GAGD,IAAI,CAAC,aAAa,QAAQ,aAAa,OAAO;IAC7C,IAAI,YAAY,OAAO,SAAA,SAAyB;KAC/C,MAAM,QAAmC;MACxC,GAAG,YAAY;MACf,QAAQ;OACP,GAAG,YAAY,MAAM;OACrB,QAAQ,CAAC;MACV;KACD;KAEA,MAAM,OAAO,SAAS,eAAe,KAAA,GAAW,YAAY,MAAM,QAAQ,MAAM,KAAK,CAAC;KAEtF,OAAO;MACN,IAAA;MACA,OAAO;KACR;IACD;IAEA,OAAO;KACN,IAAA;KACA,OAAO,YAAY;IACpB;GACD;GAEA,IAAI,YAAY,OAAO,SAAA,SAAyB;IAC/C,MAAM,QAAmC;KACxC,GAAG,YAAY;KACf,QAAQ;MACP,GAAG,YAAY,MAAM;MACrB,QAAQ,CAAC;KACV;IACD;IAEA,MAAM,OAAO,SACZ,eACC,YAAY,MAAM,SAAA,UACf,YAAY,MAAM,QAAQ,SAC1B,KAAA,GACH,YAAY,MAAM,QAAQ,MAC3B,KAAK,CAAC;IAEP,OAAO;KACN,IAAA;KACA,OAAO;IACR;GACD;GAEA,OAAO;IACN,IAAA;IACA,OAAO,YAAY;GACpB;EACD,EAAA,CAAG;EAEH,IAAI,CAAC,SAAS,OAAO;EAErB,OAAO;GACN,GAAG;IACF,YAAY;EACd;CACD,GAAG,CAAC,CAAC;CAEL,OAAO,WAAW,WAAW,IAAI,cAAc,KAAA;AAChD;AAEA,MAAa,0BAA0B,EACtC,QACC,YACA,YAC4B;CAC5B,IAAI,cAAc,CAAC,YAClB,OAAO,EACN,IAAA,UACD;CACD,IAAI,CAAC,cAAc,YAClB,OAAO;EACN,IAAA;EACA,OAAO;CACR;CAGD,MAAM,WAAW,qBAAqB,YAAY,UAAU;CAE5D,MAAM,cAAc,eAAe,YAAY,SAAS,YAAY,OAAO;CAC3E,MAAM,YAAY,eAAe,YAAY,OAAO,YAAY,KAAK;CAErE,MAAM,gBAAgB;EACrB,GAAG;EACH,GAAI,cAAc,EAAE,SAAS,YAAY,IAAI,CAAC;EAC9C,GAAI,YAAY,EAAE,OAAO,UAAU,IAAI,CAAC;CACzC;CAEA,IAAI,WAAW,aAAa,GAC3B,OAAO;EACN,IAAA;EACA,OAAO;CACR;AAGF,EACD"}

package/dist/model/diff/widgets.d.ts

@@ -0,0 +1,15 @@
+import { NestableModel } from "../nestable.js";
+import { GroupModel } from "../group.js";
+import { Diff } from "./changes.js";
+//#region src/model/diff/widgets.d.ts
+type NestableWidgetDiff = Diff<NestableModel, NestableModel>;
+type GroupWidgetWithFieldsDiff = Omit<GroupModel, "config"> & {
+  config: Omit<NonNullable<GroupModel["config"]>, "fields"> & {
+    fields?: Record<string, GroupWidgetDiff | NestableWidgetDiff>;
+  };
+};
+type GroupWidgetDiff = Diff<GroupWidgetWithFieldsDiff, GroupWidgetWithFieldsDiff>;
+type SlicePrimaryWidgetDiff = NestableWidgetDiff | GroupWidgetDiff;
+//#endregion
+export { GroupWidgetDiff, GroupWidgetWithFieldsDiff, NestableWidgetDiff, SlicePrimaryWidgetDiff };
+//# sourceMappingURL=widgets.d.ts.map

package/dist/model/diff/widgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgets.d.ts","names":[],"sources":["../../../src/model/diff/widgets.ts"],"mappings":";;;;KAIY,qBAAqB,KAAK,eAAe;KAEzC,4BAA4B,KAAK;EAC5C,QAAQ,KAAK,YAAY;IACxB,SAAS,eAAe,kBAAkB;;;KAIhC,kBAAkB,KAAK,2BAA2B;KAElD,yBAAyB,qBAAqB"}

package/dist/model/embed.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod/mini";
-
 //#region src/model/embed.d.ts
 declare const EmbedModelSchema: z.ZodMiniObject<{
   type: z.ZodMiniLiteral<"Embed">;
@@ -12,5 +11,5 @@ declare const EmbedModelSchema: z.ZodMiniObject<{
 }, z.core.$strip>;
 type EmbedModel = z.infer<typeof EmbedModelSchema>;
 //#endregion
-export { EmbedModel };
+export { EmbedModel, EmbedModelSchema };
 //# sourceMappingURL=embed.d.ts.map

package/dist/model/embed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embed.d.ts","names":[],"sources":["../../src/model/embed.ts"],"mappings":";;;cAQa,gBAAA,EAAgB,CAAA,CAAA,aAAA;;;;;;;;;KAMjB,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,gBAAA"}
+{"version":3,"file":"embed.d.ts","names":[],"sources":["../../src/model/embed.ts"],"mappings":";;cAQa,kBAAgB,EAAA;;;;;;;;;KAMjB,aAAa,EAAE,aAAa"}

package/dist/model/embed.js.map

@@ -1 +1 @@
-{"version":3,"file":"embed.js","names":[],"sources":["../../src/model/embed.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst EmbedConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tplaceholder: z.optional(z.string()),\n\tuseAsTitle: z.optional(z.boolean()),\n})\n\nexport const EmbedModelSchema = z.object({\n\ttype: z.literal(\"Embed\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(EmbedConfigSchema),\n})\n\nexport type EmbedModel = z.infer<typeof EmbedModelSchema>\n"],"mappings":";;AAEA,MAAM,oBAAoB,EAAE,OAAO;CAClC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,YAAY,EAAE,SAAS,EAAE,SAAS,CAAC;CACnC,CAAC;AAEF,MAAa,mBAAmB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,QAAQ;CACxB,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,kBAAkB;CACrC,CAAC"}
+{"version":3,"file":"embed.js","names":[],"sources":["../../src/model/embed.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst EmbedConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tplaceholder: z.optional(z.string()),\n\tuseAsTitle: z.optional(z.boolean()),\n})\n\nexport const EmbedModelSchema = z.object({\n\ttype: z.literal(\"Embed\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(EmbedConfigSchema),\n})\n\nexport type EmbedModel = z.infer<typeof EmbedModelSchema>\n"],"mappings":";;AAEA,MAAM,oBAAoB,EAAE,OAAO;CAClC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC3B,aAAa,EAAE,SAAS,EAAE,OAAO,CAAC;CAClC,YAAY,EAAE,SAAS,EAAE,QAAQ,CAAC;AACnC,CAAC;AAED,MAAa,mBAAmB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,OAAO;CACvB,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC9B,QAAQ,EAAE,SAAS,iBAAiB;AACrC,CAAC"}

package/dist/model/geopoint.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod/mini";
-
 //#region src/model/geopoint.d.ts
 declare const GeoPointModelSchema: z.ZodMiniObject<{
   type: z.ZodMiniLiteral<"GeoPoint">;
@@ -10,5 +9,5 @@ declare const GeoPointModelSchema: z.ZodMiniObject<{
 }, z.core.$strip>;
 type GeoPointModel = z.infer<typeof GeoPointModelSchema>;
 //#endregion
-export { GeoPointModel };
+export { GeoPointModel, GeoPointModelSchema };
 //# sourceMappingURL=geopoint.d.ts.map

package/dist/model/geopoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geopoint.d.ts","names":[],"sources":["../../src/model/geopoint.ts"],"mappings":";;;cAMa,mBAAA,EAAmB,CAAA,CAAA,aAAA;;;;;;;KAMpB,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA"}
+{"version":3,"file":"geopoint.d.ts","names":[],"sources":["../../src/model/geopoint.ts"],"mappings":";;cAMa,qBAAmB,EAAA;;;;;;;KAMpB,gBAAgB,EAAE,aAAa"}

package/dist/model/geopoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"geopoint.js","names":[],"sources":["../../src/model/geopoint.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst GeoPointConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n})\n\nexport const GeoPointModelSchema = z.object({\n\ttype: z.literal(\"GeoPoint\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(GeoPointConfigSchema),\n})\n\nexport type GeoPointModel = z.infer<typeof GeoPointModelSchema>\n"],"mappings":";;AAEA,MAAM,uBAAuB,EAAE,OAAO,EACrC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAC5B,CAAC;AAEF,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,WAAW;CAC3B,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,qBAAqB;CACxC,CAAC"}
+{"version":3,"file":"geopoint.js","names":[],"sources":["../../src/model/geopoint.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst GeoPointConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n})\n\nexport const GeoPointModelSchema = z.object({\n\ttype: z.literal(\"GeoPoint\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(GeoPointConfigSchema),\n})\n\nexport type GeoPointModel = z.infer<typeof GeoPointModelSchema>\n"],"mappings":";;AAEA,MAAM,uBAAuB,EAAE,OAAO,EACrC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAC5B,CAAC;AAED,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,UAAU;CAC1B,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC9B,QAAQ,EAAE,SAAS,oBAAoB;AACxC,CAAC"}

package/dist/model/group.d.ts

@@ -1,6 +1,5 @@
 import { NestableModel } from "./nestable.js";
 import { z } from "zod/mini";
-
 //#region src/model/group.d.ts
 declare const NestedGroupModelSchema: z.ZodMiniObject<{
   type: z.ZodMiniLiteral<"Group">;
@@ -78,7 +77,7 @@ declare const NestedGroupModelSchema: z.ZodMiniObject<{
         label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
         useAsTitle: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
         placeholder: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        select: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<"media" | "document" | "web" | null, unknown>>>;
+        select: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<"document" | "media" | "web" | null, unknown>>>;
         customtypes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
           id: z.ZodMiniString<string>;
           fields: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
@@ -194,7 +193,7 @@ declare const GroupModelSchema: z.ZodMiniObject<{
   config: z.ZodMiniOptional<z.ZodMiniObject<{
     label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
     repeat: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    fields: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<NestableModel | {
+    fields: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniType<{
       type: "Group";
       fieldset?: string | null | undefined;
       icon?: string | undefined;
@@ -203,6 +202,22 @@ declare const GroupModelSchema: z.ZodMiniObject<{
         label?: string | null | undefined;
         repeat?: boolean | undefined;
         fields?: Record<string, {
+          type: "StructuredText";
+          fieldset?: string | null | undefined;
+          config?: {
+            label?: string | null | undefined;
+            placeholder?: string | undefined;
+            useAsTitle?: boolean | undefined;
+            single?: string | undefined;
+            multi?: string | undefined;
+            imageConstraint?: {
+              width?: number | null | undefined;
+              height?: number | null | undefined;
+            } | undefined;
+            labels?: string[] | undefined;
+            allowTargetBlank?: boolean | undefined;
+          } | undefined;
+        } | {
           type: "Boolean";
           config?: {
             label?: string | null | undefined;
@@ -270,7 +285,7 @@ declare const GroupModelSchema: z.ZodMiniObject<{
             label?: string | null | undefined;
             useAsTitle?: boolean | undefined;
             placeholder?: string | undefined;
-            select?: "media" | "document" | "web" | null | undefined;
+            select?: "document" | "media" | "web" | null | undefined;
             customtypes?: (string | {
               id: string;
               fields: (string | {
@@ -323,22 +338,6 @@ declare const GroupModelSchema: z.ZodMiniObject<{
             max?: number | undefined;
             step?: number | undefined;
           } | undefined;
-        } | {
-          type: "StructuredText";
-          fieldset?: string | null | undefined;
-          config?: {
-            label?: string | null | undefined;
-            placeholder?: string | undefined;
-            useAsTitle?: boolean | undefined;
-            single?: string | undefined;
-            multi?: string | undefined;
-            imageConstraint?: {
-              width?: number | null | undefined;
-              height?: number | null | undefined;
-            } | undefined;
-            labels?: string[] | undefined;
-            allowTargetBlank?: boolean | undefined;
-          } | undefined;
         } | {
           type: "Select";
           fieldset?: string | null | undefined;
@@ -376,7 +375,7 @@ declare const GroupModelSchema: z.ZodMiniObject<{
           } | undefined;
         }> | undefined;
       } | undefined;
-    }, unknown, z.core.$ZodTypeInternals<NestableModel | {
+    } | NestableModel, unknown, z.core.$ZodTypeInternals<{
       type: "Group";
       fieldset?: string | null | undefined;
       icon?: string | undefined;
@@ -385,6 +384,22 @@ declare const GroupModelSchema: z.ZodMiniObject<{
         label?: string | null | undefined;
         repeat?: boolean | undefined;
         fields?: Record<string, {
+          type: "StructuredText";
+          fieldset?: string | null | undefined;
+          config?: {
+            label?: string | null | undefined;
+            placeholder?: string | undefined;
+            useAsTitle?: boolean | undefined;
+            single?: string | undefined;
+            multi?: string | undefined;
+            imageConstraint?: {
+              width?: number | null | undefined;
+              height?: number | null | undefined;
+            } | undefined;
+            labels?: string[] | undefined;
+            allowTargetBlank?: boolean | undefined;
+          } | undefined;
+        } | {
           type: "Boolean";
           config?: {
             label?: string | null | undefined;
@@ -452,7 +467,7 @@ declare const GroupModelSchema: z.ZodMiniObject<{
             label?: string | null | undefined;
             useAsTitle?: boolean | undefined;
             placeholder?: string | undefined;
-            select?: "media" | "document" | "web" | null | undefined;
+            select?: "document" | "media" | "web" | null | undefined;
             customtypes?: (string | {
               id: string;
               fields: (string | {
@@ -505,22 +520,6 @@ declare const GroupModelSchema: z.ZodMiniObject<{
             max?: number | undefined;
             step?: number | undefined;
           } | undefined;
-        } | {
-          type: "StructuredText";
-          fieldset?: string | null | undefined;
-          config?: {
-            label?: string | null | undefined;
-            placeholder?: string | undefined;
-            useAsTitle?: boolean | undefined;
-            single?: string | undefined;
-            multi?: string | undefined;
-            imageConstraint?: {
-              width?: number | null | undefined;
-              height?: number | null | undefined;
-            } | undefined;
-            labels?: string[] | undefined;
-            allowTargetBlank?: boolean | undefined;
-          } | undefined;
         } | {
           type: "Select";
           fieldset?: string | null | undefined;
@@ -558,10 +557,10 @@ declare const GroupModelSchema: z.ZodMiniObject<{
           } | undefined;
         }> | undefined;
       } | undefined;
-    }, unknown>>>>;
+    } | NestableModel, unknown>>>>;
   }, z.core.$strip>>;
 }, z.core.$strip>;
 type GroupModel = z.infer<typeof GroupModelSchema>;
 //#endregion
-export { GroupModel, NestedGroupModel };
+export { GroupModel, GroupModelSchema, NestedGroupModel, NestedGroupModelSchema };
 //# sourceMappingURL=group.d.ts.map

package/dist/model/group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"group.d.ts","names":[],"sources":["../../src/model/group.ts"],"mappings":";;;;cA2Ba,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,cAGjC,gBAAA,EAAgB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMjB,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,gBAAA"}
+{"version":3,"file":"group.d.ts","names":[],"sources":["../../src/model/group.ts"],"mappings":";;;cA2Ba,wBAAsB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEvB,mBAAmB,EAAE,aAAa;cAGjC,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMjB,aAAa,EAAE,aAAa"}

package/dist/model/group.js

@@ -18,6 +18,6 @@ const createGroupSchema = (widgets) => z.object({
 const NestedGroupModelSchema = createGroupSchema(NestableModelSchema);
 const GroupModelSchema = createGroupSchema(z.discriminatedUnion("type", [NestableModelSchema, NestedGroupModelSchema]));
 //#endregion
-export { GroupModelSchema, NestedGroupModelSchema };
+export { GroupFieldType, GroupModelSchema, NestedGroupModelSchema };
 
 //# sourceMappingURL=group.js.map

package/dist/model/group.js.map

@@ -1 +1 @@
-{"version":3,"file":"group.js","names":[],"sources":["../../src/model/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { WidgetKeySchema } from \"../common/widgetKey\"\nimport type { NestableModel } from \"./nestable\"\nimport { NestableModelSchema } from \"./nestable\"\n\nexport const GroupFieldType = \"Group\"\n\n// Factory to create group config schema with configurable widget types\nconst createGroupConfigSchema = <TWidgets extends z.ZodMiniType>(widgets: TWidgets) =>\n\tz.object({\n\t\tlabel: z.nullish(z.string()),\n\t\trepeat: z.optional(z.boolean()),\n\t\tfields: z.optional(z.record(WidgetKeySchema, widgets)),\n\t})\n\n// Factory to create group schema with configurable widget types\nconst createGroupSchema = <TWidgets extends z.ZodMiniType>(widgets: TWidgets) =>\n\tz.object({\n\t\ttype: z.literal(GroupFieldType),\n\t\tfieldset: z.nullish(z.string()),\n\t\ticon: z.optional(z.string()),\n\t\tdescription: z.optional(z.string()),\n\t\tconfig: z.optional(createGroupConfigSchema(widgets)),\n\t})\n\n// NestedGroup - only allows Nestable in fields (no further nesting)\nexport const NestedGroupModelSchema = createGroupSchema(NestableModelSchema)\n\nexport type NestedGroupModel = z.infer<typeof NestedGroupModelSchema>\n\n// Group - allows Nestable | NestedGroup in fields (max 2 levels of nesting)\nexport const GroupModelSchema = createGroupSchema(\n\tz.discriminatedUnion(\"type\", [NestableModelSchema, NestedGroupModelSchema]) as z.ZodMiniType<\n\t\tNestableModel | NestedGroupModel\n\t>,\n)\n\nexport type GroupModel = z.infer<typeof GroupModelSchema>\n"],"mappings":";;;;AAMA,MAAa,iBAAiB;AAG9B,MAAM,2BAA2D,YAChE,EAAE,OAAO;CACR,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC;CAC/B,QAAQ,EAAE,SAAS,EAAE,OAAO,iBAAiB,QAAQ,CAAC;CACtD,CAAC;AAGH,MAAM,qBAAqD,YAC1D,EAAE,OAAO;CACR,MAAM,EAAE,QAAQ,eAAe;CAC/B,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC5B,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,QAAQ,EAAE,SAAS,wBAAwB,QAAQ,CAAC;CACpD,CAAC;AAGH,MAAa,yBAAyB,kBAAkB,oBAAoB;AAK5E,MAAa,mBAAmB,kBAC/B,EAAE,mBAAmB,QAAQ,CAAC,qBAAqB,uBAAuB,CAAC,CAG3E"}
+{"version":3,"file":"group.js","names":[],"sources":["../../src/model/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { WidgetKeySchema } from \"../common/widgetKey\"\nimport type { NestableModel } from \"./nestable\"\nimport { NestableModelSchema } from \"./nestable\"\n\nexport const GroupFieldType = \"Group\"\n\n// Factory to create group config schema with configurable widget types\nconst createGroupConfigSchema = <TWidgets extends z.ZodMiniType>(widgets: TWidgets) =>\n\tz.object({\n\t\tlabel: z.nullish(z.string()),\n\t\trepeat: z.optional(z.boolean()),\n\t\tfields: z.optional(z.record(WidgetKeySchema, widgets)),\n\t})\n\n// Factory to create group schema with configurable widget types\nconst createGroupSchema = <TWidgets extends z.ZodMiniType>(widgets: TWidgets) =>\n\tz.object({\n\t\ttype: z.literal(GroupFieldType),\n\t\tfieldset: z.nullish(z.string()),\n\t\ticon: z.optional(z.string()),\n\t\tdescription: z.optional(z.string()),\n\t\tconfig: z.optional(createGroupConfigSchema(widgets)),\n\t})\n\n// NestedGroup - only allows Nestable in fields (no further nesting)\nexport const NestedGroupModelSchema = createGroupSchema(NestableModelSchema)\n\nexport type NestedGroupModel = z.infer<typeof NestedGroupModelSchema>\n\n// Group - allows Nestable | NestedGroup in fields (max 2 levels of nesting)\nexport const GroupModelSchema = createGroupSchema(\n\tz.discriminatedUnion(\"type\", [NestableModelSchema, NestedGroupModelSchema]) as z.ZodMiniType<\n\t\tNestableModel | NestedGroupModel\n\t>,\n)\n\nexport type GroupModel = z.infer<typeof GroupModelSchema>\n"],"mappings":";;;;AAMA,MAAa,iBAAiB;AAG9B,MAAM,2BAA2D,YAChE,EAAE,OAAO;CACR,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC3B,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC9B,QAAQ,EAAE,SAAS,EAAE,OAAO,iBAAiB,OAAO,CAAC;AACtD,CAAC;AAGF,MAAM,qBAAqD,YAC1D,EAAE,OAAO;CACR,MAAM,EAAE,QAAQ,cAAc;CAC9B,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC9B,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC;CAC3B,aAAa,EAAE,SAAS,EAAE,OAAO,CAAC;CAClC,QAAQ,EAAE,SAAS,wBAAwB,OAAO,CAAC;AACpD,CAAC;AAGF,MAAa,yBAAyB,kBAAkB,mBAAmB;AAK3E,MAAa,mBAAmB,kBAC/B,EAAE,mBAAmB,QAAQ,CAAC,qBAAqB,sBAAsB,CAAC,CAG3E"}

package/dist/model/image.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod/mini";
-
 //#region src/model/image.d.ts
 declare const ImageModelSchema: z.ZodMiniObject<{
   type: z.ZodMiniLiteral<"Image">;
@@ -20,5 +19,5 @@ declare const ImageModelSchema: z.ZodMiniObject<{
 }, z.core.$strip>;
 type ImageModel = z.infer<typeof ImageModelSchema>;
 //#endregion
-export { ImageModel };
+export { ImageModel, ImageModelSchema };
 //# sourceMappingURL=image.d.ts.map

package/dist/model/image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","names":[],"sources":["../../src/model/image.ts"],"mappings":";;;cA+Ca,gBAAA,EAAgB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;KAMjB,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,gBAAA"}
+{"version":3,"file":"image.d.ts","names":[],"sources":["../../src/model/image.ts"],"mappings":";;cAkDa,kBAAgB,EAAA;;;;;;;;;;;;;;;;;KAMjB,aAAa,EAAE,aAAa"}

package/dist/model/image.js

@@ -36,6 +36,6 @@ const ImageModelSchema = z.object({
 	config: z.optional(ImageConfigSchema)
 });
 //#endregion
-export { ImageConstraintSchema, ImageModelSchema };
+export { ImageConstraintSchema, ImageModelSchema, SideConstraintSchema };
 
 //# sourceMappingURL=image.js.map

package/dist/model/image.js.map

@@ -1 +1 @@
-{"version":3,"file":"image.js","names":[],"sources":["../../src/model/image.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\n/**\n * SideConstraint accepts multiple input formats and normalizes to number | null:\n * - Integer values\n * - String integers (e.g., \"100\")\n * - Pixel strings (e.g., \"100px\")\n * - \"auto\" or \"\" → null\n * - null\n */\nexport const SideConstraintSchema: z.ZodMiniType<number | null> = z.union([\n\tz.pipe(\n\t\tz.literal(\"auto\"),\n\t\tz.transform(() => null),\n\t),\n\tz.pipe(\n\t\tz.literal(\"\"),\n\t\tz.transform(() => null),\n\t),\n\tz.null(),\n\tz.pipe(z.number(), z.transform((n) => Math.round(n))),\n\tz.pipe(\n\t\tz.string(),\n\t\tz.transform((s: string) => parseInt(s.replace(\"px\", \"\"), 10)),\n\t),\n])\n\nexport const ImageConstraintSchema = z.object({\n\twidth: z.optional(SideConstraintSchema),\n\theight: z.optional(SideConstraintSchema),\n})\n\nexport type ImageConstraint = z.infer<typeof ImageConstraintSchema>\n\nconst ThumbnailSchema = z.object({\n\tname: z.string(),\n\twidth: z.optional(SideConstraintSchema),\n\theight: z.optional(SideConstraintSchema),\n})\n\nconst ImageConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tplaceholder: z.optional(z.string()),\n\tconstraint: z.optional(ImageConstraintSchema),\n\tthumbnails: z.optional(z.array(ThumbnailSchema)),\n})\n\nexport const ImageModelSchema = z.object({\n\ttype: z.literal(\"Image\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(ImageConfigSchema),\n})\n\nexport type ImageModel = z.infer<typeof ImageModelSchema>\n"],"mappings":";;;;;;;;;;AAUA,MAAa,uBAAqD,EAAE,MAAM;CACzE,EAAE,KACD,EAAE,QAAQ,OAAO,EACjB,EAAE,gBAAgB,KAAK,CACvB;CACD,EAAE,KACD,EAAE,QAAQ,GAAG,EACb,EAAE,gBAAgB,KAAK,CACvB;CACD,EAAE,MAAM;CACR,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,WAAW,MAAM,KAAK,MAAM,EAAE,CAAC,CAAC;CACrD,EAAE,KACD,EAAE,QAAQ,EACV,EAAE,WAAW,MAAc,SAAS,EAAE,QAAQ,MAAM,GAAG,EAAE,GAAG,CAAC,CAC7D;CACD,CAAC;AAEF,MAAa,wBAAwB,EAAE,OAAO;CAC7C,OAAO,EAAE,SAAS,qBAAqB;CACvC,QAAQ,EAAE,SAAS,qBAAqB;CACxC,CAAC;AAIF,MAAM,kBAAkB,EAAE,OAAO;CAChC,MAAM,EAAE,QAAQ;CAChB,OAAO,EAAE,SAAS,qBAAqB;CACvC,QAAQ,EAAE,SAAS,qBAAqB;CACxC,CAAC;AAEF,MAAM,oBAAoB,EAAE,OAAO;CAClC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,YAAY,EAAE,SAAS,sBAAsB;CAC7C,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;CAChD,CAAC;AAEF,MAAa,mBAAmB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,QAAQ;CACxB,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,kBAAkB;CACrC,CAAC"}
+{"version":3,"file":"image.js","names":[],"sources":["../../src/model/image.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\n/**\n * SideConstraint accepts multiple input formats and normalizes to number | null:\n * - Integer values\n * - String integers (e.g., \"100\")\n * - Pixel strings (e.g., \"100px\")\n * - \"auto\" or \"\" → null\n * - null\n */\nexport const SideConstraintSchema: z.ZodMiniType<number | null> = z.union([\n\tz.pipe(\n\t\tz.literal(\"auto\"),\n\t\tz.transform(() => null),\n\t),\n\tz.pipe(\n\t\tz.literal(\"\"),\n\t\tz.transform(() => null),\n\t),\n\tz.null(),\n\tz.pipe(\n\t\tz.number(),\n\t\tz.transform((n) => Math.round(n)),\n\t),\n\tz.pipe(\n\t\tz.string(),\n\t\tz.transform((s: string) => parseInt(s.replace(\"px\", \"\"), 10)),\n\t),\n])\n\nexport const ImageConstraintSchema = z.object({\n\twidth: z.optional(SideConstraintSchema),\n\theight: z.optional(SideConstraintSchema),\n})\n\nexport type ImageConstraint = z.infer<typeof ImageConstraintSchema>\n\nconst ThumbnailSchema = z.object({\n\tname: z.string(),\n\twidth: z.optional(SideConstraintSchema),\n\theight: z.optional(SideConstraintSchema),\n})\n\nconst ImageConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tplaceholder: z.optional(z.string()),\n\tconstraint: z.optional(ImageConstraintSchema),\n\tthumbnails: z.optional(z.array(ThumbnailSchema)),\n})\n\nexport const ImageModelSchema = z.object({\n\ttype: z.literal(\"Image\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(ImageConfigSchema),\n})\n\nexport type ImageModel = z.infer<typeof ImageModelSchema>\n"],"mappings":";;;;;;;;;;AAUA,MAAa,uBAAqD,EAAE,MAAM;CACzE,EAAE,KACD,EAAE,QAAQ,MAAM,GAChB,EAAE,gBAAgB,IAAI,CACvB;CACA,EAAE,KACD,EAAE,QAAQ,EAAE,GACZ,EAAE,gBAAgB,IAAI,CACvB;CACA,EAAE,KAAK;CACP,EAAE,KACD,EAAE,OAAO,GACT,EAAE,WAAW,MAAM,KAAK,MAAM,CAAC,CAAC,CACjC;CACA,EAAE,KACD,EAAE,OAAO,GACT,EAAE,WAAW,MAAc,SAAS,EAAE,QAAQ,MAAM,EAAE,GAAG,EAAE,CAAC,CAC7D;AACD,CAAC;AAED,MAAa,wBAAwB,EAAE,OAAO;CAC7C,OAAO,EAAE,SAAS,oBAAoB;CACtC,QAAQ,EAAE,SAAS,oBAAoB;AACxC,CAAC;AAID,MAAM,kBAAkB,EAAE,OAAO;CAChC,MAAM,EAAE,OAAO;CACf,OAAO,EAAE,SAAS,oBAAoB;CACtC,QAAQ,EAAE,SAAS,oBAAoB;AACxC,CAAC;AAED,MAAM,oBAAoB,EAAE,OAAO;CAClC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC3B,aAAa,EAAE,SAAS,EAAE,OAAO,CAAC;CAClC,YAAY,EAAE,SAAS,qBAAqB;CAC5C,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAChD,CAAC;AAED,MAAa,mBAAmB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,OAAO;CACvB,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC9B,QAAQ,EAAE,SAAS,iBAAiB;AACrC,CAAC"}

package/dist/model/integrationField.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod/mini";
-
 //#region src/model/integrationField.d.ts
 declare const IntegrationFieldModelSchema: z.ZodMiniObject<{
   type: z.ZodMiniLiteral<"IntegrationFields">;
@@ -12,5 +11,5 @@ declare const IntegrationFieldModelSchema: z.ZodMiniObject<{
 }, z.core.$strip>;
 type IntegrationFieldModel = z.infer<typeof IntegrationFieldModelSchema>;
 //#endregion
-export { IntegrationFieldModel };
+export { IntegrationFieldModel, IntegrationFieldModelSchema };
 //# sourceMappingURL=integrationField.d.ts.map

package/dist/model/integrationField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrationField.d.ts","names":[],"sources":["../../src/model/integrationField.ts"],"mappings":";;;cAQa,2BAAA,EAA2B,CAAA,CAAA,aAAA;;;;;;;;;KAM5B,qBAAA,GAAwB,CAAA,CAAE,KAAA,QAAa,2BAAA"}
+{"version":3,"file":"integrationField.d.ts","names":[],"sources":["../../src/model/integrationField.ts"],"mappings":";;cAQa,6BAA2B,EAAA;;;;;;;;;KAM5B,wBAAwB,EAAE,aAAa"}

package/dist/model/integrationField.js.map

@@ -1 +1 @@
-{"version":3,"file":"integrationField.js","names":[],"sources":["../../src/model/integrationField.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst IntegrationFieldConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tplaceholder: z.optional(z.string()),\n\tcatalog: z.optional(z.string()),\n})\n\nexport const IntegrationFieldModelSchema = z.object({\n\ttype: z.literal(\"IntegrationFields\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(IntegrationFieldConfigSchema),\n})\n\nexport type IntegrationFieldModel = z.infer<typeof IntegrationFieldModelSchema>\n"],"mappings":";;AAEA,MAAM,+BAA+B,EAAE,OAAO;CAC7C,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,aAAa,EAAE,SAAS,EAAE,QAAQ,CAAC;CACnC,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC/B,CAAC;AAEF,MAAa,8BAA8B,EAAE,OAAO;CACnD,MAAM,EAAE,QAAQ,oBAAoB;CACpC,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC/B,QAAQ,EAAE,SAAS,6BAA6B;CAChD,CAAC"}
+{"version":3,"file":"integrationField.js","names":[],"sources":["../../src/model/integrationField.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nconst IntegrationFieldConfigSchema = z.object({\n\tlabel: z.nullish(z.string()),\n\tplaceholder: z.optional(z.string()),\n\tcatalog: z.optional(z.string()),\n})\n\nexport const IntegrationFieldModelSchema = z.object({\n\ttype: z.literal(\"IntegrationFields\"),\n\tfieldset: z.nullish(z.string()),\n\tconfig: z.optional(IntegrationFieldConfigSchema),\n})\n\nexport type IntegrationFieldModel = z.infer<typeof IntegrationFieldModelSchema>\n"],"mappings":";;AAEA,MAAM,+BAA+B,EAAE,OAAO;CAC7C,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC3B,aAAa,EAAE,SAAS,EAAE,OAAO,CAAC;CAClC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC;AAC/B,CAAC;AAED,MAAa,8BAA8B,EAAE,OAAO;CACnD,MAAM,EAAE,QAAQ,mBAAmB;CACnC,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC;CAC9B,QAAQ,EAAE,SAAS,4BAA4B;AAChD,CAAC"}

package/dist/model/link.d.ts

@@ -1,6 +1,31 @@
 import { z } from "zod/mini";
-
 //#region src/model/link.d.ts
+declare const CustomTypesModelSchema: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+  id: z.ZodMiniString<string>;
+  fields: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    id: z.ZodMiniString<string>;
+    fields: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+      id: z.ZodMiniString<string>;
+      customtypes: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+        fields: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+          id: z.ZodMiniString<string>;
+          fields: z.ZodMiniArray<z.ZodMiniString<string>>;
+        }, z.core.$strip>, z.ZodMiniString<string>]>>;
+      }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodMiniString<string>]>>;
+  }, z.core.$strip>, z.ZodMiniObject<{
+    id: z.ZodMiniString<string>;
+    customtypes: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+      id: z.ZodMiniString<string>;
+      fields: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+        fields: z.ZodMiniArray<z.ZodMiniString<string>>;
+      }, z.core.$strip>, z.ZodMiniString<string>]>>;
+    }, z.core.$strip>]>>;
+  }, z.core.$strip>, z.ZodMiniString<string>]>>;
+}, z.core.$strip>]>>;
+type CustomTypesModel = z.infer<typeof CustomTypesModelSchema>;
 declare const LinkModelSchema: z.ZodMiniObject<{
   type: z.ZodMiniLiteral<"Link">;
   fieldset: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
@@ -8,7 +33,7 @@ declare const LinkModelSchema: z.ZodMiniObject<{
     label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
     useAsTitle: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
     placeholder: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    select: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<"media" | "document" | "web" | null, unknown>>>;
+    select: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnknown, z.ZodMiniTransform<"document" | "media" | "web" | null, unknown>>>;
     customtypes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
       id: z.ZodMiniString<string>;
       fields: z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
@@ -44,5 +69,5 @@ declare const LinkModelSchema: z.ZodMiniObject<{
 }, z.core.$strip>;
 type LinkModel = z.infer<typeof LinkModelSchema>;
 //#endregion
-export { LinkModel };
+export { CustomTypesModel, CustomTypesModelSchema, LinkModel, LinkModelSchema };
 //# sourceMappingURL=link.d.ts.map

package/dist/model/link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"link.d.ts","names":[],"sources":["../../src/model/link.ts"],"mappings":";;;cAsIa,eAAA,EAAe,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMhB,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,eAAA"}
+{"version":3,"file":"link.d.ts","names":[],"sources":["../../src/model/link.ts"],"mappings":";;cA6Ea,wBAAsB,EAAA,aAAA,EAAA,uBAAA,EAAA,uBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;KA6BvB,mBAAmB,EAAE,aAAa;cA8BjC,iBAAe,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMhB,YAAY,EAAE,aAAa"}

package/dist/model/link.js

@@ -36,7 +36,7 @@ const CustomTypeLevel1Schema = z.union([z.string(), z.object({
 	id: z.string(),
 	fields: CustomTypeLevel1FieldsSchema
 })]);
-const CustomTypesSchema = z.array(CustomTypeLevel1Schema).check(({ value, issues }) => {
+const CustomTypesModelSchema = z.array(CustomTypeLevel1Schema).check(({ value, issues }) => {
 	const cts = value;
 	const push = (message) => issues.push({
 		code: "custom",
@@ -75,7 +75,7 @@ const LinkConfigSchema = z.object({
 	useAsTitle: z.optional(z.boolean()),
 	placeholder: z.optional(z.string()),
 	select: z.optional(SelectWithFallbackSchema),
-	customtypes: z.optional(CustomTypesSchema),
+	customtypes: z.optional(CustomTypesModelSchema),
 	masks: z.optional(MasksArrayStringSchema),
 	tags: z.optional(MasksArrayStringSchema),
 	allowTargetBlank: z.optional(z.boolean()),
@@ -89,6 +89,6 @@ const LinkModelSchema = z.object({
 	config: z.optional(LinkConfigSchema)
 });
 //#endregion
-export { LinkModelSchema };
+export { CustomTypesModelSchema, LinkModelSchema };
 
 //# sourceMappingURL=link.js.map