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

package/dist/customtypes/widgets/slices/Slices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slices.d.ts","names":[],"sources":["../../../../src/customtypes/widgets/slices/Slices.ts"],"mappings":";;;;;;;;;;;cAaa,qBAAA;AAAA,cACA,eAAA;AAAA,cAEA,YAAA,EAAY,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,OAAA,EAAA,CAAA,CAAA,cAAA,CAAA,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,aAAA,EAAA,CAAA,CAAA,KAAA;;;;;KAkBb,YAAA,GAAe,CAAA,CAAE,MAAA,QAAc,YAAA;AAAA,iBAE3B,kBAAA,WAA6B,WAAA,GAAc,cAAA,CAAA,CAC1D,KAAA,EAAO,CAAA,CAAE,IAAA,CAAK,CAAA,aAAW,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAUb,kBAAA,EAAkB,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/customtypes/widgets/slices/Slices.js

@@ -0,0 +1,124 @@
+import { WidgetKey } from "../../../common/WidgetKey.js";
+import "../../../common/index.js";
+import StringOrNull_default from "../../../validators/StringOrNull.js";
+import "../../../validators/index.js";
+import { traverseNestedGroup } from "../Group.js";
+import { CompositeSlice, traverseCompositeSlice } from "./CompositeSlice.js";
+import { LegacySlice } from "./LegacySlice.js";
+import { SharedSlice, traverseSharedSlice } from "./SharedSlice.js";
+import { SharedSliceRef } from "./SharedSliceRef.js";
+import * as t from "io-ts";
+
+//#region src/customtypes/widgets/slices/Slices.ts
+const LegacySlicesFieldType = "Choice";
+const SlicesFieldType = "Slices";
+const SlicesLabels = t.union([t.record(t.string, t.readonlyArray(t.exact(t.intersection([t.type({ name: t.string }), t.partial({ display: t.string })])))), t.null]);
+function slicesConfigReader(codec) {
+	return t.exact(t.partial({
+		label: StringOrNull_default,
+		labels: SlicesLabels,
+		choices: t.record(WidgetKey, t.union([
+			LegacySlice,
+			CompositeSlice,
+			codec
+		]))
+	}));
+}
+const StaticSlicesConfig = slicesConfigReader(SharedSlice);
+const DynamicSlicesConfig = slicesConfigReader(SharedSliceRef);
+const SlicesConfig = { toStatic(config, sharedSlices) {
+	const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
+		if (slice.type === "SharedSlice") {
+			const sharedSlice = sharedSlices.get(ref);
+			if (sharedSlice) return {
+				...acc,
+				[ref]: sharedSlice
+			};
+			else return acc;
+		} else return {
+			...acc,
+			[ref]: slice
+		};
+	}, {});
+	return {
+		...config,
+		choices
+	};
+} };
+function slicesReader(codec) {
+	return t.exact(t.intersection([t.type({ type: t.keyof({
+		[SlicesFieldType]: null,
+		[LegacySlicesFieldType]: null
+	}) }), t.partial({
+		fieldset: StringOrNull_default,
+		config: codec
+	})]));
+}
+const StaticSlices = slicesReader(StaticSlicesConfig);
+const DynamicSlices = slicesReader(DynamicSlicesConfig);
+const Slices = { toStatic(slices, sharedSlices) {
+	if (!slices.config) return slices;
+	else return {
+		...slices,
+		config: SlicesConfig.toStatic(slices.config, sharedSlices)
+	};
+} };
+function traverseSlices(args) {
+	const { path: prevPath, slices, onField } = args;
+	if (!slices.config?.choices) return slices;
+	let choices;
+	for (const [key, prevModel] of Object.entries(slices.config.choices)) {
+		const path = [...prevPath, key];
+		let model;
+		switch (prevModel.type) {
+			case "Slice":
+				model = traverseCompositeSlice({
+					path,
+					slice: prevModel,
+					onField
+				});
+				break;
+			case "SharedSlice":
+				if ("variations" in prevModel) model = traverseSharedSlice({
+					path,
+					slice: prevModel,
+					onField
+				});
+				else model = prevModel;
+				break;
+			case "Group":
+				model = onField({
+					path,
+					key,
+					field: traverseNestedGroup({
+						path,
+						group: prevModel,
+						onField
+					})
+				});
+				break;
+			default:
+				model = onField({
+					path,
+					key,
+					field: prevModel
+				});
+				break;
+		}
+		if (model !== prevModel) {
+			if (!choices) choices = { ...slices.config.choices };
+			choices[key] = model;
+		}
+	}
+	return choices ? {
+		...slices,
+		config: {
+			...slices.config,
+			choices
+		}
+	} : slices;
+}
+
+//#endregion
+export { DynamicSlices, DynamicSlicesConfig, LegacySlicesFieldType, Slices, SlicesFieldType, SlicesLabels, StaticSlices, StaticSlicesConfig, slicesConfigReader, slicesReader, traverseSlices };
+//# sourceMappingURL=Slices.js.map

package/dist/customtypes/widgets/slices/Slices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slices.js","names":["StringOrNull"],"sources":["../../../../src/customtypes/widgets/slices/Slices.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { WidgetKey } from \"../../../common\"\nimport type { Fields } from \"../../../utils\"\nimport { StringOrNull } from \"../../../validators\"\nimport type { Group, NestedGroup} from \"../Group\";\nimport { traverseNestedGroup } from \"../Group\"\nimport type { NestableWidget } from \"../nestable\"\nimport { CompositeSlice, traverseCompositeSlice } from \"./CompositeSlice\"\nimport { LegacySlice } from \"./LegacySlice\"\nimport { SharedSlice, traverseSharedSlice } from \"./SharedSlice\"\nimport { SharedSliceRef } from \"./SharedSliceRef\"\n\nexport const LegacySlicesFieldType = \"Choice\"\nexport const SlicesFieldType = \"Slices\"\n\nexport const SlicesLabels = t.union([\n\tt.record(\n\t\tt.string,\n\t\tt.readonlyArray(\n\t\t\tt.exact(\n\t\t\t\tt.intersection([\n\t\t\t\t\tt.type({\n\t\t\t\t\t\tname: t.string,\n\t\t\t\t\t}),\n\t\t\t\t\tt.partial({\n\t\t\t\t\t\tdisplay: t.string,\n\t\t\t\t\t}),\n\t\t\t\t]),\n\t\t\t),\n\t\t),\n\t),\n\tt.null,\n])\nexport type SlicesLabels = t.TypeOf<typeof SlicesLabels>\n\nexport function slicesConfigReader<T extends SharedSlice | SharedSliceRef>(\n\tcodec: t.Type<T, unknown>,\n) {\n\treturn t.exact(\n\t\tt.partial({\n\t\t\tlabel: StringOrNull,\n\t\t\tlabels: SlicesLabels,\n\t\t\tchoices: t.record(WidgetKey, t.union([LegacySlice, CompositeSlice, codec])),\n\t\t}),\n\t)\n}\nexport const StaticSlicesConfig = slicesConfigReader(SharedSlice)\nexport type StaticSlicesConfig = t.TypeOf<typeof StaticSlicesConfig>\n\nexport const DynamicSlicesConfig = slicesConfigReader(SharedSliceRef)\nexport type DynamicSlicesConfig = t.TypeOf<typeof DynamicSlicesConfig>\n\nconst SlicesConfig = {\n\ttoStatic(\n\t\tconfig: DynamicSlicesConfig,\n\t\tsharedSlices: Map<string, SharedSlice>,\n\t): StaticSlicesConfig {\n\t\tconst choices: {\n\t\t\t[key: string]: LegacySlice | CompositeSlice | SharedSlice\n\t\t} = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {\n\t\t\tif (slice.type === \"SharedSlice\") {\n\t\t\t\tconst sharedSlice = sharedSlices.get(ref)\n\t\t\t\tif (sharedSlice) return { ...acc, [ref]: sharedSlice }\n\t\t\t\telse return acc\n\t\t\t} else {\n\t\t\t\treturn { ...acc, [ref]: slice }\n\t\t\t}\n\t\t}, {})\n\n\t\treturn { ...config, choices } as StaticSlicesConfig\n\t},\n}\n\nexport function slicesReader<T extends StaticSlicesConfig | DynamicSlicesConfig>(\n\tcodec: t.Type<T, unknown>,\n) {\n\treturn t.exact(\n\t\tt.intersection([\n\t\t\tt.type({\n\t\t\t\ttype: t.keyof({\n\t\t\t\t\t[SlicesFieldType]: null,\n\t\t\t\t\t[LegacySlicesFieldType]: null,\n\t\t\t\t}),\n\t\t\t}),\n\t\t\tt.partial({\n\t\t\t\tfieldset: StringOrNull,\n\t\t\t\tconfig: codec,\n\t\t\t}),\n\t\t]),\n\t)\n}\n\nexport const StaticSlices = slicesReader(StaticSlicesConfig)\nexport type StaticSlices = t.TypeOf<typeof StaticSlices>\n\nexport const DynamicSlices = slicesReader(DynamicSlicesConfig)\nexport type DynamicSlices = t.TypeOf<typeof DynamicSlices>\n\nexport const Slices = {\n\ttoStatic(slices: DynamicSlices, sharedSlices: Map<string, SharedSlice>): StaticSlices {\n\t\tif (!slices.config) return slices as StaticSlices\n\t\telse {\n\t\t\treturn {\n\t\t\t\t...slices,\n\t\t\t\tconfig: SlicesConfig.toStatic(slices.config, sharedSlices),\n\t\t\t}\n\t\t}\n\t},\n}\n\nexport function traverseSlices<T extends DynamicSlices | StaticSlices>(args: {\n\tpath: ReadonlyArray<string>\n\tslices: T\n\tonField: Fields.OnFieldFn<NestableWidget | Group | NestedGroup>\n}): T {\n\tconst { path: prevPath, slices, onField } = args\n\n\tif (!slices.config?.choices) return slices\n\n\tlet choices: Record<string, (typeof slices.config.choices)[string]> | undefined\n\tfor (const [key, prevModel] of Object.entries(slices.config.choices)) {\n\t\tconst path = [...prevPath, key]\n\t\tlet model\n\t\tswitch (prevModel.type) {\n\t\t\tcase \"Slice\":\n\t\t\t\tmodel = traverseCompositeSlice({\n\t\t\t\t\tpath,\n\t\t\t\t\tslice: prevModel,\n\t\t\t\t\tonField: onField as Fields.OnFieldFn<NestableWidget>,\n\t\t\t\t})\n\t\t\t\tbreak\n\t\t\tcase \"SharedSlice\":\n\t\t\t\tif (\"variations\" in prevModel)\n\t\t\t\t\tmodel = traverseSharedSlice({\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tslice: prevModel as SharedSlice,\n\t\t\t\t\t\tonField,\n\t\t\t\t\t})\n\t\t\t\telse model = prevModel\n\t\t\t\tbreak\n\t\t\t// Group and other fields are technically possible because of legacy slices.\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: traverseNestedGroup({\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>,\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 (!choices) choices = { ...slices.config.choices }\n\t\t\tchoices[key] = model as (typeof slices.config.choices)[string]\n\t\t}\n\t}\n\n\t// returns the traversed model instead of a new one if it didn't change\n\treturn choices\n\t\t? {\n\t\t\t\t...slices,\n\t\t\t\tconfig: {\n\t\t\t\t\t...slices.config,\n\t\t\t\t\tchoices,\n\t\t\t\t},\n\t\t\t}\n\t\t: slices\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAa,wBAAwB;AACrC,MAAa,kBAAkB;AAE/B,MAAa,eAAe,EAAE,MAAM,CACnC,EAAE,OACD,EAAE,QACF,EAAE,cACD,EAAE,MACD,EAAE,aAAa,CACd,EAAE,KAAK,EACN,MAAM,EAAE,QACR,CAAC,EACF,EAAE,QAAQ,EACT,SAAS,EAAE,QACX,CAAC,CACF,CAAC,CACF,CACD,CACD,EACD,EAAE,KACF,CAAC;AAGF,SAAgB,mBACf,OACC;AACD,QAAO,EAAE,MACR,EAAE,QAAQ;EACT,OAAOA;EACP,QAAQ;EACR,SAAS,EAAE,OAAO,WAAW,EAAE,MAAM;GAAC;GAAa;GAAgB;GAAM,CAAC,CAAC;EAC3E,CAAC,CACF;;AAEF,MAAa,qBAAqB,mBAAmB,YAAY;AAGjE,MAAa,sBAAsB,mBAAmB,eAAe;AAGrE,MAAM,eAAe,EACpB,SACC,QACA,cACqB;CACrB,MAAM,UAEF,OAAO,QAAQ,OAAO,WAAW,EAAE,CAAC,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;AACtE,MAAI,MAAM,SAAS,eAAe;GACjC,MAAM,cAAc,aAAa,IAAI,IAAI;AACzC,OAAI,YAAa,QAAO;IAAE,GAAG;KAAM,MAAM;IAAa;OACjD,QAAO;QAEZ,QAAO;GAAE,GAAG;IAAM,MAAM;GAAO;IAE9B,EAAE,CAAC;AAEN,QAAO;EAAE,GAAG;EAAQ;EAAS;GAE9B;AAED,SAAgB,aACf,OACC;AACD,QAAO,EAAE,MACR,EAAE,aAAa,CACd,EAAE,KAAK,EACN,MAAM,EAAE,MAAM;GACZ,kBAAkB;GAClB,wBAAwB;EACzB,CAAC,EACF,CAAC,EACF,EAAE,QAAQ;EACT,UAAUA;EACV,QAAQ;EACR,CAAC,CACF,CAAC,CACF;;AAGF,MAAa,eAAe,aAAa,mBAAmB;AAG5D,MAAa,gBAAgB,aAAa,oBAAoB;AAG9D,MAAa,SAAS,EACrB,SAAS,QAAuB,cAAsD;AACrF,KAAI,CAAC,OAAO,OAAQ,QAAO;KAE1B,QAAO;EACN,GAAG;EACH,QAAQ,aAAa,SAAS,OAAO,QAAQ,aAAa;EAC1D;GAGH;AAED,SAAgB,eAAuD,MAIjE;CACL,MAAM,EAAE,MAAM,UAAU,QAAQ,YAAY;AAE5C,KAAI,CAAC,OAAO,QAAQ,QAAS,QAAO;CAEpC,IAAI;AACJ,MAAK,MAAM,CAAC,KAAK,cAAc,OAAO,QAAQ,OAAO,OAAO,QAAQ,EAAE;EACrE,MAAM,OAAO,CAAC,GAAG,UAAU,IAAI;EAC/B,IAAI;AACJ,UAAQ,UAAU,MAAlB;GACC,KAAK;AACJ,YAAQ,uBAAuB;KAC9B;KACA,OAAO;KACE;KACT,CAAC;AACF;GACD,KAAK;AACJ,QAAI,gBAAgB,UACnB,SAAQ,oBAAoB;KAC3B;KACA,OAAO;KACP;KACA,CAAC;QACE,SAAQ;AACb;GAED,KAAK;AACJ,YAAQ,QAAQ;KACf;KACA;KACA,OAAO,oBAAoB;MAC1B;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,OAAO,OAAO,SAAS;AACpD,WAAQ,OAAO;;;AAKjB,QAAO,UACJ;EACA,GAAG;EACH,QAAQ;GACP,GAAG,OAAO;GACV;GACA;EACD,GACA"}

package/dist/customtypes/widgets/slices/SlicesTypes.cjs

@@ -0,0 +1,15 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
+const require_CompositeSlice = require('./CompositeSlice.cjs');
+const require_SharedSlice = require('./SharedSlice.cjs');
+let io_ts = require("io-ts");
+io_ts = require_runtime.__toESM(io_ts);
+
+//#region src/customtypes/widgets/slices/SlicesTypes.ts
+const SlicesTypes = io_ts.keyof({
+	[require_CompositeSlice.CompositeSliceType]: null,
+	[require_SharedSlice.SharedSliceType]: null
+});
+
+//#endregion
+exports.SlicesTypes = SlicesTypes;
+//# sourceMappingURL=SlicesTypes.cjs.map

package/dist/customtypes/widgets/slices/SlicesTypes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlicesTypes.cjs","names":["t","CompositeSliceType","SharedSliceType"],"sources":["../../../../src/customtypes/widgets/slices/SlicesTypes.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { CompositeSliceType } from \"./CompositeSlice\"\nimport { SharedSliceType } from \"./SharedSlice\"\n\nexport const SlicesTypes = t.keyof({\n\t[CompositeSliceType]: null,\n\t[SharedSliceType]: null,\n})\n\nexport type SlicesTypes = t.TypeOf<typeof SlicesTypes>\n"],"mappings":";;;;;;;AAKA,MAAa,cAAcA,MAAE,MAAM;EACjCC,4CAAqB;EACrBC,sCAAkB;CACnB,CAAC"}

package/dist/customtypes/widgets/slices/SlicesTypes.d.cts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+
+//#region src/customtypes/widgets/slices/SlicesTypes.d.ts
+declare const SlicesTypes: t.KeyofC<{
+  Slice: null;
+  SharedSlice: null;
+}>;
+type SlicesTypes = t.TypeOf<typeof SlicesTypes>;
+//#endregion
+export { SlicesTypes };
+//# sourceMappingURL=SlicesTypes.d.cts.map

package/dist/customtypes/widgets/slices/SlicesTypes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlicesTypes.d.cts","names":[],"sources":["../../../../src/customtypes/widgets/slices/SlicesTypes.ts"],"mappings":";;;cAKa,WAAA,EAAW,CAAA,CAAA,MAAA;;;;KAKZ,WAAA,GAAc,CAAA,CAAE,MAAA,QAAc,WAAA"}

package/dist/customtypes/widgets/slices/SlicesTypes.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+
+//#region src/customtypes/widgets/slices/SlicesTypes.d.ts
+declare const SlicesTypes: t.KeyofC<{
+  Slice: null;
+  SharedSlice: null;
+}>;
+type SlicesTypes = t.TypeOf<typeof SlicesTypes>;
+//#endregion
+export { SlicesTypes };
+//# sourceMappingURL=SlicesTypes.d.ts.map

package/dist/customtypes/widgets/slices/SlicesTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlicesTypes.d.ts","names":[],"sources":["../../../../src/customtypes/widgets/slices/SlicesTypes.ts"],"mappings":";;;cAKa,WAAA,EAAW,CAAA,CAAA,MAAA;;;;KAKZ,WAAA,GAAc,CAAA,CAAE,MAAA,QAAc,WAAA"}

package/dist/customtypes/widgets/slices/SlicesTypes.js

@@ -0,0 +1,13 @@
+import { CompositeSliceType } from "./CompositeSlice.js";
+import { SharedSliceType } from "./SharedSlice.js";
+import * as t from "io-ts";
+
+//#region src/customtypes/widgets/slices/SlicesTypes.ts
+const SlicesTypes = t.keyof({
+	[CompositeSliceType]: null,
+	[SharedSliceType]: null
+});
+
+//#endregion
+export { SlicesTypes };
+//# sourceMappingURL=SlicesTypes.js.map

package/dist/customtypes/widgets/slices/SlicesTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlicesTypes.js","names":[],"sources":["../../../../src/customtypes/widgets/slices/SlicesTypes.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { CompositeSliceType } from \"./CompositeSlice\"\nimport { SharedSliceType } from \"./SharedSlice\"\n\nexport const SlicesTypes = t.keyof({\n\t[CompositeSliceType]: null,\n\t[SharedSliceType]: null,\n})\n\nexport type SlicesTypes = t.TypeOf<typeof SlicesTypes>\n"],"mappings":";;;;;AAKA,MAAa,cAAc,EAAE,MAAM;EACjC,qBAAqB;EACrB,kBAAkB;CACnB,CAAC"}

package/dist/customtypes/widgets/slices/index.cjs

@@ -0,0 +1,7 @@
+const require_CompositeSlice = require('./CompositeSlice.cjs');
+const require_LegacySlice = require('./LegacySlice.cjs');
+const require_SlicePrimaryWidget = require('./SlicePrimaryWidget.cjs');
+const require_SharedSlice = require('./SharedSlice.cjs');
+const require_SharedSliceRef = require('./SharedSliceRef.cjs');
+const require_Slices = require('./Slices.cjs');
+const require_SlicesTypes = require('./SlicesTypes.cjs');

package/dist/customtypes/widgets/slices/index.d.ts

@@ -0,0 +1,8 @@
+import { LegacySlice, isLegacySlice } from "./LegacySlice.js";
+import { SharedSliceRef } from "./SharedSliceRef.js";
+import { SharedSlice, SharedSliceType, Variation, VariationFields, isDynamicSharedSlice, isStaticSharedSlice, traverseSharedSlice, traverseVariation } from "./SharedSlice.js";
+import { DynamicSlice, StaticSlice } from "./Slice.js";
+import { CompositeSlice, CompositeSliceConfig, CompositeSliceType, isCompositeSlice, traverseCompositeSlice } from "./CompositeSlice.js";
+import { SlicePrimaryFieldTypes, SlicePrimaryWidget, isSlicePrimaryWidget } from "./SlicePrimaryWidget.js";
+import { DynamicSlices, DynamicSlicesConfig, LegacySlicesFieldType, Slices, SlicesFieldType, SlicesLabels, StaticSlices, StaticSlicesConfig, slicesConfigReader, slicesReader, traverseSlices } from "./Slices.js";
+import { SlicesTypes } from "./SlicesTypes.js";

package/dist/customtypes/widgets/slices/index.js

@@ -0,0 +1,7 @@
+import { CompositeSlice, CompositeSliceConfig, CompositeSliceType, isCompositeSlice, traverseCompositeSlice } from "./CompositeSlice.js";
+import { LegacySlice, isLegacySlice } from "./LegacySlice.js";
+import { SlicePrimaryWidget, isSlicePrimaryWidget } from "./SlicePrimaryWidget.js";
+import { SharedSlice, SharedSliceType, Variation, isDynamicSharedSlice, isStaticSharedSlice, traverseSharedSlice, traverseVariation } from "./SharedSlice.js";
+import { SharedSliceRef } from "./SharedSliceRef.js";
+import { DynamicSlices, DynamicSlicesConfig, LegacySlicesFieldType, Slices, SlicesFieldType, SlicesLabels, StaticSlices, StaticSlicesConfig, slicesConfigReader, slicesReader, traverseSlices } from "./Slices.js";
+import { SlicesTypes } from "./SlicesTypes.js";

package/dist/index.cjs

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_index = require('./common/index.cjs');
+const require_index$1 = require('./validators/index.cjs');
+const require_index$2 = require('./utils/index.cjs');
+const require_index$3 = require('./customtypes/index.cjs');
+const require_index$4 = require('./content/index.cjs');
+
+Object.defineProperty(exports, 'Common', {
+  enumerable: true,
+  get: function () {
+    return require_index.common_exports;
+  }
+});
+Object.defineProperty(exports, 'Content', {
+  enumerable: true,
+  get: function () {
+    return require_index$4.content_exports;
+  }
+});
+Object.defineProperty(exports, 'CustomTypes', {
+  enumerable: true,
+  get: function () {
+    return require_index$3.customtypes_exports;
+  }
+});
+Object.defineProperty(exports, 'Utils', {
+  enumerable: true,
+  get: function () {
+    return require_index$2.utils_exports;
+  }
+});
+Object.defineProperty(exports, 'Validators', {
+  enumerable: true,
+  get: function () {
+    return require_index$1.validators_exports;
+  }
+});

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+import { index_d_exports } from "./common/index.cjs";
+import { index_d_exports as index_d_exports$3 } from "./utils/index.cjs";
+import { index_d_exports as index_d_exports$2 } from "./customtypes/index.cjs";
+import { index_d_exports as index_d_exports$1 } from "./content/index.cjs";
+import { index_d_exports as index_d_exports$4 } from "./validators/index.cjs";
+export { index_d_exports as Common, index_d_exports$1 as Content, index_d_exports$2 as CustomTypes, index_d_exports$3 as Utils, index_d_exports$4 as Validators };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { index_d_exports } from "./common/index.js";
+import { index_d_exports as index_d_exports$3 } from "./utils/index.js";
+import { index_d_exports as index_d_exports$2 } from "./customtypes/index.js";
+import { index_d_exports as index_d_exports$1 } from "./content/index.js";
+import { index_d_exports as index_d_exports$4 } from "./validators/index.js";
+export { index_d_exports as Common, index_d_exports$1 as Content, index_d_exports$2 as CustomTypes, index_d_exports$3 as Utils, index_d_exports$4 as Validators };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { common_exports } from "./common/index.js";
+import { validators_exports } from "./validators/index.js";
+import { utils_exports } from "./utils/index.js";
+import { customtypes_exports } from "./customtypes/index.js";
+import { content_exports } from "./content/index.js";
+
+export { common_exports as Common, content_exports as Content, customtypes_exports as CustomTypes, utils_exports as Utils, validators_exports as Validators };

package/dist/utils/Arrays.cjs

@@ -0,0 +1,23 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+
+//#region src/utils/Arrays.ts
+var Arrays_exports = /* @__PURE__ */ require_runtime.__exportAll({ toRecord: () => toRecord });
+function toRecord(arr, key) {
+	return arr.reduce((acc, entry) => {
+		const k = key(entry);
+		return {
+			...acc,
+			[k]: entry
+		};
+	}, {});
+}
+
+//#endregion
+Object.defineProperty(exports, 'Arrays_exports', {
+  enumerable: true,
+  get: function () {
+    return Arrays_exports;
+  }
+});
+exports.toRecord = toRecord;
+//# sourceMappingURL=Arrays.cjs.map

package/dist/utils/Arrays.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Arrays.cjs","names":[],"sources":["../../src/utils/Arrays.ts"],"sourcesContent":["export function toRecord<A extends object>(arr: ReadonlyArray<A>, key: (obj: A) => string) {\n\treturn arr.reduce((acc, entry) => {\n\t\tconst k = key(entry)\n\t\treturn {\n\t\t\t...acc,\n\t\t\t[k]: entry,\n\t\t}\n\t}, {})\n}\n"],"mappings":";;;;AAAA,SAAgB,SAA2B,KAAuB,KAAyB;AAC1F,QAAO,IAAI,QAAQ,KAAK,UAAU;EACjC,MAAM,IAAI,IAAI,MAAM;AACpB,SAAO;GACN,GAAG;IACF,IAAI;GACL;IACC,EAAE,CAAC"}

package/dist/utils/Arrays.d.cts

@@ -0,0 +1,7 @@
+declare namespace Arrays_d_exports {
+  export { toRecord };
+}
+declare function toRecord<A extends object>(arr: ReadonlyArray<A>, key: (obj: A) => string): {};
+//#endregion
+export { Arrays_d_exports };
+//# sourceMappingURL=Arrays.d.cts.map

package/dist/utils/Arrays.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Arrays.d.cts","names":[],"sources":["../../src/utils/Arrays.ts"],"mappings":";;;iBAAgB,QAAA,kBAAA,CAA2B,GAAA,EAAK,aAAA,CAAc,CAAA,GAAI,GAAA,GAAM,GAAA,EAAK,CAAA"}

package/dist/utils/Arrays.d.ts

@@ -0,0 +1,7 @@
+declare namespace Arrays_d_exports {
+  export { toRecord };
+}
+declare function toRecord<A extends object>(arr: ReadonlyArray<A>, key: (obj: A) => string): {};
+//#endregion
+export { Arrays_d_exports };
+//# sourceMappingURL=Arrays.d.ts.map

package/dist/utils/Arrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Arrays.d.ts","names":[],"sources":["../../src/utils/Arrays.ts"],"mappings":";;;iBAAgB,QAAA,kBAAA,CAA2B,GAAA,EAAK,aAAA,CAAc,CAAA,GAAI,GAAA,GAAM,GAAA,EAAK,CAAA"}

package/dist/utils/Arrays.js

@@ -0,0 +1,17 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+
+//#region src/utils/Arrays.ts
+var Arrays_exports = /* @__PURE__ */ __exportAll({ toRecord: () => toRecord });
+function toRecord(arr, key) {
+	return arr.reduce((acc, entry) => {
+		const k = key(entry);
+		return {
+			...acc,
+			[k]: entry
+		};
+	}, {});
+}
+
+//#endregion
+export { Arrays_exports, toRecord };
+//# sourceMappingURL=Arrays.js.map

package/dist/utils/Arrays.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Arrays.js","names":[],"sources":["../../src/utils/Arrays.ts"],"sourcesContent":["export function toRecord<A extends object>(arr: ReadonlyArray<A>, key: (obj: A) => string) {\n\treturn arr.reduce((acc, entry) => {\n\t\tconst k = key(entry)\n\t\treturn {\n\t\t\t...acc,\n\t\t\t[k]: entry,\n\t\t}\n\t}, {})\n}\n"],"mappings":";;;;AAAA,SAAgB,SAA2B,KAAuB,KAAyB;AAC1F,QAAO,IAAI,QAAQ,KAAK,UAAU;EACjC,MAAM,IAAI,IAAI,MAAM;AACpB,SAAO;GACN,GAAG;IACF,IAAI;GACL;IACC,EAAE,CAAC"}

package/dist/utils/Fields.cjs

@@ -0,0 +1,13 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+
+//#region src/utils/Fields.ts
+var Fields_exports = /* @__PURE__ */ require_runtime.__exportAll({});
+
+//#endregion
+Object.defineProperty(exports, 'Fields_exports', {
+  enumerable: true,
+  get: function () {
+    return Fields_exports;
+  }
+});
+//# sourceMappingURL=Fields.cjs.map

package/dist/utils/Fields.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fields.cjs","names":[],"sources":["../../src/utils/Fields.ts"],"sourcesContent":["import type { Group, NestableWidget, NestedGroup, UID } from \"../customtypes\"\n\nexport type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> = (args: {\n\tpath: ReadonlyArray<string>\n\tkey: string\n\tfield: T\n}) => T\n"],"mappings":""}

package/dist/utils/Fields.d.cts

@@ -0,0 +1,16 @@
+import { NestableWidget } from "../customtypes/widgets/nestable/NestableWidget.cjs";
+import { Group, NestedGroup } from "../customtypes/widgets/Group.cjs";
+import { UID } from "../customtypes/widgets/UID.cjs";
+
+//#region src/utils/Fields.d.ts
+declare namespace Fields_d_exports {
+  export { OnFieldFn };
+}
+type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> = (args: {
+  path: ReadonlyArray<string>;
+  key: string;
+  field: T;
+}) => T;
+//#endregion
+export { Fields_d_exports, OnFieldFn };
+//# sourceMappingURL=Fields.d.cts.map

package/dist/utils/Fields.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fields.d.cts","names":[],"sources":["../../src/utils/Fields.ts"],"mappings":";;;;;;;;KAEY,SAAA,WAAoB,GAAA,GAAM,cAAA,GAAiB,KAAA,GAAQ,WAAA,KAAgB,IAAA;EAC9E,IAAA,EAAM,aAAA;EACN,GAAA;EACA,KAAA,EAAO,CAAA;AAAA,MACF,CAAA"}

package/dist/utils/Fields.d.ts

@@ -0,0 +1,17 @@
+import { NestableWidget } from "../customtypes/widgets/nestable/NestableWidget.js";
+import { Group, NestedGroup } from "../customtypes/widgets/Group.js";
+import { UID } from "../customtypes/widgets/UID.js";
+import "../customtypes/index.js";
+
+//#region src/utils/Fields.d.ts
+declare namespace Fields_d_exports {
+  export { OnFieldFn };
+}
+type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> = (args: {
+  path: ReadonlyArray<string>;
+  key: string;
+  field: T;
+}) => T;
+//#endregion
+export { Fields_d_exports, OnFieldFn };
+//# sourceMappingURL=Fields.d.ts.map

package/dist/utils/Fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fields.d.ts","names":[],"sources":["../../src/utils/Fields.ts"],"mappings":";;;;;;;;;KAEY,SAAA,WAAoB,GAAA,GAAM,cAAA,GAAiB,KAAA,GAAQ,WAAA,KAAgB,IAAA;EAC9E,IAAA,EAAM,aAAA;EACN,GAAA;EACA,KAAA,EAAO,CAAA;AAAA,MACF,CAAA"}

package/dist/utils/Fields.js

@@ -0,0 +1,8 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+
+//#region src/utils/Fields.ts
+var Fields_exports = /* @__PURE__ */ __exportAll({});
+
+//#endregion
+export { Fields_exports };
+//# sourceMappingURL=Fields.js.map

package/dist/utils/Fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fields.js","names":[],"sources":["../../src/utils/Fields.ts"],"sourcesContent":["import type { Group, NestableWidget, NestedGroup, UID } from \"../customtypes\"\n\nexport type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> = (args: {\n\tpath: ReadonlyArray<string>\n\tkey: string\n\tfield: T\n}) => T\n"],"mappings":""}

package/dist/utils/Objects.cjs

@@ -0,0 +1,62 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let io_ts = require("io-ts");
+io_ts = require_runtime.__toESM(io_ts);
+let fp_ts_lib_Either = require("fp-ts/lib/Either");
+
+//#region src/utils/Objects.ts
+var Objects_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	isNotEmpty: () => isNotEmpty,
+	isObject: () => isObject,
+	mapValues: () => mapValues,
+	withOptionals: () => withOptionals,
+	zipObjects: () => zipObjects
+});
+function zipObjects(objLeft, objRight) {
+	return [...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {})))].reduce((acc, key) => {
+		const left = objLeft?.[key];
+		const right = objRight?.[key];
+		return {
+			...acc,
+			[key]: {
+				left,
+				right
+			}
+		};
+	}, {});
+}
+function isNotEmpty(obj) {
+	return Boolean(Object.keys(obj).length);
+}
+function withOptionals(object, optionals) {
+	return {
+		...object,
+		...optionals.reduce((acc, [key, value]) => {
+			return value ? {
+				...acc,
+				[key]: value
+			} : acc;
+		}, {})
+	};
+}
+const recordCodec = io_ts.record(io_ts.string, io_ts.unknown);
+function isObject(value) {
+	return (0, fp_ts_lib_Either.isRight)(recordCodec.decode(value));
+}
+function mapValues(record, fn) {
+	return Object.entries(record).reduce((acc, [key, value]) => ({
+		...acc,
+		[key]: fn(value, key)
+	}), {});
+}
+
+//#endregion
+Object.defineProperty(exports, 'Objects_exports', {
+  enumerable: true,
+  get: function () {
+    return Objects_exports;
+  }
+});
+exports.isNotEmpty = isNotEmpty;
+exports.withOptionals = withOptionals;
+exports.zipObjects = zipObjects;
+//# sourceMappingURL=Objects.cjs.map

package/dist/utils/Objects.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Objects.cjs","names":["t"],"sources":["../../src/utils/Objects.ts"],"sourcesContent":["import { isRight } from \"fp-ts/lib/Either\"\nimport * as t from \"io-ts\"\n\nexport function zipObjects<A, B = A>(\n\tobjLeft?: Partial<Record<string, A>> | undefined,\n\tobjRight?: Partial<Record<string, B>> | undefined,\n): Partial<Record<string, { left?: A | undefined; right?: B | undefined }>> {\n\tconst allKeys = [...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {})))]\n\n\treturn allKeys.reduce<Record<string, { left?: A | undefined; right?: B | undefined }>>(\n\t\t(acc, key) => {\n\t\t\tconst left = objLeft?.[key]\n\t\t\tconst right = objRight?.[key]\n\t\t\treturn {\n\t\t\t\t...acc,\n\t\t\t\t[key]: { left, right },\n\t\t\t}\n\t\t},\n\t\t{},\n\t)\n}\n\nexport function isNotEmpty<A extends object>(obj: A): boolean {\n\treturn Boolean(Object.keys(obj).length)\n}\n\nexport function withOptionals<T extends object>(\n\tobject: T,\n\toptionals: Array<[keyof T, T[keyof T] | null | undefined]>,\n): T {\n\treturn {\n\t\t...object,\n\t\t...optionals.reduce((acc, [key, value]) => {\n\t\t\treturn value ? { ...acc, [key]: value } : acc\n\t\t}, {}),\n\t}\n}\n\nconst recordCodec = t.record(t.string, t.unknown)\nexport function isObject(value: unknown): value is Record<string, unknown> {\n\treturn isRight(recordCodec.decode(value))\n}\n\nexport function mapValues<T, O>(\n\trecord: Record<string, T>,\n\tfn: (value: T, key: string) => O,\n): Record<string, O> {\n\treturn Object.entries<T>(record).reduce<Record<string, O>>(\n\t\t(acc, [key, value]) => ({ ...acc, [key]: fn(value, key) }),\n\t\t{},\n\t)\n}\n"],"mappings":";;;;;;;;;;;;;AAGA,SAAgB,WACf,SACA,UAC2E;AAG3E,QAFgB,CAAC,GAAG,IAAI,IAAI,OAAO,KAAK,WAAW,EAAE,CAAC,CAAC,OAAO,OAAO,KAAK,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC,CAE7E,QACb,KAAK,QAAQ;EACb,MAAM,OAAO,UAAU;EACvB,MAAM,QAAQ,WAAW;AACzB,SAAO;GACN,GAAG;IACF,MAAM;IAAE;IAAM;IAAO;GACtB;IAEF,EAAE,CACF;;AAGF,SAAgB,WAA6B,KAAiB;AAC7D,QAAO,QAAQ,OAAO,KAAK,IAAI,CAAC,OAAO;;AAGxC,SAAgB,cACf,QACA,WACI;AACJ,QAAO;EACN,GAAG;EACH,GAAG,UAAU,QAAQ,KAAK,CAAC,KAAK,WAAW;AAC1C,UAAO,QAAQ;IAAE,GAAG;KAAM,MAAM;IAAO,GAAG;KACxC,EAAE,CAAC;EACN;;AAGF,MAAM,cAAcA,MAAE,OAAOA,MAAE,QAAQA,MAAE,QAAQ;AACjD,SAAgB,SAAS,OAAkD;AAC1E,sCAAe,YAAY,OAAO,MAAM,CAAC;;AAG1C,SAAgB,UACf,QACA,IACoB;AACpB,QAAO,OAAO,QAAW,OAAO,CAAC,QAC/B,KAAK,CAAC,KAAK,YAAY;EAAE,GAAG;GAAM,MAAM,GAAG,OAAO,IAAI;EAAE,GACzD,EAAE,CACF"}

package/dist/utils/Objects.d.cts

@@ -0,0 +1,14 @@
+declare namespace Objects_d_exports {
+  export { isNotEmpty, isObject, mapValues, withOptionals, zipObjects };
+}
+declare function zipObjects<A, B = A>(objLeft?: Partial<Record<string, A>> | undefined, objRight?: Partial<Record<string, B>> | undefined): Partial<Record<string, {
+  left?: A | undefined;
+  right?: B | undefined;
+}>>;
+declare function isNotEmpty<A extends object>(obj: A): boolean;
+declare function withOptionals<T extends object>(object: T, optionals: Array<[keyof T, T[keyof T] | null | undefined]>): T;
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function mapValues<T, O>(record: Record<string, T>, fn: (value: T, key: string) => O): Record<string, O>;
+//#endregion
+export { Objects_d_exports };
+//# sourceMappingURL=Objects.d.cts.map

package/dist/utils/Objects.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Objects.d.cts","names":[],"sources":["../../src/utils/Objects.ts"],"mappings":";;;iBAGgB,UAAA,QAAkB,CAAA,CAAA,CACjC,OAAA,GAAU,OAAA,CAAQ,MAAA,SAAe,CAAA,gBACjC,QAAA,GAAW,OAAA,CAAQ,MAAA,SAAe,CAAA,iBAChC,OAAA,CAAQ,MAAA;EAAiB,IAAA,GAAO,CAAA;EAAe,KAAA,GAAQ,CAAA;AAAA;AAAA,iBAgB1C,UAAA,kBAAA,CAA6B,GAAA,EAAK,CAAA;AAAA,iBAIlC,aAAA,kBAAA,CACf,MAAA,EAAQ,CAAA,EACR,SAAA,EAAW,KAAA,QAAa,CAAA,EAAG,CAAA,OAAQ,CAAA,yBACjC,CAAA;AAAA,iBAUa,QAAA,CAAS,KAAA,YAAiB,KAAA,IAAS,MAAA;AAAA,iBAInC,SAAA,MAAA,CACf,MAAA,EAAQ,MAAA,SAAe,CAAA,GACvB,EAAA,GAAK,KAAA,EAAO,CAAA,EAAG,GAAA,aAAgB,CAAA,GAC7B,MAAA,SAAe,CAAA"}

package/dist/utils/Objects.d.ts

@@ -0,0 +1,14 @@
+declare namespace Objects_d_exports {
+  export { isNotEmpty, isObject, mapValues, withOptionals, zipObjects };
+}
+declare function zipObjects<A, B = A>(objLeft?: Partial<Record<string, A>> | undefined, objRight?: Partial<Record<string, B>> | undefined): Partial<Record<string, {
+  left?: A | undefined;
+  right?: B | undefined;
+}>>;
+declare function isNotEmpty<A extends object>(obj: A): boolean;
+declare function withOptionals<T extends object>(object: T, optionals: Array<[keyof T, T[keyof T] | null | undefined]>): T;
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function mapValues<T, O>(record: Record<string, T>, fn: (value: T, key: string) => O): Record<string, O>;
+//#endregion
+export { Objects_d_exports };
+//# sourceMappingURL=Objects.d.ts.map

package/dist/utils/Objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Objects.d.ts","names":[],"sources":["../../src/utils/Objects.ts"],"mappings":";;;iBAGgB,UAAA,QAAkB,CAAA,CAAA,CACjC,OAAA,GAAU,OAAA,CAAQ,MAAA,SAAe,CAAA,gBACjC,QAAA,GAAW,OAAA,CAAQ,MAAA,SAAe,CAAA,iBAChC,OAAA,CAAQ,MAAA;EAAiB,IAAA,GAAO,CAAA;EAAe,KAAA,GAAQ,CAAA;AAAA;AAAA,iBAgB1C,UAAA,kBAAA,CAA6B,GAAA,EAAK,CAAA;AAAA,iBAIlC,aAAA,kBAAA,CACf,MAAA,EAAQ,CAAA,EACR,SAAA,EAAW,KAAA,QAAa,CAAA,EAAG,CAAA,OAAQ,CAAA,yBACjC,CAAA;AAAA,iBAUa,QAAA,CAAS,KAAA,YAAiB,KAAA,IAAS,MAAA;AAAA,iBAInC,SAAA,MAAA,CACf,MAAA,EAAQ,MAAA,SAAe,CAAA,GACvB,EAAA,GAAK,KAAA,EAAO,CAAA,EAAG,GAAA,aAAgB,CAAA,GAC7B,MAAA,SAAe,CAAA"}

package/dist/utils/Objects.js

@@ -0,0 +1,53 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import * as t from "io-ts";
+import { isRight } from "fp-ts/lib/Either";
+
+//#region src/utils/Objects.ts
+var Objects_exports = /* @__PURE__ */ __exportAll({
+	isNotEmpty: () => isNotEmpty,
+	isObject: () => isObject,
+	mapValues: () => mapValues,
+	withOptionals: () => withOptionals,
+	zipObjects: () => zipObjects
+});
+function zipObjects(objLeft, objRight) {
+	return [...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {})))].reduce((acc, key) => {
+		const left = objLeft?.[key];
+		const right = objRight?.[key];
+		return {
+			...acc,
+			[key]: {
+				left,
+				right
+			}
+		};
+	}, {});
+}
+function isNotEmpty(obj) {
+	return Boolean(Object.keys(obj).length);
+}
+function withOptionals(object, optionals) {
+	return {
+		...object,
+		...optionals.reduce((acc, [key, value]) => {
+			return value ? {
+				...acc,
+				[key]: value
+			} : acc;
+		}, {})
+	};
+}
+const recordCodec = t.record(t.string, t.unknown);
+function isObject(value) {
+	return isRight(recordCodec.decode(value));
+}
+function mapValues(record, fn) {
+	return Object.entries(record).reduce((acc, [key, value]) => ({
+		...acc,
+		[key]: fn(value, key)
+	}), {});
+}
+
+//#endregion
+export { Objects_exports, isNotEmpty, withOptionals, zipObjects };
+//# sourceMappingURL=Objects.js.map