@prismicio/types-internal 3.17.0-alpha.2 → 3.17.0-pr.144.0c8207f

package/dist/customtypes/Section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Section.d.ts","names":[],"sources":["../../src/customtypes/Section.ts"],"mappings":";;;;;;;;;;;;iBASgB,aAAA,WAAwB,YAAA,GAAe,aAAA,CAAA,CAAe,KAAA,EAAO,CAAA,CAAE,IAAA,CAAK,CAAA,aAAW,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,IAAA,2BAAA,CAAA,CAAA,IAAA,CAAA,CAAA;AAAA,cAIlF,aAAA,EAAa,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,IAAA,2BAAA,CAAA,CAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACd,aAAA,GAAgB,CAAA,CAAE,MAAA,QAAc,aAAA;AAAA,cAE/B,cAAA,EAAc,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,IAAA,2BAAA,CAAA,CAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACf,cAAA,GAAiB,CAAA,CAAE,MAAA,QAAc,cAAA;AAAA,cAEhC,QAAA;oBACM,cAAA,EAAc,YAAA,EAAgB,GAAA,SAAY,WAAA,IAAe,aAAA;AAAA;AAAA,iBAW5D,eAAA,WAA0B,cAAA,GAAiB,aAAA,CAAA,CAAe,IAAA;EACzE,IAAA,EAAM,aAAA;EACN,OAAA,EAAS,CAAA;EACT,OAAA,EAAS,SAAA,CAAiB,GAAA,GAAM,cAAA,GAAiB,KAAA,GAAQ,WAAA;AAAA,IACtD,CAAA"}

package/dist/customtypes/Section.js

@@ -0,0 +1,67 @@
+import { WidgetKey } from "../common/WidgetKey.js";
+import "../common/index.js";
+import { traverseGroup } from "./widgets/Group.js";
+import { traverseSlices } from "./widgets/slices/Slices.js";
+import { DynamicWidget, StaticWidget, Widgets } from "./widgets/Widget.js";
+import "./widgets/index.js";
+import * as t from "io-ts";
+
+//#region src/customtypes/Section.ts
+function sectionReader(codec) {
+	return t.record(WidgetKey, codec);
+}
+const StaticSection = sectionReader(StaticWidget);
+const DynamicSection = sectionReader(DynamicWidget);
+const Sections = { toStatic(dynamic, sharedSlices) {
+	return Object.entries(dynamic).reduce((acc, [widgetKey, widget]) => {
+		return {
+			...acc,
+			[widgetKey]: Widgets.toStatic(widget, sharedSlices)
+		};
+	}, {});
+} };
+function traverseSection(args) {
+	const { path: prevPath, section: prevSection, onField } = args;
+	let section;
+	for (const [key, prevModel] of Object.entries(prevSection)) {
+		const path = [...prevPath, key];
+		let model;
+		switch (prevModel.type) {
+			case "Choice":
+			case "Slices":
+				model = traverseSlices({
+					path,
+					slices: prevModel,
+					onField
+				});
+				break;
+			case "Group":
+				model = onField({
+					path,
+					key,
+					field: traverseGroup({
+						path,
+						group: prevModel,
+						onField
+					})
+				});
+				break;
+			default:
+				model = onField({
+					path,
+					key,
+					field: prevModel
+				});
+				break;
+		}
+		if (model !== prevModel) {
+			if (!section) section = { ...prevSection };
+			section[key] = model;
+		}
+	}
+	return section ?? prevSection;
+}
+
+//#endregion
+export { DynamicSection, Sections, StaticSection, sectionReader, traverseSection };
+//# sourceMappingURL=Section.js.map

package/dist/customtypes/Section.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Section.js","names":[],"sources":["../../src/customtypes/Section.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { WidgetKey } from \"../common\"\nimport type { Fields } from \"../utils\"\nimport type { Group, NestableWidget, NestedGroup, UID } from \"./widgets\";\nimport { traverseGroup, traverseSlices } from \"./widgets\"\nimport type { SharedSlice } from \"./widgets/slices\"\nimport { DynamicWidget, StaticWidget, Widgets } from \"./widgets/Widget\"\n\nexport function sectionReader<T extends StaticWidget | DynamicWidget>(codec: t.Type<T, unknown>) {\n\treturn t.record(WidgetKey, codec) // WidgetId -> Widget Data\n}\n\nexport const StaticSection = sectionReader(StaticWidget)\nexport type StaticSection = t.TypeOf<typeof StaticSection>\n\nexport const DynamicSection = sectionReader(DynamicWidget)\nexport type DynamicSection = t.TypeOf<typeof DynamicSection>\n\nexport const Sections = {\n\ttoStatic(dynamic: DynamicSection, sharedSlices: Map<string, SharedSlice>): StaticSection {\n\t\tconst section = Object.entries(dynamic).reduce(\n\t\t\t(acc: { [key: string]: StaticWidget }, [widgetKey, widget]: [string, DynamicWidget]) => {\n\t\t\t\treturn { ...acc, [widgetKey]: Widgets.toStatic(widget, sharedSlices) }\n\t\t\t},\n\t\t\t{},\n\t\t)\n\t\treturn section as StaticSection\n\t},\n}\n\nexport function traverseSection<T extends DynamicSection | StaticSection>(args: {\n\tpath: ReadonlyArray<string>\n\tsection: T\n\tonField: Fields.OnFieldFn<UID | NestableWidget | Group | NestedGroup>\n}): T {\n\tconst { path: prevPath, section: prevSection, onField } = args\n\n\tlet section: T | undefined\n\tfor (const [key, prevModel] of Object.entries(prevSection)) {\n\t\tconst path = [...prevPath, key]\n\t\tlet model\n\t\tswitch (prevModel.type) {\n\t\t\tcase \"Choice\":\n\t\t\tcase \"Slices\":\n\t\t\t\tmodel = traverseSlices({\n\t\t\t\t\tpath,\n\t\t\t\t\tslices: prevModel,\n\t\t\t\t\tonField: onField as Fields.OnFieldFn<NestableWidget | Group | NestedGroup>,\n\t\t\t\t})\n\t\t\t\tbreak\n\t\t\tcase \"Group\":\n\t\t\t\tmodel = onField({\n\t\t\t\t\tpath,\n\t\t\t\t\tkey,\n\t\t\t\t\tfield: traverseGroup({\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tgroup: prevModel,\n\t\t\t\t\t\tonField: onField as Fields.OnFieldFn<NestableWidget | NestedGroup>,\n\t\t\t\t\t}),\n\t\t\t\t})\n\t\t\t\tbreak\n\t\t\tdefault:\n\t\t\t\tmodel = onField({\n\t\t\t\t\tpath,\n\t\t\t\t\tkey,\n\t\t\t\t\tfield: prevModel,\n\t\t\t\t})\n\t\t\t\tbreak\n\t\t}\n\n\t\tif (model !== prevModel) {\n\t\t\tif (!section) section = { ...prevSection }\n\t\t\tsection[key] = model\n\t\t}\n\t}\n\n\t// returns the traversed model instead of a new one if it didn't change\n\treturn section ?? prevSection\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,cAAsD,OAA2B;AAChG,QAAO,EAAE,OAAO,WAAW,MAAM;;AAGlC,MAAa,gBAAgB,cAAc,aAAa;AAGxD,MAAa,iBAAiB,cAAc,cAAc;AAG1D,MAAa,WAAW,EACvB,SAAS,SAAyB,cAAuD;AAOxF,QANgB,OAAO,QAAQ,QAAQ,CAAC,QACtC,KAAsC,CAAC,WAAW,YAAqC;AACvF,SAAO;GAAE,GAAG;IAAM,YAAY,QAAQ,SAAS,QAAQ,aAAa;GAAE;IAEvE,EAAE,CACF;GAGF;AAED,SAAgB,gBAA0D,MAIpE;CACL,MAAM,EAAE,MAAM,UAAU,SAAS,aAAa,YAAY;CAE1D,IAAI;AACJ,MAAK,MAAM,CAAC,KAAK,cAAc,OAAO,QAAQ,YAAY,EAAE;EAC3D,MAAM,OAAO,CAAC,GAAG,UAAU,IAAI;EAC/B,IAAI;AACJ,UAAQ,UAAU,MAAlB;GACC,KAAK;GACL,KAAK;AACJ,YAAQ,eAAe;KACtB;KACA,QAAQ;KACC;KACT,CAAC;AACF;GACD,KAAK;AACJ,YAAQ,QAAQ;KACf;KACA;KACA,OAAO,cAAc;MACpB;MACA,OAAO;MACE;MACT,CAAC;KACF,CAAC;AACF;GACD;AACC,YAAQ,QAAQ;KACf;KACA;KACA,OAAO;KACP,CAAC;AACF;;AAGF,MAAI,UAAU,WAAW;AACxB,OAAI,CAAC,QAAS,WAAU,EAAE,GAAG,aAAa;AAC1C,WAAQ,OAAO;;;AAKjB,QAAO,WAAW"}

package/dist/customtypes/diff/Changes.cjs

@@ -0,0 +1,12 @@
+
+//#region src/customtypes/diff/Changes.ts
+let DiffOperation = /* @__PURE__ */ function(DiffOperation) {
+	DiffOperation["Added"] = "added";
+	DiffOperation["Removed"] = "removed";
+	DiffOperation["Updated"] = "updated";
+	return DiffOperation;
+}({});
+
+//#endregion
+exports.DiffOperation = DiffOperation;
+//# sourceMappingURL=Changes.cjs.map

package/dist/customtypes/diff/Changes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Changes.cjs","names":[],"sources":["../../../src/customtypes/diff/Changes.ts"],"sourcesContent":["export enum DiffOperation {\n\tAdded = \"added\",\n\tRemoved = \"removed\",\n\tUpdated = \"updated\",\n}\n\nexport type AddChange<A> = {\n\top: DiffOperation.Added\n\tvalue: A\n}\n\nexport type RemovedChange = {\n\top: DiffOperation.Removed\n}\n\nexport type UpdatedChange<A> = {\n\top: DiffOperation.Updated\n\tvalue: A\n}\n\nexport type DiffChange<A, U> = AddChange<A> | UpdatedChange<U> | RemovedChange\n"],"mappings":";;AAAA,IAAY,wDAAL;AACN;AACA;AACA"}

package/dist/customtypes/diff/Changes.d.cts

@@ -0,0 +1,21 @@
+//#region src/customtypes/diff/Changes.d.ts
+declare enum DiffOperation {
+  Added = "added",
+  Removed = "removed",
+  Updated = "updated"
+}
+type AddChange<A> = {
+  op: DiffOperation.Added;
+  value: A;
+};
+type RemovedChange = {
+  op: DiffOperation.Removed;
+};
+type UpdatedChange<A> = {
+  op: DiffOperation.Updated;
+  value: A;
+};
+type DiffChange<A, U> = AddChange<A> | UpdatedChange<U> | RemovedChange;
+//#endregion
+export { AddChange, DiffChange, DiffOperation, RemovedChange, UpdatedChange };
+//# sourceMappingURL=Changes.d.cts.map

package/dist/customtypes/diff/Changes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Changes.d.cts","names":[],"sources":["../../../src/customtypes/diff/Changes.ts"],"mappings":";aAAY,aAAA;EACX,KAAA;EACA,OAAA;EACA,OAAA;AAAA;AAAA,KAGW,SAAA;EACX,EAAA,EAAI,aAAA,CAAc,KAAA;EAClB,KAAA,EAAO,CAAA;AAAA;AAAA,KAGI,aAAA;EACX,EAAA,EAAI,aAAA,CAAc,OAAA;AAAA;AAAA,KAGP,aAAA;EACX,EAAA,EAAI,aAAA,CAAc,OAAA;EAClB,KAAA,EAAO,CAAA;AAAA;AAAA,KAGI,UAAA,SAAmB,SAAA,CAAU,CAAA,IAAK,aAAA,CAAc,CAAA,IAAK,aAAA"}

package/dist/customtypes/diff/Changes.d.ts

@@ -0,0 +1,21 @@
+//#region src/customtypes/diff/Changes.d.ts
+declare enum DiffOperation {
+  Added = "added",
+  Removed = "removed",
+  Updated = "updated"
+}
+type AddChange<A> = {
+  op: DiffOperation.Added;
+  value: A;
+};
+type RemovedChange = {
+  op: DiffOperation.Removed;
+};
+type UpdatedChange<A> = {
+  op: DiffOperation.Updated;
+  value: A;
+};
+type DiffChange<A, U> = AddChange<A> | UpdatedChange<U> | RemovedChange;
+//#endregion
+export { AddChange, DiffChange, DiffOperation, RemovedChange, UpdatedChange };
+//# sourceMappingURL=Changes.d.ts.map

package/dist/customtypes/diff/Changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Changes.d.ts","names":[],"sources":["../../../src/customtypes/diff/Changes.ts"],"mappings":";aAAY,aAAA;EACX,KAAA;EACA,OAAA;EACA,OAAA;AAAA;AAAA,KAGW,SAAA;EACX,EAAA,EAAI,aAAA,CAAc,KAAA;EAClB,KAAA,EAAO,CAAA;AAAA;AAAA,KAGI,aAAA;EACX,EAAA,EAAI,aAAA,CAAc,OAAA;AAAA;AAAA,KAGP,aAAA;EACX,EAAA,EAAI,aAAA,CAAc,OAAA;EAClB,KAAA,EAAO,CAAA;AAAA;AAAA,KAGI,UAAA,SAAmB,SAAA,CAAU,CAAA,IAAK,aAAA,CAAc,CAAA,IAAK,aAAA"}

package/dist/customtypes/diff/Changes.js

@@ -0,0 +1,11 @@
+//#region src/customtypes/diff/Changes.ts
+let DiffOperation = /* @__PURE__ */ function(DiffOperation) {
+	DiffOperation["Added"] = "added";
+	DiffOperation["Removed"] = "removed";
+	DiffOperation["Updated"] = "updated";
+	return DiffOperation;
+}({});
+
+//#endregion
+export { DiffOperation };
+//# sourceMappingURL=Changes.js.map

package/dist/customtypes/diff/Changes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Changes.js","names":[],"sources":["../../../src/customtypes/diff/Changes.ts"],"sourcesContent":["export enum DiffOperation {\n\tAdded = \"added\",\n\tRemoved = \"removed\",\n\tUpdated = \"updated\",\n}\n\nexport type AddChange<A> = {\n\top: DiffOperation.Added\n\tvalue: A\n}\n\nexport type RemovedChange = {\n\top: DiffOperation.Removed\n}\n\nexport type UpdatedChange<A> = {\n\top: DiffOperation.Updated\n\tvalue: A\n}\n\nexport type DiffChange<A, U> = AddChange<A> | UpdatedChange<U> | RemovedChange\n"],"mappings":";AAAA,IAAY,wDAAL;AACN;AACA;AACA"}

package/dist/customtypes/diff/SharedSlice.cjs

@@ -0,0 +1,48 @@
+const require_Changes = require('./Changes.cjs');
+const require_Arrays = require('../../utils/Arrays.cjs');
+const require_Objects = require('../../utils/Objects.cjs');
+require('../../utils/index.cjs');
+const require_Variation = require('./Variation.cjs');
+
+//#region src/customtypes/diff/SharedSlice.ts
+function compareSliceMeta(sliceA, sliceB) {
+	const zippedSlices = require_Objects.zipObjects(sliceA, sliceB);
+	return Object.entries(zippedSlices).reduce((acc, [key, value]) => {
+		if (key === `variations`) return acc;
+		if (value?.left === value?.right) return acc;
+		return {
+			...acc,
+			[key]: value?.right
+		};
+	}, {});
+}
+const SliceComparator = { compare(sliceA, sliceB) {
+	if (!sliceA && sliceB) return {
+		op: require_Changes.DiffOperation.Added,
+		value: sliceB
+	};
+	if (sliceA && !sliceB) return { op: require_Changes.DiffOperation.Removed };
+	const diffMeta = compareSliceMeta(sliceA, sliceB);
+	const zippedSlices = require_Objects.zipObjects(sliceA && require_Arrays.toRecord(sliceA.variations, (v) => v.id), sliceB && require_Arrays.toRecord(sliceB.variations, (v) => v.id));
+	const diffVariations = Object.entries(zippedSlices).reduce((acc, [variationId, value]) => {
+		if (!value) return acc;
+		const vDiff = require_Variation.VariationComparator.compare(value.left, value.right);
+		if (!vDiff) return acc;
+		return {
+			...acc,
+			[variationId]: vDiff
+		};
+	}, {});
+	const diffSlice = {
+		...diffMeta,
+		...require_Objects.isNotEmpty(diffVariations) ? { variations: diffVariations } : {}
+	};
+	if (require_Objects.isNotEmpty(diffSlice)) return {
+		op: require_Changes.DiffOperation.Updated,
+		value: diffSlice
+	};
+} };
+
+//#endregion
+exports.SliceComparator = SliceComparator;
+//# sourceMappingURL=SharedSlice.cjs.map

package/dist/customtypes/diff/SharedSlice.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedSlice.cjs","names":["DiffOperation","VariationComparator"],"sources":["../../../src/customtypes/diff/SharedSlice.ts"],"sourcesContent":["import { Arrays, Objects } from \"../../utils\"\nimport type { SharedSlice, Variation } from \"../widgets/slices\"\nimport { type DiffChange, DiffOperation } from \"./Changes\"\nimport type { VariationDiff } from \"./Variation\";\nimport { VariationComparator } from \"./Variation\"\n\nexport type SliceMetadata = Omit<SharedSlice, \"variations\">\nexport type SliceDiff = DiffChange<\n\tSharedSlice,\n\tPartial<\n\t\tSliceMetadata & {\n\t\t\tvariations?: Partial<Record<string, VariationDiff>>\n\t\t}\n\t>\n>\n\nfunction compareSliceMeta(sliceA?: SharedSlice, sliceB?: SharedSlice): Partial<SliceMetadata> {\n\tconst zippedSlices = Objects.zipObjects(sliceA, sliceB)\n\n\treturn Object.entries(zippedSlices).reduce((acc, [key, value]) => {\n\t\tif (key === `variations`) return acc\n\n\t\tif (value?.left === value?.right) return acc\n\t\treturn { ...acc, [key]: value?.right }\n\t}, {})\n}\n\nexport const SliceComparator = {\n\tcompare(sliceA?: SharedSlice, sliceB?: SharedSlice): SliceDiff | undefined {\n\t\tif (!sliceA && sliceB)\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Added,\n\t\t\t\tvalue: sliceB,\n\t\t\t}\n\t\tif (sliceA && !sliceB)\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Removed,\n\t\t\t}\n\n\t\tconst diffMeta = compareSliceMeta(sliceA, sliceB)\n\n\t\tconst zippedSlices = Objects.zipObjects<Variation>(\n\t\t\tsliceA && Arrays.toRecord(sliceA.variations, (v) => v.id),\n\t\t\tsliceB && Arrays.toRecord(sliceB.variations, (v) => v.id),\n\t\t)\n\n\t\tconst diffVariations = Object.entries(zippedSlices).reduce<\n\t\t\tPartial<Record<string, VariationDiff>>\n\t\t>((acc, [variationId, value]) => {\n\t\t\tif (!value) return acc\n\n\t\t\tconst vDiff = VariationComparator.compare(value.left, value.right)\n\t\t\tif (!vDiff) return acc\n\t\t\treturn {\n\t\t\t\t...acc,\n\t\t\t\t[variationId]: vDiff,\n\t\t\t}\n\t\t}, {})\n\n\t\tconst diffSlice = {\n\t\t\t...diffMeta,\n\t\t\t...(Objects.isNotEmpty(diffVariations) ? { variations: diffVariations } : {}),\n\t\t}\n\n\t\tif (Objects.isNotEmpty(diffSlice)) {\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Updated,\n\t\t\t\tvalue: diffSlice,\n\t\t\t}\n\t\t}\n\t\treturn undefined\n\t},\n}\n"],"mappings":";;;;;;;AAgBA,SAAS,iBAAiB,QAAsB,QAA8C;CAC7F,MAAM,0CAAkC,QAAQ,OAAO;AAEvD,QAAO,OAAO,QAAQ,aAAa,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;AACjE,MAAI,QAAQ,aAAc,QAAO;AAEjC,MAAI,OAAO,SAAS,OAAO,MAAO,QAAO;AACzC,SAAO;GAAE,GAAG;IAAM,MAAM,OAAO;GAAO;IACpC,EAAE,CAAC;;AAGP,MAAa,kBAAkB,EAC9B,QAAQ,QAAsB,QAA6C;AAC1E,KAAI,CAAC,UAAU,OACd,QAAO;EACN,IAAIA,8BAAc;EAClB,OAAO;EACP;AACF,KAAI,UAAU,CAAC,OACd,QAAO,EACN,IAAIA,8BAAc,SAClB;CAEF,MAAM,WAAW,iBAAiB,QAAQ,OAAO;CAEjD,MAAM,0CACL,kCAA0B,OAAO,aAAa,MAAM,EAAE,GAAG,EACzD,kCAA0B,OAAO,aAAa,MAAM,EAAE,GAAG,CACzD;CAED,MAAM,iBAAiB,OAAO,QAAQ,aAAa,CAAC,QAEjD,KAAK,CAAC,aAAa,WAAW;AAChC,MAAI,CAAC,MAAO,QAAO;EAEnB,MAAM,QAAQC,sCAAoB,QAAQ,MAAM,MAAM,MAAM,MAAM;AAClE,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO;GACN,GAAG;IACF,cAAc;GACf;IACC,EAAE,CAAC;CAEN,MAAM,YAAY;EACjB,GAAG;EACH,8BAAuB,eAAe,GAAG,EAAE,YAAY,gBAAgB,GAAG,EAAE;EAC5E;AAED,gCAAuB,UAAU,CAChC,QAAO;EACN,IAAID,8BAAc;EAClB,OAAO;EACP;GAIH"}

package/dist/customtypes/diff/SharedSlice.d.cts

@@ -0,0 +1,15 @@
+import { SharedSlice } from "../widgets/slices/SharedSlice.cjs";
+import { DiffChange } from "./Changes.cjs";
+import { VariationDiff } from "./Variation.cjs";
+
+//#region src/customtypes/diff/SharedSlice.d.ts
+type SliceMetadata = Omit<SharedSlice, "variations">;
+type SliceDiff = DiffChange<SharedSlice, Partial<SliceMetadata & {
+  variations?: Partial<Record<string, VariationDiff>>;
+}>>;
+declare const SliceComparator: {
+  compare(sliceA?: SharedSlice, sliceB?: SharedSlice): SliceDiff | undefined;
+};
+//#endregion
+export { SliceComparator, SliceDiff, SliceMetadata };
+//# sourceMappingURL=SharedSlice.d.cts.map

package/dist/customtypes/diff/SharedSlice.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedSlice.d.cts","names":[],"sources":["../../../src/customtypes/diff/SharedSlice.ts"],"mappings":";;;;;KAMY,aAAA,GAAgB,IAAA,CAAK,WAAA;AAAA,KACrB,SAAA,GAAY,UAAA,CACvB,WAAA,EACA,OAAA,CACC,aAAA;EACC,UAAA,GAAa,OAAA,CAAQ,MAAA,SAAe,aAAA;AAAA;AAAA,cAgB1B,eAAA;mBACK,WAAA,EAAW,MAAA,GAAW,WAAA,GAAc,SAAA;AAAA"}

package/dist/customtypes/diff/SharedSlice.d.ts

@@ -0,0 +1,16 @@
+import { SharedSlice } from "../widgets/slices/SharedSlice.js";
+import "../widgets/slices/index.js";
+import { DiffChange } from "./Changes.js";
+import { VariationDiff } from "./Variation.js";
+
+//#region src/customtypes/diff/SharedSlice.d.ts
+type SliceMetadata = Omit<SharedSlice, "variations">;
+type SliceDiff = DiffChange<SharedSlice, Partial<SliceMetadata & {
+  variations?: Partial<Record<string, VariationDiff>>;
+}>>;
+declare const SliceComparator: {
+  compare(sliceA?: SharedSlice, sliceB?: SharedSlice): SliceDiff | undefined;
+};
+//#endregion
+export { SliceComparator, SliceDiff, SliceMetadata };
+//# sourceMappingURL=SharedSlice.d.ts.map

package/dist/customtypes/diff/SharedSlice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedSlice.d.ts","names":[],"sources":["../../../src/customtypes/diff/SharedSlice.ts"],"mappings":";;;;;;KAMY,aAAA,GAAgB,IAAA,CAAK,WAAA;AAAA,KACrB,SAAA,GAAY,UAAA,CACvB,WAAA,EACA,OAAA,CACC,aAAA;EACC,UAAA,GAAa,OAAA,CAAQ,MAAA,SAAe,aAAA;AAAA;AAAA,cAgB1B,eAAA;mBACK,WAAA,EAAW,MAAA,GAAW,WAAA,GAAc,SAAA;AAAA"}

package/dist/customtypes/diff/SharedSlice.js

@@ -0,0 +1,48 @@
+import { DiffOperation } from "./Changes.js";
+import { toRecord } from "../../utils/Arrays.js";
+import { isNotEmpty, zipObjects } from "../../utils/Objects.js";
+import "../../utils/index.js";
+import { VariationComparator } from "./Variation.js";
+
+//#region src/customtypes/diff/SharedSlice.ts
+function compareSliceMeta(sliceA, sliceB) {
+	const zippedSlices = zipObjects(sliceA, sliceB);
+	return Object.entries(zippedSlices).reduce((acc, [key, value]) => {
+		if (key === `variations`) return acc;
+		if (value?.left === value?.right) return acc;
+		return {
+			...acc,
+			[key]: value?.right
+		};
+	}, {});
+}
+const SliceComparator = { compare(sliceA, sliceB) {
+	if (!sliceA && sliceB) return {
+		op: DiffOperation.Added,
+		value: sliceB
+	};
+	if (sliceA && !sliceB) return { op: DiffOperation.Removed };
+	const diffMeta = compareSliceMeta(sliceA, sliceB);
+	const zippedSlices = zipObjects(sliceA && toRecord(sliceA.variations, (v) => v.id), sliceB && toRecord(sliceB.variations, (v) => v.id));
+	const diffVariations = Object.entries(zippedSlices).reduce((acc, [variationId, value]) => {
+		if (!value) return acc;
+		const vDiff = VariationComparator.compare(value.left, value.right);
+		if (!vDiff) return acc;
+		return {
+			...acc,
+			[variationId]: vDiff
+		};
+	}, {});
+	const diffSlice = {
+		...diffMeta,
+		...isNotEmpty(diffVariations) ? { variations: diffVariations } : {}
+	};
+	if (isNotEmpty(diffSlice)) return {
+		op: DiffOperation.Updated,
+		value: diffSlice
+	};
+} };
+
+//#endregion
+export { SliceComparator };
+//# sourceMappingURL=SharedSlice.js.map

package/dist/customtypes/diff/SharedSlice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedSlice.js","names":["Objects.zipObjects","Arrays.toRecord","Objects.isNotEmpty"],"sources":["../../../src/customtypes/diff/SharedSlice.ts"],"sourcesContent":["import { Arrays, Objects } from \"../../utils\"\nimport type { SharedSlice, Variation } from \"../widgets/slices\"\nimport { type DiffChange, DiffOperation } from \"./Changes\"\nimport type { VariationDiff } from \"./Variation\";\nimport { VariationComparator } from \"./Variation\"\n\nexport type SliceMetadata = Omit<SharedSlice, \"variations\">\nexport type SliceDiff = DiffChange<\n\tSharedSlice,\n\tPartial<\n\t\tSliceMetadata & {\n\t\t\tvariations?: Partial<Record<string, VariationDiff>>\n\t\t}\n\t>\n>\n\nfunction compareSliceMeta(sliceA?: SharedSlice, sliceB?: SharedSlice): Partial<SliceMetadata> {\n\tconst zippedSlices = Objects.zipObjects(sliceA, sliceB)\n\n\treturn Object.entries(zippedSlices).reduce((acc, [key, value]) => {\n\t\tif (key === `variations`) return acc\n\n\t\tif (value?.left === value?.right) return acc\n\t\treturn { ...acc, [key]: value?.right }\n\t}, {})\n}\n\nexport const SliceComparator = {\n\tcompare(sliceA?: SharedSlice, sliceB?: SharedSlice): SliceDiff | undefined {\n\t\tif (!sliceA && sliceB)\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Added,\n\t\t\t\tvalue: sliceB,\n\t\t\t}\n\t\tif (sliceA && !sliceB)\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Removed,\n\t\t\t}\n\n\t\tconst diffMeta = compareSliceMeta(sliceA, sliceB)\n\n\t\tconst zippedSlices = Objects.zipObjects<Variation>(\n\t\t\tsliceA && Arrays.toRecord(sliceA.variations, (v) => v.id),\n\t\t\tsliceB && Arrays.toRecord(sliceB.variations, (v) => v.id),\n\t\t)\n\n\t\tconst diffVariations = Object.entries(zippedSlices).reduce<\n\t\t\tPartial<Record<string, VariationDiff>>\n\t\t>((acc, [variationId, value]) => {\n\t\t\tif (!value) return acc\n\n\t\t\tconst vDiff = VariationComparator.compare(value.left, value.right)\n\t\t\tif (!vDiff) return acc\n\t\t\treturn {\n\t\t\t\t...acc,\n\t\t\t\t[variationId]: vDiff,\n\t\t\t}\n\t\t}, {})\n\n\t\tconst diffSlice = {\n\t\t\t...diffMeta,\n\t\t\t...(Objects.isNotEmpty(diffVariations) ? { variations: diffVariations } : {}),\n\t\t}\n\n\t\tif (Objects.isNotEmpty(diffSlice)) {\n\t\t\treturn {\n\t\t\t\top: DiffOperation.Updated,\n\t\t\t\tvalue: diffSlice,\n\t\t\t}\n\t\t}\n\t\treturn undefined\n\t},\n}\n"],"mappings":";;;;;;;AAgBA,SAAS,iBAAiB,QAAsB,QAA8C;CAC7F,MAAM,eAAeA,WAAmB,QAAQ,OAAO;AAEvD,QAAO,OAAO,QAAQ,aAAa,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;AACjE,MAAI,QAAQ,aAAc,QAAO;AAEjC,MAAI,OAAO,SAAS,OAAO,MAAO,QAAO;AACzC,SAAO;GAAE,GAAG;IAAM,MAAM,OAAO;GAAO;IACpC,EAAE,CAAC;;AAGP,MAAa,kBAAkB,EAC9B,QAAQ,QAAsB,QAA6C;AAC1E,KAAI,CAAC,UAAU,OACd,QAAO;EACN,IAAI,cAAc;EAClB,OAAO;EACP;AACF,KAAI,UAAU,CAAC,OACd,QAAO,EACN,IAAI,cAAc,SAClB;CAEF,MAAM,WAAW,iBAAiB,QAAQ,OAAO;CAEjD,MAAM,eAAeA,WACpB,UAAUC,SAAgB,OAAO,aAAa,MAAM,EAAE,GAAG,EACzD,UAAUA,SAAgB,OAAO,aAAa,MAAM,EAAE,GAAG,CACzD;CAED,MAAM,iBAAiB,OAAO,QAAQ,aAAa,CAAC,QAEjD,KAAK,CAAC,aAAa,WAAW;AAChC,MAAI,CAAC,MAAO,QAAO;EAEnB,MAAM,QAAQ,oBAAoB,QAAQ,MAAM,MAAM,MAAM,MAAM;AAClE,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO;GACN,GAAG;IACF,cAAc;GACf;IACC,EAAE,CAAC;CAEN,MAAM,YAAY;EACjB,GAAG;EACH,GAAIC,WAAmB,eAAe,GAAG,EAAE,YAAY,gBAAgB,GAAG,EAAE;EAC5E;AAED,KAAIA,WAAmB,UAAU,CAChC,QAAO;EACN,IAAI,cAAc;EAClB,OAAO;EACP;GAIH"}

package/dist/customtypes/diff/Variation.cjs

@@ -0,0 +1,94 @@
+const require_Group = require('../widgets/Group.cjs');
+const require_Changes = require('./Changes.cjs');
+const require_Objects = require('../../utils/Objects.cjs');
+require('../../utils/index.cjs');
+
+//#region src/customtypes/diff/Variation.ts
+function compareVariationMeta(variationA, variationB) {
+	const zippedVariations = require_Objects.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 = require_Objects.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: require_Changes.DiffOperation.Removed };
+			if (!widgetValue?.left && widgetValue?.right) {
+				if (widgetValue.right?.type === require_Group.GroupFieldType) {
+					const group = {
+						...widgetValue.right,
+						config: {
+							...widgetValue.right.config,
+							fields: {}
+						}
+					};
+					group.config.fields = compareWidgets(void 0, widgetValue.right.config?.fields) || {};
+					return {
+						op: require_Changes.DiffOperation.Added,
+						value: group
+					};
+				}
+				return {
+					op: require_Changes.DiffOperation.Added,
+					value: widgetValue.right
+				};
+			}
+			if (widgetValue.right?.type === require_Group.GroupFieldType) {
+				const group = {
+					...widgetValue.right,
+					config: {
+						...widgetValue.right.config,
+						fields: {}
+					}
+				};
+				group.config.fields = compareWidgets(widgetValue.left?.type === require_Group.GroupFieldType ? widgetValue.left?.config?.fields : void 0, widgetValue.right.config?.fields) || {};
+				return {
+					op: require_Changes.DiffOperation.Updated,
+					value: group
+				};
+			}
+			return {
+				op: require_Changes.DiffOperation.Updated,
+				value: widgetValue.right
+			};
+		})();
+		if (!changes) return acc;
+		return {
+			...acc,
+			[widgetKey]: changes
+		};
+	}, {});
+	return require_Objects.isNotEmpty(diffWidgets) ? diffWidgets : void 0;
+}
+const VariationComparator = { compare(variationA, variationB) {
+	if (variationA && !variationB) return { op: require_Changes.DiffOperation.Removed };
+	if (!variationA && variationB) return {
+		op: require_Changes.DiffOperation.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 (require_Objects.isNotEmpty(diffVariation)) return {
+		op: require_Changes.DiffOperation.Updated,
+		value: diffVariation
+	};
+} };
+
+//#endregion
+exports.VariationComparator = VariationComparator;
+//# sourceMappingURL=Variation.cjs.map

package/dist/customtypes/diff/Variation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Variation.cjs","names":["DiffOperation","GroupFieldType"],"sources":["../../../src/customtypes/diff/Variation.ts"],"sourcesContent":["import { Objects } from \"../../utils\"\nimport type { Group} from \"../widgets/Group\";\nimport { GroupFieldType } from \"../widgets/Group\"\nimport type { NestableWidget } from \"../widgets/nestable\"\nimport type { SlicePrimaryWidget } from \"../widgets/slices\"\nimport type { Variation } from \"../widgets/slices\"\nimport { type DiffChange, DiffOperation } from \"./Changes\"\nimport type {\n\tGroupWidgetWithFieldsDiff,\n\tNestableWidgetDiff,\n\tSlicePrimaryWidgetDiff,\n} from \"./Widgets\"\n\nexport type VariationMetadata = Omit<Variation, \"primary\" | \"items\">\nexport type VariationDiff = DiffChange<\n\tVariation,\n\tPartial<VariationMetadata> & {\n\t\tprimary?: Record<string, SlicePrimaryWidgetDiff>\n\t\titems?: Record<string, NestableWidgetDiff>\n\t}\n>\n\nfunction compareVariationMeta(\n\tvariationA?: Variation,\n\tvariationB?: Variation,\n): Partial<VariationMetadata> {\n\tconst zippedVariations = Objects.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 NestableWidget | Group>(\n\twidgetsA?: { [key: string]: TWidget },\n\twidgetsB?: { [key: string]: TWidget },\n):\n\t| Record<string, SlicePrimaryWidget extends TWidget ? SlicePrimaryWidgetDiff : NestableWidgetDiff>\n\t| undefined {\n\tconst zippedWidgets = Objects.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 Objects.isNotEmpty(diffWidgets) ? diffWidgets : undefined\n}\n\nexport const VariationComparator = {\n\tcompare(variationA?: Variation, variationB?: Variation): 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 (Objects.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":";;;;;;AAsBA,SAAS,qBACR,YACA,YAC6B;CAC7B,MAAM,8CAAsC,YAAY,WAAW;AAEnE,QAAO,OAAO,QAAQ,iBAAiB,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;AACrE,MAAI,QAAQ,aAAa,QAAQ,QAAS,QAAO;AAEjD,MAAI,OAAO,SAAS,OAAO,MAAO,QAAO;AACzC,SAAO;GAAE,GAAG;IAAM,MAAM,OAAO;GAAO;IACpC,EAAE,CAAC;;AAGP,SAAS,eACR,UACA,UAGY;CACZ,MAAM,2CAAmC,UAAU,SAAS;CAE5D,MAAM,cAAc,OAAO,QAAQ,cAAc,CAAC,QAAQ,KAAK,CAAC,WAAW,iBAAiB;AAC3F,MAAI,KAAK,UAAU,aAAa,KAAK,KAAK,KAAK,UAAU,aAAa,MAAM,CAAE,QAAO;EAErF,MAAM,iBAAiB;AACtB,OAAI,CAAC,aAAa,QAAQ,CAAC,aAAa,MAAO;AAE/C,OAAI,aAAa,QAAQ,CAAC,YAAY,MACrC,QAAO,EACN,IAAIA,8BAAc,SAClB;AAGF,OAAI,CAAC,aAAa,QAAQ,aAAa,OAAO;AAC7C,QAAI,YAAY,OAAO,SAASC,8BAAgB;KAC/C,MAAM,QAAmC;MACxC,GAAG,YAAY;MACf,QAAQ;OACP,GAAG,YAAY,MAAM;OACrB,QAAQ,EAAE;OACV;MACD;AAED,WAAM,OAAO,SAAS,eAAe,QAAW,YAAY,MAAM,QAAQ,OAAO,IAAI,EAAE;AAEvF,YAAO;MACN,IAAID,8BAAc;MAClB,OAAO;MACP;;AAGF,WAAO;KACN,IAAIA,8BAAc;KAClB,OAAO,YAAY;KACnB;;AAGF,OAAI,YAAY,OAAO,SAASC,8BAAgB;IAC/C,MAAM,QAAmC;KACxC,GAAG,YAAY;KACf,QAAQ;MACP,GAAG,YAAY,MAAM;MACrB,QAAQ,EAAE;MACV;KACD;AAED,UAAM,OAAO,SACZ,eACC,YAAY,MAAM,SAASA,+BACxB,YAAY,MAAM,QAAQ,SAC1B,QACH,YAAY,MAAM,QAAQ,OAC1B,IAAI,EAAE;AAER,WAAO;KACN,IAAID,8BAAc;KAClB,OAAO;KACP;;AAGF,UAAO;IACN,IAAIA,8BAAc;IAClB,OAAO,YAAY;IACnB;MACE;AAEJ,MAAI,CAAC,QAAS,QAAO;AAErB,SAAO;GACN,GAAG;IACF,YAAY;GACb;IACC,EAAE,CAAC;AAEN,mCAA0B,YAAY,GAAG,cAAc;;AAGxD,MAAa,sBAAsB,EAClC,QAAQ,YAAwB,YAAmD;AAClF,KAAI,cAAc,CAAC,WAClB,QAAO,EACN,IAAIA,8BAAc,SAClB;AACF,KAAI,CAAC,cAAc,WAClB,QAAO;EACN,IAAIA,8BAAc;EAClB,OAAO;EACP;CAGF,MAAM,WAAW,qBAAqB,YAAY,WAAW;CAE7D,MAAM,cAAc,eAAe,YAAY,SAAS,YAAY,QAAQ;CAC5E,MAAM,YAAY,eAAe,YAAY,OAAO,YAAY,MAAM;CAEtE,MAAM,gBAAgB;EACrB,GAAG;EACH,GAAI,cAAc,EAAE,SAAS,aAAa,GAAG,EAAE;EAC/C,GAAI,YAAY,EAAE,OAAO,WAAW,GAAG,EAAE;EACzC;AAED,gCAAuB,cAAc,CACpC,QAAO;EACN,IAAIA,8BAAc;EAClB,OAAO;EACP;GAIH"}

package/dist/customtypes/diff/Variation.d.cts

@@ -0,0 +1,16 @@
+import { Variation } from "../widgets/slices/SharedSlice.cjs";
+import { DiffChange } from "./Changes.cjs";
+import { NestableWidgetDiff, SlicePrimaryWidgetDiff } from "./Widgets.cjs";
+
+//#region src/customtypes/diff/Variation.d.ts
+type VariationMetadata = Omit<Variation, "primary" | "items">;
+type VariationDiff = DiffChange<Variation, Partial<VariationMetadata> & {
+  primary?: Record<string, SlicePrimaryWidgetDiff>;
+  items?: Record<string, NestableWidgetDiff>;
+}>;
+declare const VariationComparator: {
+  compare(variationA?: Variation, variationB?: Variation): VariationDiff | undefined;
+};
+//#endregion
+export { VariationComparator, VariationDiff, VariationMetadata };
+//# sourceMappingURL=Variation.d.cts.map

package/dist/customtypes/diff/Variation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Variation.d.cts","names":[],"sources":["../../../src/customtypes/diff/Variation.ts"],"mappings":";;;;;KAaY,iBAAA,GAAoB,IAAA,CAAK,SAAA;AAAA,KACzB,aAAA,GAAgB,UAAA,CAC3B,SAAA,EACA,OAAA,CAAQ,iBAAA;EACP,OAAA,GAAU,MAAA,SAAe,sBAAA;EACzB,KAAA,GAAQ,MAAA,SAAe,kBAAA;AAAA;AAAA,cAsGZ,mBAAA;uBACS,SAAA,EAAS,UAAA,GAAe,SAAA,GAAY,aAAA;AAAA"}

package/dist/customtypes/diff/Variation.d.ts

@@ -0,0 +1,17 @@
+import { Variation } from "../widgets/slices/SharedSlice.js";
+import "../widgets/slices/index.js";
+import { DiffChange } from "./Changes.js";
+import { NestableWidgetDiff, SlicePrimaryWidgetDiff } from "./Widgets.js";
+
+//#region src/customtypes/diff/Variation.d.ts
+type VariationMetadata = Omit<Variation, "primary" | "items">;
+type VariationDiff = DiffChange<Variation, Partial<VariationMetadata> & {
+  primary?: Record<string, SlicePrimaryWidgetDiff>;
+  items?: Record<string, NestableWidgetDiff>;
+}>;
+declare const VariationComparator: {
+  compare(variationA?: Variation, variationB?: Variation): VariationDiff | undefined;
+};
+//#endregion
+export { VariationComparator, VariationDiff, VariationMetadata };
+//# sourceMappingURL=Variation.d.ts.map

package/dist/customtypes/diff/Variation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Variation.d.ts","names":[],"sources":["../../../src/customtypes/diff/Variation.ts"],"mappings":";;;;;;KAaY,iBAAA,GAAoB,IAAA,CAAK,SAAA;AAAA,KACzB,aAAA,GAAgB,UAAA,CAC3B,SAAA,EACA,OAAA,CAAQ,iBAAA;EACP,OAAA,GAAU,MAAA,SAAe,sBAAA;EACzB,KAAA,GAAQ,MAAA,SAAe,kBAAA;AAAA;AAAA,cAsGZ,mBAAA;uBACS,SAAA,EAAS,UAAA,GAAe,SAAA,GAAY,aAAA;AAAA"}

package/dist/customtypes/diff/Variation.js

@@ -0,0 +1,94 @@
+import { GroupFieldType } from "../widgets/Group.js";
+import { DiffOperation } from "./Changes.js";
+import { isNotEmpty, zipObjects } from "../../utils/Objects.js";
+import "../../utils/index.js";
+
+//#region src/customtypes/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: DiffOperation.Removed };
+			if (!widgetValue?.left && widgetValue?.right) {
+				if (widgetValue.right?.type === GroupFieldType) {
+					const group = {
+						...widgetValue.right,
+						config: {
+							...widgetValue.right.config,
+							fields: {}
+						}
+					};
+					group.config.fields = compareWidgets(void 0, widgetValue.right.config?.fields) || {};
+					return {
+						op: DiffOperation.Added,
+						value: group
+					};
+				}
+				return {
+					op: DiffOperation.Added,
+					value: widgetValue.right
+				};
+			}
+			if (widgetValue.right?.type === GroupFieldType) {
+				const group = {
+					...widgetValue.right,
+					config: {
+						...widgetValue.right.config,
+						fields: {}
+					}
+				};
+				group.config.fields = compareWidgets(widgetValue.left?.type === GroupFieldType ? widgetValue.left?.config?.fields : void 0, widgetValue.right.config?.fields) || {};
+				return {
+					op: DiffOperation.Updated,
+					value: group
+				};
+			}
+			return {
+				op: DiffOperation.Updated,
+				value: widgetValue.right
+			};
+		})();
+		if (!changes) return acc;
+		return {
+			...acc,
+			[widgetKey]: changes
+		};
+	}, {});
+	return isNotEmpty(diffWidgets) ? diffWidgets : void 0;
+}
+const VariationComparator = { compare(variationA, variationB) {
+	if (variationA && !variationB) return { op: DiffOperation.Removed };
+	if (!variationA && variationB) return {
+		op: DiffOperation.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: DiffOperation.Updated,
+		value: diffVariation
+	};
+} };
+
+//#endregion
+export { VariationComparator };
+//# sourceMappingURL=Variation.js.map

package/dist/customtypes/diff/Variation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Variation.js","names":["Objects.zipObjects","Objects.isNotEmpty"],"sources":["../../../src/customtypes/diff/Variation.ts"],"sourcesContent":["import { Objects } from \"../../utils\"\nimport type { Group} from \"../widgets/Group\";\nimport { GroupFieldType } from \"../widgets/Group\"\nimport type { NestableWidget } from \"../widgets/nestable\"\nimport type { SlicePrimaryWidget } from \"../widgets/slices\"\nimport type { Variation } from \"../widgets/slices\"\nimport { type DiffChange, DiffOperation } from \"./Changes\"\nimport type {\n\tGroupWidgetWithFieldsDiff,\n\tNestableWidgetDiff,\n\tSlicePrimaryWidgetDiff,\n} from \"./Widgets\"\n\nexport type VariationMetadata = Omit<Variation, \"primary\" | \"items\">\nexport type VariationDiff = DiffChange<\n\tVariation,\n\tPartial<VariationMetadata> & {\n\t\tprimary?: Record<string, SlicePrimaryWidgetDiff>\n\t\titems?: Record<string, NestableWidgetDiff>\n\t}\n>\n\nfunction compareVariationMeta(\n\tvariationA?: Variation,\n\tvariationB?: Variation,\n): Partial<VariationMetadata> {\n\tconst zippedVariations = Objects.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 NestableWidget | Group>(\n\twidgetsA?: { [key: string]: TWidget },\n\twidgetsB?: { [key: string]: TWidget },\n):\n\t| Record<string, SlicePrimaryWidget extends TWidget ? SlicePrimaryWidgetDiff : NestableWidgetDiff>\n\t| undefined {\n\tconst zippedWidgets = Objects.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 Objects.isNotEmpty(diffWidgets) ? diffWidgets : undefined\n}\n\nexport const VariationComparator = {\n\tcompare(variationA?: Variation, variationB?: Variation): 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 (Objects.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":";;;;;;AAsBA,SAAS,qBACR,YACA,YAC6B;CAC7B,MAAM,mBAAmBA,WAAmB,YAAY,WAAW;AAEnE,QAAO,OAAO,QAAQ,iBAAiB,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;AACrE,MAAI,QAAQ,aAAa,QAAQ,QAAS,QAAO;AAEjD,MAAI,OAAO,SAAS,OAAO,MAAO,QAAO;AACzC,SAAO;GAAE,GAAG;IAAM,MAAM,OAAO;GAAO;IACpC,EAAE,CAAC;;AAGP,SAAS,eACR,UACA,UAGY;CACZ,MAAM,gBAAgBA,WAAmB,UAAU,SAAS;CAE5D,MAAM,cAAc,OAAO,QAAQ,cAAc,CAAC,QAAQ,KAAK,CAAC,WAAW,iBAAiB;AAC3F,MAAI,KAAK,UAAU,aAAa,KAAK,KAAK,KAAK,UAAU,aAAa,MAAM,CAAE,QAAO;EAErF,MAAM,iBAAiB;AACtB,OAAI,CAAC,aAAa,QAAQ,CAAC,aAAa,MAAO;AAE/C,OAAI,aAAa,QAAQ,CAAC,YAAY,MACrC,QAAO,EACN,IAAI,cAAc,SAClB;AAGF,OAAI,CAAC,aAAa,QAAQ,aAAa,OAAO;AAC7C,QAAI,YAAY,OAAO,SAAS,gBAAgB;KAC/C,MAAM,QAAmC;MACxC,GAAG,YAAY;MACf,QAAQ;OACP,GAAG,YAAY,MAAM;OACrB,QAAQ,EAAE;OACV;MACD;AAED,WAAM,OAAO,SAAS,eAAe,QAAW,YAAY,MAAM,QAAQ,OAAO,IAAI,EAAE;AAEvF,YAAO;MACN,IAAI,cAAc;MAClB,OAAO;MACP;;AAGF,WAAO;KACN,IAAI,cAAc;KAClB,OAAO,YAAY;KACnB;;AAGF,OAAI,YAAY,OAAO,SAAS,gBAAgB;IAC/C,MAAM,QAAmC;KACxC,GAAG,YAAY;KACf,QAAQ;MACP,GAAG,YAAY,MAAM;MACrB,QAAQ,EAAE;MACV;KACD;AAED,UAAM,OAAO,SACZ,eACC,YAAY,MAAM,SAAS,iBACxB,YAAY,MAAM,QAAQ,SAC1B,QACH,YAAY,MAAM,QAAQ,OAC1B,IAAI,EAAE;AAER,WAAO;KACN,IAAI,cAAc;KAClB,OAAO;KACP;;AAGF,UAAO;IACN,IAAI,cAAc;IAClB,OAAO,YAAY;IACnB;MACE;AAEJ,MAAI,CAAC,QAAS,QAAO;AAErB,SAAO;GACN,GAAG;IACF,YAAY;GACb;IACC,EAAE,CAAC;AAEN,QAAOC,WAAmB,YAAY,GAAG,cAAc;;AAGxD,MAAa,sBAAsB,EAClC,QAAQ,YAAwB,YAAmD;AAClF,KAAI,cAAc,CAAC,WAClB,QAAO,EACN,IAAI,cAAc,SAClB;AACF,KAAI,CAAC,cAAc,WAClB,QAAO;EACN,IAAI,cAAc;EAClB,OAAO;EACP;CAGF,MAAM,WAAW,qBAAqB,YAAY,WAAW;CAE7D,MAAM,cAAc,eAAe,YAAY,SAAS,YAAY,QAAQ;CAC5E,MAAM,YAAY,eAAe,YAAY,OAAO,YAAY,MAAM;CAEtE,MAAM,gBAAgB;EACrB,GAAG;EACH,GAAI,cAAc,EAAE,SAAS,aAAa,GAAG,EAAE;EAC/C,GAAI,YAAY,EAAE,OAAO,WAAW,GAAG,EAAE;EACzC;AAED,KAAIA,WAAmB,cAAc,CACpC,QAAO;EACN,IAAI,cAAc;EAClB,OAAO;EACP;GAIH"}

package/dist/customtypes/diff/Widgets.d.cts

@@ -0,0 +1,16 @@
+import { NestableWidget } from "../widgets/nestable/NestableWidget.cjs";
+import { Group } from "../widgets/Group.cjs";
+import { DiffChange } from "./Changes.cjs";
+
+//#region src/customtypes/diff/Widgets.d.ts
+type NestableWidgetDiff = DiffChange<NestableWidget, NestableWidget>;
+type GroupWidgetWithFieldsDiff = Omit<Group, "config"> & {
+  config: Omit<Group["config"], "fields"> & {
+    fields?: Record<string, GroupWidgetDiff | NestableWidgetDiff>;
+  };
+};
+type GroupWidgetDiff = DiffChange<GroupWidgetWithFieldsDiff, GroupWidgetWithFieldsDiff>;
+type SlicePrimaryWidgetDiff = NestableWidgetDiff | GroupWidgetDiff;
+//#endregion
+export { GroupWidgetDiff, GroupWidgetWithFieldsDiff, NestableWidgetDiff, SlicePrimaryWidgetDiff };
+//# sourceMappingURL=Widgets.d.cts.map

package/dist/customtypes/diff/Widgets.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Widgets.d.cts","names":[],"sources":["../../../src/customtypes/diff/Widgets.ts"],"mappings":";;;;;KAIY,kBAAA,GAAqB,UAAA,CAAW,cAAA,EAAgB,cAAA;AAAA,KAEhD,yBAAA,GAA4B,IAAA,CAAK,KAAA;EAC5C,MAAA,EAAQ,IAAA,CAAK,KAAA;IACZ,MAAA,GAAS,MAAA,SAAe,eAAA,GAAkB,kBAAA;EAAA;AAAA;AAAA,KAGhC,eAAA,GAAkB,UAAA,CAAW,yBAAA,EAA2B,yBAAA;AAAA,KAExD,sBAAA,GAAyB,kBAAA,GAAqB,eAAA"}

package/dist/customtypes/diff/Widgets.d.ts

@@ -0,0 +1,18 @@
+import { NestableWidget } from "../widgets/nestable/NestableWidget.js";
+import { Group } from "../widgets/Group.js";
+import "../widgets/nestable/index.js";
+import "../widgets/index.js";
+import { DiffChange } from "./Changes.js";
+
+//#region src/customtypes/diff/Widgets.d.ts
+type NestableWidgetDiff = DiffChange<NestableWidget, NestableWidget>;
+type GroupWidgetWithFieldsDiff = Omit<Group, "config"> & {
+  config: Omit<Group["config"], "fields"> & {
+    fields?: Record<string, GroupWidgetDiff | NestableWidgetDiff>;
+  };
+};
+type GroupWidgetDiff = DiffChange<GroupWidgetWithFieldsDiff, GroupWidgetWithFieldsDiff>;
+type SlicePrimaryWidgetDiff = NestableWidgetDiff | GroupWidgetDiff;
+//#endregion
+export { GroupWidgetDiff, GroupWidgetWithFieldsDiff, NestableWidgetDiff, SlicePrimaryWidgetDiff };
+//# sourceMappingURL=Widgets.d.ts.map