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

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

@@ -1 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACnB,kBAAA,GAAqB,CAAA,CAAE,MAAA,QAAc,kBAAA;AAAA,cAEpC,mBAAA,EAAmB,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACpB,mBAAA,GAAsB,CAAA,CAAE,MAAA,QAAc,mBAAA;AAAA,iBAuBlC,YAAA,WAAuB,kBAAA,GAAqB,mBAAA,CAAA,CAC3D,KAAA,EAAO,CAAA,CAAE,IAAA,CAAK,CAAA,aAAW,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,aAAA,EAAA,CAAA,CAAA,KAAA;;;;;;;;;cAkBb,YAAA,EAAY,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,aAAA,EAAA,CAAA,CAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACb,YAAA,GAAe,CAAA,CAAE,MAAA,QAAc,YAAA;AAAA,cAE9B,aAAA,EAAa,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,aAAA,EAAA,CAAA,CAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACd,aAAA,GAAgB,CAAA,CAAE,MAAA,QAAc,aAAA;AAAA,cAE/B,MAAA;mBACK,aAAA,EAAa,YAAA,EAAgB,GAAA,SAAY,WAAA,IAAe,YAAA;AAAA;AAAA,iBAW1D,cAAA,WAAyB,aAAA,GAAgB,YAAA,CAAA,CAAc,IAAA;EACtE,IAAA,EAAM,aAAA;EACN,MAAA,EAAQ,CAAA;EACR,OAAA,EAAS,SAAA,CAAiB,cAAA,GAAiB,KAAA,GAAQ,WAAA;AAAA,IAChD,CAAA"}

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

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

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

@@ -1,16 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
-const require_customtypes_widgets_slices_CompositeSlice = require('./CompositeSlice.cjs');
-const require_customtypes_widgets_slices_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_customtypes_widgets_slices_CompositeSlice.CompositeSliceType]: null,
-	[require_customtypes_widgets_slices_SharedSlice.SharedSliceType]: null
-});
-
-//#endregion
-exports.SlicesTypes = SlicesTypes;
-//# sourceMappingURL=SlicesTypes.cjs.map

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

@@ -1 +0,0 @@
-{"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,uEAAqB;EACrBC,iEAAkB;CACnB,CAAC"}

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

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

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

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

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

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

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

@@ -1,38 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_customtypes_widgets_slices_CompositeSlice = require('./CompositeSlice.cjs');
-const require_customtypes_widgets_slices_LegacySlice = require('./LegacySlice.cjs');
-const require_customtypes_widgets_slices_SlicePrimaryWidget = require('./SlicePrimaryWidget.cjs');
-const require_customtypes_widgets_slices_SharedSlice = require('./SharedSlice.cjs');
-const require_customtypes_widgets_slices_SharedSliceRef = require('./SharedSliceRef.cjs');
-const require_customtypes_widgets_slices_Slices = require('./Slices.cjs');
-const require_customtypes_widgets_slices_SlicesTypes = require('./SlicesTypes.cjs');
-
-exports.CompositeSlice = require_customtypes_widgets_slices_CompositeSlice.CompositeSlice;
-exports.CompositeSliceConfig = require_customtypes_widgets_slices_CompositeSlice.CompositeSliceConfig;
-exports.CompositeSliceType = require_customtypes_widgets_slices_CompositeSlice.CompositeSliceType;
-exports.DynamicSlices = require_customtypes_widgets_slices_Slices.DynamicSlices;
-exports.DynamicSlicesConfig = require_customtypes_widgets_slices_Slices.DynamicSlicesConfig;
-exports.LegacySlice = require_customtypes_widgets_slices_LegacySlice.LegacySlice;
-exports.LegacySlicesFieldType = require_customtypes_widgets_slices_Slices.LegacySlicesFieldType;
-exports.SharedSlice = require_customtypes_widgets_slices_SharedSlice.SharedSlice;
-exports.SharedSliceRef = require_customtypes_widgets_slices_SharedSliceRef.SharedSliceRef;
-exports.SharedSliceType = require_customtypes_widgets_slices_SharedSlice.SharedSliceType;
-exports.SlicePrimaryWidget = require_customtypes_widgets_slices_SlicePrimaryWidget.SlicePrimaryWidget;
-exports.Slices = require_customtypes_widgets_slices_Slices.Slices;
-exports.SlicesFieldType = require_customtypes_widgets_slices_Slices.SlicesFieldType;
-exports.SlicesLabels = require_customtypes_widgets_slices_Slices.SlicesLabels;
-exports.SlicesTypes = require_customtypes_widgets_slices_SlicesTypes.SlicesTypes;
-exports.StaticSlices = require_customtypes_widgets_slices_Slices.StaticSlices;
-exports.StaticSlicesConfig = require_customtypes_widgets_slices_Slices.StaticSlicesConfig;
-exports.Variation = require_customtypes_widgets_slices_SharedSlice.Variation;
-exports.isCompositeSlice = require_customtypes_widgets_slices_CompositeSlice.isCompositeSlice;
-exports.isDynamicSharedSlice = require_customtypes_widgets_slices_SharedSlice.isDynamicSharedSlice;
-exports.isLegacySlice = require_customtypes_widgets_slices_LegacySlice.isLegacySlice;
-exports.isSlicePrimaryWidget = require_customtypes_widgets_slices_SlicePrimaryWidget.isSlicePrimaryWidget;
-exports.isStaticSharedSlice = require_customtypes_widgets_slices_SharedSlice.isStaticSharedSlice;
-exports.slicesConfigReader = require_customtypes_widgets_slices_Slices.slicesConfigReader;
-exports.slicesReader = require_customtypes_widgets_slices_Slices.slicesReader;
-exports.traverseCompositeSlice = require_customtypes_widgets_slices_CompositeSlice.traverseCompositeSlice;
-exports.traverseSharedSlice = require_customtypes_widgets_slices_SharedSlice.traverseSharedSlice;
-exports.traverseSlices = require_customtypes_widgets_slices_Slices.traverseSlices;
-exports.traverseVariation = require_customtypes_widgets_slices_SharedSlice.traverseVariation;

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

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

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

@@ -1,9 +0,0 @@
-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";
-export { CompositeSlice, CompositeSliceConfig, CompositeSliceType, DynamicSlice, DynamicSlices, DynamicSlicesConfig, LegacySlice, LegacySlicesFieldType, SharedSlice, SharedSliceRef, SharedSliceType, SlicePrimaryFieldTypes, SlicePrimaryWidget, Slices, SlicesFieldType, SlicesLabels, SlicesTypes, StaticSlice, StaticSlices, StaticSlicesConfig, Variation, VariationFields, isCompositeSlice, isDynamicSharedSlice, isLegacySlice, isSlicePrimaryWidget, isStaticSharedSlice, slicesConfigReader, slicesReader, traverseCompositeSlice, traverseSharedSlice, traverseSlices, traverseVariation };

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

@@ -1,9 +0,0 @@
-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";
-
-export { CompositeSlice, CompositeSliceConfig, CompositeSliceType, DynamicSlices, DynamicSlicesConfig, LegacySlice, LegacySlicesFieldType, SharedSlice, SharedSliceRef, SharedSliceType, SlicePrimaryWidget, Slices, SlicesFieldType, SlicesLabels, SlicesTypes, StaticSlices, StaticSlicesConfig, Variation, isCompositeSlice, isDynamicSharedSlice, isLegacySlice, isSlicePrimaryWidget, isStaticSharedSlice, slicesConfigReader, slicesReader, traverseCompositeSlice, traverseSharedSlice, traverseSlices, traverseVariation };

package/dist/index.cjs

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

package/dist/index.d.cts

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

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

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

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

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

@@ -1,7 +0,0 @@
-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, toRecord };
-//# sourceMappingURL=Arrays.d.cts.map

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

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

@@ -1,7 +0,0 @@
-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, toRecord };
-//# sourceMappingURL=Arrays.d.ts.map

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

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

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

@@ -1 +0,0 @@
-{"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/DocumentId.cjs

@@ -1,12 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_validators_function = require('../validators/function.cjs');
-let io_ts = require("io-ts");
-io_ts = require_runtime.__toESM(io_ts);
-
-//#region src/utils/DocumentId.ts
-const DocumentId = require_validators_function.withCustomError(require_validators_function.refineType(io_ts.string, "DocumentId", (s) => s.length === 16), () => "DocumentId must be a 16 character string");
-
-//#endregion
-exports.DocumentId = DocumentId;
-//# sourceMappingURL=DocumentId.cjs.map

package/dist/utils/DocumentId.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"DocumentId.cjs","names":["withCustomError","refineType","t"],"sources":["../../src/utils/DocumentId.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { refineType, withCustomError } from \"../validators/function\"\n\nexport const DocumentId = withCustomError(\n\trefineType(t.string, \"DocumentId\", (s) => s.length === 16),\n\t() => \"DocumentId must be a 16 character string\",\n)\n"],"mappings":";;;;;;;AAIA,MAAa,aAAaA,4CACzBC,uCAAWC,MAAE,QAAQ,eAAe,MAAM,EAAE,WAAW,GAAG,QACpD,2CACN"}

package/dist/utils/DocumentId.d.cts

@@ -1,7 +0,0 @@
-import * as t from "io-ts";
-
-//#region src/utils/DocumentId.d.ts
-declare const DocumentId: t.Type<string, string, unknown>;
-//#endregion
-export { DocumentId };
-//# sourceMappingURL=DocumentId.d.cts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DocumentId.d.cts","names":[],"sources":["../../src/utils/DocumentId.ts"],"mappings":";;;cAIa,UAAA,EAAU,CAAA,CAAA,IAAA"}

package/dist/utils/DocumentId.d.ts

@@ -1,7 +0,0 @@
-import * as t from "io-ts";
-
-//#region src/utils/DocumentId.d.ts
-declare const DocumentId: t.Type<string, string, unknown>;
-//#endregion
-export { DocumentId };
-//# sourceMappingURL=DocumentId.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"DocumentId.d.ts","names":[],"sources":["../../src/utils/DocumentId.ts"],"mappings":";;;cAIa,UAAA,EAAU,CAAA,CAAA,IAAA"}

package/dist/utils/DocumentId.js

@@ -1,9 +0,0 @@
-import { refineType, withCustomError } from "../validators/function.js";
-import * as t from "io-ts";
-
-//#region src/utils/DocumentId.ts
-const DocumentId = withCustomError(refineType(t.string, "DocumentId", (s) => s.length === 16), () => "DocumentId must be a 16 character string");
-
-//#endregion
-export { DocumentId };
-//# sourceMappingURL=DocumentId.js.map

package/dist/utils/DocumentId.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DocumentId.js","names":[],"sources":["../../src/utils/DocumentId.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { refineType, withCustomError } from \"../validators/function\"\n\nexport const DocumentId = withCustomError(\n\trefineType(t.string, \"DocumentId\", (s) => s.length === 16),\n\t() => \"DocumentId must be a 16 character string\",\n)\n"],"mappings":";;;;AAIA,MAAa,aAAa,gBACzB,WAAW,EAAE,QAAQ,eAAe,MAAM,EAAE,WAAW,GAAG,QACpD,2CACN"}

package/dist/utils/Fields.cjs

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

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

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

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

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

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

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

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