@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

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

@@ -1 +0,0 @@
-{"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

@@ -1,67 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,21 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,21 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,11 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_customtypes_diff_Changes = require('./Changes.cjs');
-const require_utils_Arrays = require('../../utils/Arrays.cjs');
-const require_utils_Objects = require('../../utils/Objects.cjs');
-require('../../utils/index.cjs');
-const require_customtypes_diff_Variation = require('./Variation.cjs');
-
-//#region src/customtypes/diff/SharedSlice.ts
-function compareSliceMeta(sliceA, sliceB) {
-	const zippedSlices = require_utils_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_customtypes_diff_Changes.DiffOperation.Added,
-		value: sliceB
-	};
-	if (sliceA && !sliceB) return { op: require_customtypes_diff_Changes.DiffOperation.Removed };
-	const diffMeta = compareSliceMeta(sliceA, sliceB);
-	const zippedSlices = require_utils_Objects.zipObjects(sliceA && require_utils_Arrays.toRecord(sliceA.variations, (v) => v.id), sliceB && require_utils_Arrays.toRecord(sliceB.variations, (v) => v.id));
-	const diffVariations = Object.entries(zippedSlices).reduce((acc, [variationId, value]) => {
-		if (!value) return acc;
-		const vDiff = require_customtypes_diff_Variation.VariationComparator.compare(value.left, value.right);
-		if (!vDiff) return acc;
-		return {
-			...acc,
-			[variationId]: vDiff
-		};
-	}, {});
-	const diffSlice = {
-		...diffMeta,
-		...require_utils_Objects.isNotEmpty(diffVariations) ? { variations: diffVariations } : {}
-	};
-	if (require_utils_Objects.isNotEmpty(diffSlice)) return {
-		op: require_customtypes_diff_Changes.DiffOperation.Updated,
-		value: diffSlice
-	};
-} };
-
-//#endregion
-exports.SliceComparator = SliceComparator;
-//# sourceMappingURL=SharedSlice.cjs.map

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

@@ -1 +0,0 @@
-{"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,gDAAkC,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,+CAAc;EAClB,OAAO;EACP;AACF,KAAI,UAAU,CAAC,OACd,QAAO,EACN,IAAIA,+CAAc,SAClB;CAEF,MAAM,WAAW,iBAAiB,QAAQ,OAAO;CAEjD,MAAM,gDACL,wCAA0B,OAAO,aAAa,MAAM,EAAE,GAAG,EACzD,wCAA0B,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,uDAAoB,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,oCAAuB,eAAe,GAAG,EAAE,YAAY,gBAAgB,GAAG,EAAE;EAC5E;AAED,sCAAuB,UAAU,CAChC,QAAO;EACN,IAAID,+CAAc;EAClB,OAAO;EACP;GAIH"}

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

@@ -1,15 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,48 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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,oDAAsC,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,iDAAmC,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,+CAAc,SAClB;AAGF,OAAI,CAAC,aAAa,QAAQ,aAAa,OAAO;AAC7C,QAAI,YAAY,OAAO,SAASC,kDAAgB;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,+CAAc;MAClB,OAAO;MACP;;AAGF,WAAO;KACN,IAAIA,+CAAc;KAClB,OAAO,YAAY;KACnB;;AAGF,OAAI,YAAY,OAAO,SAASC,kDAAgB;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,mDACxB,YAAY,MAAM,QAAQ,SAC1B,QACH,YAAY,MAAM,QAAQ,OAC1B,IAAI,EAAE;AAER,WAAO;KACN,IAAID,+CAAc;KAClB,OAAO;KACP;;AAGF,UAAO;IACN,IAAIA,+CAAc;IAClB,OAAO,YAAY;IACnB;MACE;AAEJ,MAAI,CAAC,QAAS,QAAO;AAErB,SAAO;GACN,GAAG;IACF,YAAY;GACb;IACC,EAAE,CAAC;AAEN,yCAA0B,YAAY,GAAG,cAAc;;AAGxD,MAAa,sBAAsB,EAClC,QAAQ,YAAwB,YAAmD;AAClF,KAAI,cAAc,CAAC,WAClB,QAAO,EACN,IAAIA,+CAAc,SAClB;AACF,KAAI,CAAC,cAAc,WAClB,QAAO;EACN,IAAIA,+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,sCAAuB,cAAc,CACpC,QAAO;EACN,IAAIA,+CAAc;EAClB,OAAO;EACP;GAIH"}

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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,94 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}