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

package/dist/content/Document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Document.d.ts","names":[],"sources":["../../src/content/Document.ts"],"mappings":";;;;;;;;;;;;;cA8Ca,QAAA,EAAQ,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,IAAA,2BAAA,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,IAAA,CAAA,YAAA,EAAA,YAAA,YAAA,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,MAAA,CAAA,CAAA,CAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACT,QAAA,GAAW,CAAA,CAAE,MAAA,QAAc,QAAA;AAAA,cAEjC,eAAA,EAAe,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,IAAA,2BAAA,CAAA,CAAA,QAAA;AAAA,KAChB,cAAA,GAAiB,CAAA,CAAE,MAAA,QAAc,eAAA;AAAA,iBA8C7B,eAAA,CAAgB,IAAA;EAAA,CAAS,CAAA;AAAA;EACjC,KAAA,EAAO,GAAA,SAAY,gBAAA;EACnB,OAAA,EAAS,OAAA,CAAQ,MAAA,CAAO,SAAA;EACxB,IAAA,EAAM,GAAA;EACN,KAAA,EAAO,aAAA;EACP,GAAA;AAAA;AAAA,iBAsDQ,mBAAA,CACR,SAAA,WACA,UAAA,EACG,gBAAA;EAEA,YAAA;EACA,MAAA,EAAQ,MAAA,SAAe,YAAA;AAAA,IAExB,QAAA;AAAA,iBAeM,sBAAA,CAAuB,QAAA,EAAU,QAAA,GAAW,cAAA;AAAA,cAKxC,cAAA;sBA9HD,gBAAA,cAA4B,OAAA,GAC7B,gBAAA,gBAA2B,CAAA,CAAA,IAAA;IAAA,aAAX,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8IX,6BAAA,CACf,UAAA,EACG,gBAAA;EAEA,YAAA;EACA,MAAA,EAAQ,MAAA,SAAe,YAAA;AAAA,GAE1B,QAAA,EAAU,QAAA,GACR,QAAA;;;;;;;;;;iBA0Ca,gBAAA,CAAA;EACf,QAAA;EACA;AAAA;EAEA,QAAA,EAAU,QAAA;EACV,UAAA,GACG,gBAAA;IAEA,YAAA;IACA,MAAA,EAAQ,MAAA,SAAe,YAAA;EAAA;AAAA;EAMlB,eAAA;EAAA;AAAA;EAIP,eAAA,GAAkB,uBAAA;EAClB,cAAA,GAAiB,sBAAA;AAAA,MACd,QAAA;AAAA,iBAmFW,cAAA,WAAyB,aAAA,CAAA,CACxC,QAAA,EAAU,QAAA,EACV,EAAA,GAAK,OAAA,EAAS,aAAA,EAAe,IAAA,EAAM,WAAA,KAAgB,OAAA,IAAW,CAAA,GAC5D,MAAA,SAAe,CAAA;AAAA,iBAaF,eAAA,CACf,QAAA,EAAU,QAAA,EACV,UAAA,EACG,gBAAA;EAEA,YAAA;EACA,MAAA,EAAQ,MAAA,SAAe,YAAA;AAAA;EAAA,aAAT,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBF,yBAAA,CAAA;EACf,QAAA;EACA;AAAA;EAEA,QAAA,EAAU,QAAA;EACV,UAAA,EACG,gBAAA;IAEA,YAAA;IACA,MAAA,EAAQ,MAAA,SAAe,YAAA;EAAA;AAAA;EAKlB,eAAA;EAAA;AAAA;EAIP,eAAA,EAAiB,gCAAA;EACjB,cAAA,EAAgB,+BAAA;AAAA,MACb,QAAA"}

package/dist/content/Document.js

@@ -0,0 +1,315 @@
+import { WidgetKey } from "../common/WidgetKey.js";
+import "../common/index.js";
+import { UUID } from "../common/UUID.js";
+import { NestableWidget } from "../customtypes/widgets/nestable/NestableWidget.js";
+import { StaticCustomType, collectSharedSlices, flattenSections } from "../customtypes/CustomType.js";
+import "../customtypes/index.js";
+import { ContentPath } from "./utils.js";
+import { FieldOrSliceType, defaultCtx } from "./LegacyContentCtx.js";
+import { isRepeatableContent, traverseRepeatableContent, traverseRepeatableContentWithModel } from "./fields/nestable/RepeatableContent.js";
+import { isTableContent, traverseTableContent, traverseTableContentWithModel } from "./fields/nestable/TableContent.js";
+import { NestableContentDefaultValue, isNestableContent } from "./fields/nestable/NestableContent.js";
+import { groupContentWithDefaultValues, isGroupContent, traverseGroupContent, traverseGroupContentWithModel } from "./fields/GroupContent.js";
+import { migrateSliceItem } from "./fields/slices/SliceItem.js";
+import { isSlicesContent, slicesContentWithDefaultValues, traverseSlices, traverseSlicesWithModel } from "./fields/slices/SlicesContent.js";
+import { WidgetContent, WidgetLegacy } from "./fields/WidgetContent.js";
+import "./fields/index.js";
+import * as t from "io-ts";
+import { either } from "fp-ts";
+import { isLeft, isRight } from "fp-ts/lib/Either";
+import { pipe } from "fp-ts/lib/function";
+
+//#region src/content/Document.ts
+const Document = t.record(WidgetKey, WidgetContent);
+const legacyDocReader = t.record(WidgetKey, t.unknown);
+/**
+* `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
+* format used by Prismic DB, therefore, this function itself is not "legacy".
+*/
+const DocumentLegacyCodec = (allTypes, allKeys) => {
+	return new t.Type("Document", (u) => !!u && typeof u === "object", (doc) => {
+		return pipe(legacyDocReader.decode(doc), either.map((parsedDoc) => {
+			return Object.entries(parsedDoc).reduce((acc, [widgetKey, widgetValue]) => {
+				const parsedW = WidgetLegacy(defaultCtx(widgetKey, allTypes, allKeys)).decode(widgetValue);
+				if (!parsedW || isLeft(parsedW)) return acc;
+				return {
+					...acc,
+					[widgetKey]: parsedW.right
+				};
+			}, {});
+		}));
+	}, (g) => {
+		return Object.entries(g).reduce((acc, [key, value]) => {
+			const result = WidgetLegacy(defaultCtx(key, allTypes)).encode(value);
+			if (!result) return acc;
+			return {
+				content: {
+					...acc.content,
+					[key]: result.content
+				},
+				types: {
+					...acc.types,
+					...result.types
+				},
+				keys: {
+					...acc.keys,
+					...result.keys
+				}
+			};
+		}, {
+			content: {},
+			types: {},
+			keys: {}
+		});
+	});
+};
+function extractMetadata(data) {
+	const { types, widgets, keys } = Object.entries(data).reduce((acc, [k, v]) => {
+		if (k.endsWith("_TYPE")) {
+			const decodedValue = FieldOrSliceType.decode(v);
+			if (isRight(decodedValue)) return {
+				...acc,
+				types: acc.types.set(k.substring(0, k.length - 5), decodedValue.right)
+			};
+		}
+		if (k.endsWith("_KEY")) {
+			const decodedValue = UUID.decode(v);
+			if (isRight(decodedValue)) return {
+				...acc,
+				keys: acc.keys.set(k.substring(0, k.length - 4), decodedValue.right)
+			};
+		}
+		if (!k.endsWith("_POSITION") && !k.endsWith("_TYPE") && !k.endsWith("_KEY")) return {
+			...acc,
+			widgets: {
+				...acc.widgets,
+				[k]: v
+			}
+		};
+		return acc;
+	}, {
+		types: /* @__PURE__ */ new Map(),
+		widgets: {},
+		keys: /* @__PURE__ */ new Map()
+	});
+	const slugs = data["slugs_INTERNAL"] || [];
+	return {
+		widgets,
+		types,
+		keys,
+		uid: data["uid"],
+		slugs
+	};
+}
+function parseLegacyDocument(legacyDoc, customType) {
+	const result = pipe(t.record(WidgetKey, t.unknown).decode(legacyDoc), either.chain((doc) => {
+		const { types, widgets, keys } = extractMetadata(doc);
+		return DocumentLegacyCodec(types, keys).decode(widgets);
+	}));
+	return isLeft(result) ? void 0 : migrateDocument(result.right, customType);
+}
+function encodeToLegacyDocument(document) {
+	const encoded = DocumentLegacyCodec().encode(document);
+	return {
+		...encoded.content,
+		...encoded.types,
+		...encoded.keys
+	};
+}
+const DocumentLegacy = {
+	_codec: DocumentLegacyCodec,
+	extractMetadata,
+	parse: parseLegacyDocument,
+	encode: encodeToLegacyDocument
+};
+function simplifyCustomType(customType) {
+	return {
+		customTypeId: customType?.id,
+		fields: Object.fromEntries(flattenSections(customType))
+	};
+}
+function fillDocumentWithDefaultValues(customType, document) {
+	const { fields } = customType && StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType;
+	return Object.entries(fields).reduce((updatedDocument, [fieldKey, fieldDef]) => {
+		const fieldContent = document[fieldKey];
+		const updatedField = (() => {
+			switch (fieldDef.type) {
+				case "Group": return isGroupContent(fieldContent) ? groupContentWithDefaultValues(fieldDef, fieldContent) : fieldContent;
+				case "Choice":
+				case "Slices": return isSlicesContent(fieldContent) ? slicesContentWithDefaultValues(fieldDef, fieldContent) : fieldContent;
+				default: return fieldContent === void 0 && NestableWidget.is(fieldDef) ? NestableContentDefaultValue(fieldDef) : fieldContent;
+			}
+		})();
+		return updatedField ? {
+			...updatedDocument,
+			[fieldKey]: updatedField
+		} : updatedDocument;
+	}, document);
+}
+/**
+* @param model: Can be optional if we simply want to loop through the content
+*   without any consideration for the attached model
+* @param document: The content we actually want to iterate on in an immutable fashion
+* @param transform: A user function that provides a way to transform any kind
+*   of content wherever it is in a structured Prismic object content.
+* @returns A transformed document with the user's transformation applied with
+*   the transform function
+*/
+function traverseDocument({ document, customType }) {
+	const model = customType && StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType;
+	return ({ transformWidget = ({ content }) => content, transformSlice = ({ content }) => content }) => {
+		const fieldModels = model && Object.entries(model.fields).reduce((acc, [key, def]) => ({
+			...acc,
+			[key]: def
+		}), {});
+		return Object.entries(document).reduce((acc, [key, content]) => {
+			const fieldModel = fieldModels && fieldModels[key];
+			const path = ContentPath.make([{
+				key: model?.customTypeId,
+				type: "CustomType"
+			}, {
+				key,
+				type: "Widget"
+			}]);
+			const transformedWidget = (() => {
+				switch (content.__TYPE__) {
+					case "SliceContentType": return traverseSlices({
+						path,
+						key,
+						model: fieldModel?.type === "Slices" || fieldModel?.type === "Choice" ? fieldModel : void 0,
+						content
+					})({
+						transformWidget,
+						transformSlice
+					});
+					case "GroupContentType": return traverseGroupContent({
+						path,
+						key,
+						apiId: key,
+						model: fieldModel?.type === "Group" ? fieldModel : void 0,
+						content
+					})(transformWidget);
+					case "RepeatableContent": return traverseRepeatableContent({
+						path,
+						key,
+						apiId: key,
+						model: fieldModel?.type === "Link" ? fieldModel : void 0,
+						content
+					})(transformWidget);
+					case "TableContent": return traverseTableContent({
+						path,
+						key,
+						apiId: key,
+						model: fieldModel?.type === "Table" ? fieldModel : void 0,
+						content
+					})(transformWidget);
+					default: return transformWidget({
+						path,
+						key,
+						apiId: key,
+						model: fieldModel?.type !== "Group" && fieldModel?.type !== "Slices" && fieldModel?.type !== "Choice" ? fieldModel : void 0,
+						content
+					});
+				}
+			})();
+			return {
+				...acc,
+				...transformedWidget ? { [key]: transformedWidget } : {}
+			};
+		}, {});
+	};
+}
+function collectWidgets(document, is) {
+	const collected = {};
+	traverseDocument({ document })({ transformWidget: ({ content, path }) => {
+		const key = ContentPath.serialize(path);
+		if (is(content, path)) collected[key] = content;
+		return content;
+	} });
+	return collected;
+}
+function migrateDocument(document, customType) {
+	const model = StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType;
+	if (!Object.values(collectSharedSlices(model)).some((slice) => Boolean(slice.legacyPaths))) return document;
+	return traverseDocument({
+		document,
+		customType
+	})({ transformSlice: migrateSliceItem });
+}
+function traverseDocumentWithModel({ document, customType }) {
+	const model = StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType;
+	return ({ transformWidget, transformSlice }) => {
+		return Object.entries(model.fields).reduce((acc, [key, fieldModel]) => {
+			const content = document[key];
+			const path = ContentPath.make([{
+				key: model.customTypeId,
+				type: "CustomType"
+			}, {
+				key,
+				type: "Widget"
+			}]);
+			const transformedWidget = (() => {
+				switch (fieldModel.type) {
+					case "Choice":
+					case "Slices": return traverseSlicesWithModel({
+						path,
+						key,
+						model: fieldModel,
+						content: isSlicesContent(content) ? content : void 0
+					})({
+						transformWidget,
+						transformSlice
+					});
+					case "Group": return traverseGroupContentWithModel({
+						path,
+						key,
+						model: fieldModel,
+						content: isGroupContent(content) ? content : void 0
+					})(transformWidget);
+					case "Link":
+						if (fieldModel.config?.repeat === true) return traverseRepeatableContentWithModel({
+							path,
+							key,
+							model: fieldModel,
+							content: isRepeatableContent(content) ? content : void 0
+						})(transformWidget);
+						return transformWidget({
+							path,
+							key,
+							apiId: key,
+							model: fieldModel,
+							content: isNestableContent(content) ? content : void 0
+						});
+					case "Table": return traverseTableContentWithModel({
+						path,
+						key,
+						model: fieldModel,
+						content: isTableContent(content) ? content : void 0
+					})(transformWidget);
+					case "UID": return transformWidget({
+						path,
+						key,
+						apiId: key,
+						model: fieldModel,
+						content
+					});
+					default: return transformWidget({
+						path,
+						key,
+						apiId: key,
+						model: fieldModel,
+						content: isNestableContent(content) ? content : void 0
+					});
+				}
+			})();
+			return {
+				...acc,
+				...transformedWidget ? { [key]: transformedWidget } : {}
+			};
+		}, {});
+	};
+}
+
+//#endregion
+export { Document, DocumentLegacy, collectWidgets, fillDocumentWithDefaultValues, migrateDocument, traverseDocument, traverseDocumentWithModel };
+//# sourceMappingURL=Document.js.map

package/dist/content/Document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Document.js","names":[],"sources":["../../src/content/Document.ts"],"sourcesContent":["import { either } from \"fp-ts\"\nimport { isLeft, isRight } from \"fp-ts/lib/Either\"\nimport { pipe } from \"fp-ts/lib/function\"\nimport * as t from \"io-ts\"\n\nimport { WidgetKey } from \"../common\"\nimport { UUID } from \"../common/UUID\"\nimport {\n\ttype StaticWidget,\n\tcollectSharedSlices,\n\tflattenSections,\n\tNestableWidget,\n\tStaticCustomType,\n} from \"../customtypes\"\nimport {\n\tgroupContentWithDefaultValues,\n\tisGroupContent,\n\tisNestableContent,\n\tisRepeatableContent,\n\tisSlicesContent,\n\tisTableContent,\n\tmigrateSliceItem,\n\tNestableContentDefaultValue,\n\tslicesContentWithDefaultValues,\n\ttraverseGroupContent,\n\ttraverseGroupContentWithModel,\n\ttraverseRepeatableContent,\n\ttraverseRepeatableContentWithModel,\n\ttraverseSlices,\n\ttraverseSlicesWithModel,\n\ttraverseTableContent,\n\ttraverseTableContentWithModel,\n\tWidgetContent,\n\tWidgetLegacy,\n} from \"./fields\"\nimport type { LegacyContentCtx, WithTypes } from \"./LegacyContentCtx\";\nimport { defaultCtx, FieldOrSliceType } from \"./LegacyContentCtx\"\nimport type {\n\tTraverseSliceContentFn,\n\tTraverseSliceContentWithModelFn,\n\tTraverseWidgetContentFn,\n\tTraverseWidgetContentWithModelFn} from \"./utils\";\nimport {\n\tContentPath\n} from \"./utils\"\n\nexport const Document = t.record(WidgetKey, WidgetContent)\nexport type Document = t.TypeOf<typeof Document>\n\nconst legacyDocReader = t.record(WidgetKey, t.unknown)\ntype DocumentLegacy = t.TypeOf<typeof legacyDocReader>\n\n/**\n * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy\n * format used by Prismic DB, therefore, this function itself is not \"legacy\".\n */\nconst DocumentLegacyCodec = (\n\tallTypes?: LegacyContentCtx[\"allTypes\"],\n\tallKeys?: LegacyContentCtx[\"allKeys\"],\n) => {\n\treturn new t.Type<Document, WithTypes<DocumentLegacy>, unknown>(\n\t\t\"Document\",\n\t\t(u): u is Document => !!u && typeof u === \"object\",\n\t\t(doc) => {\n\t\t\treturn pipe(\n\t\t\t\tlegacyDocReader.decode(doc),\n\t\t\t\teither.map((parsedDoc) => {\n\t\t\t\t\treturn Object.entries(parsedDoc).reduce((acc, [widgetKey, widgetValue]) => {\n\t\t\t\t\t\tconst widgetCtx = defaultCtx(widgetKey, allTypes, allKeys)\n\t\t\t\t\t\tconst parsedW = WidgetLegacy(widgetCtx).decode(widgetValue)\n\t\t\t\t\t\tif (!parsedW || isLeft(parsedW)) return acc\n\n\t\t\t\t\t\treturn { ...acc, [widgetKey]: parsedW.right }\n\t\t\t\t\t}, {})\n\t\t\t\t}),\n\t\t\t)\n\t\t},\n\t\t(g: Document) => {\n\t\t\treturn Object.entries(g).reduce(\n\t\t\t\t(acc, [key, value]) => {\n\t\t\t\t\tconst widgetCtx = defaultCtx(key, allTypes)\n\t\t\t\t\tconst result = WidgetLegacy(widgetCtx).encode(value)\n\t\t\t\t\tif (!result) return acc\n\n\t\t\t\t\treturn {\n\t\t\t\t\t\tcontent: { ...acc.content, [key]: result.content },\n\t\t\t\t\t\ttypes: { ...acc.types, ...result.types },\n\t\t\t\t\t\tkeys: { ...acc.keys, ...result.keys },\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t{ content: {}, types: {}, keys: {} },\n\t\t\t)\n\t\t},\n\t)\n}\n\nfunction extractMetadata(data: { [p: string]: unknown }): {\n\ttypes: Map<string, FieldOrSliceType>\n\twidgets: Partial<Record<WidgetKey, unknown>>\n\tkeys: Map<string, string>\n\tslugs: ReadonlyArray<string>\n\tuid: string | undefined\n} {\n\tconst fields: [string, unknown][] = Object.entries(data)\n\n\tconst { types, widgets, keys } = fields.reduce(\n\t\t(acc, [k, v]) => {\n\t\t\tif (k.endsWith(\"_TYPE\")) {\n\t\t\t\tconst decodedValue = FieldOrSliceType.decode(v)\n\t\t\t\tif (isRight(decodedValue)) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t...acc,\n\t\t\t\t\t\ttypes: acc.types.set(k.substring(0, k.length - 5), decodedValue.right),\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (k.endsWith(\"_KEY\")) {\n\t\t\t\tconst decodedValue = UUID.decode(v)\n\t\t\t\tif (isRight(decodedValue)) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\t...acc,\n\t\t\t\t\t\tkeys: acc.keys.set(k.substring(0, k.length - 4), decodedValue.right),\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!k.endsWith(\"_POSITION\") && !k.endsWith(\"_TYPE\") && !k.endsWith(\"_KEY\")) {\n\t\t\t\treturn {\n\t\t\t\t\t...acc,\n\t\t\t\t\twidgets: {\n\t\t\t\t\t\t...acc.widgets,\n\t\t\t\t\t\t[k]: v,\n\t\t\t\t\t},\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn acc\n\t\t},\n\t\t{\n\t\t\ttypes: new Map<string, FieldOrSliceType>(),\n\t\t\twidgets: {},\n\t\t\tkeys: new Map<string, string>(),\n\t\t},\n\t)\n\n\tconst slugs = (data[\"slugs_INTERNAL\"] as string[]) || []\n\tconst uid = data[\"uid\"] as string | undefined\n\n\treturn {\n\t\twidgets,\n\t\ttypes,\n\t\tkeys,\n\t\tuid,\n\t\tslugs,\n\t}\n}\n\nfunction parseLegacyDocument(\n\tlegacyDoc: unknown,\n\tcustomType:\n\t\t| StaticCustomType\n\t\t| {\n\t\t\t\tcustomTypeId: string\n\t\t\t\tfields: Record<string, StaticWidget>\n\t\t  },\n): Document | undefined {\n\tconst result = pipe(\n\t\t// ensure it's the right document format first\n\t\tt.record(WidgetKey, t.unknown).decode(legacyDoc),\n\t\teither.chain((doc) => {\n\t\t\t// extract all metadata, meaning all _TYPES keys from legacy format + the widgets as unknown\n\t\t\tconst { types, widgets, keys } = extractMetadata(doc)\n\t\t\t// parse the actual widgets\n\t\t\treturn DocumentLegacyCodec(types, keys).decode(widgets)\n\t\t}),\n\t)\n\n\treturn isLeft(result) ? undefined : migrateDocument(result.right, customType)\n}\n\nfunction encodeToLegacyDocument(document: Document): DocumentLegacy {\n\tconst encoded = DocumentLegacyCodec().encode(document)\n\treturn { ...encoded.content, ...encoded.types, ...encoded.keys }\n}\n\nexport const DocumentLegacy = {\n\t_codec: DocumentLegacyCodec,\n\textractMetadata,\n\tparse: parseLegacyDocument,\n\tencode: encodeToLegacyDocument,\n}\n\nfunction simplifyCustomType(customType: StaticCustomType): {\n\tcustomTypeId: string\n\tfields: Record<string, StaticWidget>\n} {\n\treturn {\n\t\tcustomTypeId: customType?.id,\n\t\tfields: Object.fromEntries(flattenSections(customType)),\n\t}\n}\n\nexport function fillDocumentWithDefaultValues(\n\tcustomType:\n\t\t| StaticCustomType\n\t\t| {\n\t\t\t\tcustomTypeId: string\n\t\t\t\tfields: Record<string, StaticWidget>\n\t\t  },\n\tdocument: Document,\n): Document {\n\tconst { fields } =\n\t\tcustomType && StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType\n\n\treturn Object.entries(fields).reduce<Document>((updatedDocument, [fieldKey, fieldDef]) => {\n\t\tconst fieldContent = document[fieldKey]\n\n\t\tconst updatedField = (() => {\n\t\t\tswitch (fieldDef.type) {\n\t\t\t\tcase \"Group\":\n\t\t\t\t\treturn isGroupContent(fieldContent)\n\t\t\t\t\t\t? groupContentWithDefaultValues(fieldDef, fieldContent)\n\t\t\t\t\t\t: fieldContent\n\t\t\t\tcase \"Choice\":\n\t\t\t\tcase \"Slices\":\n\t\t\t\t\treturn isSlicesContent(fieldContent)\n\t\t\t\t\t\t? slicesContentWithDefaultValues(fieldDef, fieldContent)\n\t\t\t\t\t\t: fieldContent\n\t\t\t\tdefault:\n\t\t\t\t\treturn fieldContent === undefined && NestableWidget.is(fieldDef)\n\t\t\t\t\t\t? NestableContentDefaultValue(fieldDef)\n\t\t\t\t\t\t: fieldContent\n\t\t\t}\n\t\t})()\n\n\t\treturn updatedField\n\t\t\t? {\n\t\t\t\t\t...updatedDocument,\n\t\t\t\t\t[fieldKey]: updatedField,\n\t\t\t\t}\n\t\t\t: updatedDocument\n\t}, document)\n}\n/**\n * @param model: Can be optional if we simply want to loop through the content\n *   without any consideration for the attached model\n * @param document: The content we actually want to iterate on in an immutable fashion\n * @param transform: A user function that provides a way to transform any kind\n *   of content wherever it is in a structured Prismic object content.\n * @returns A transformed document with the user's transformation applied with\n *   the transform function\n */\nexport function traverseDocument({\n\tdocument,\n\tcustomType,\n}: {\n\tdocument: Document\n\tcustomType?:\n\t\t| StaticCustomType\n\t\t| {\n\t\t\t\tcustomTypeId: string\n\t\t\t\tfields: Record<string, StaticWidget>\n\t\t  }\n\t\t| undefined\n}) {\n\tconst model =\n\t\tcustomType && StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType\n\treturn ({\n\t\ttransformWidget = ({ content }) => content,\n\t\ttransformSlice = ({ content }) => content,\n\t}: {\n\t\ttransformWidget?: TraverseWidgetContentFn\n\t\ttransformSlice?: TraverseSliceContentFn\n\t}): Document => {\n\t\tconst fieldModels =\n\t\t\tmodel &&\n\t\t\tObject.entries(model.fields).reduce<Record<string, StaticWidget>>(\n\t\t\t\t(acc, [key, def]) => ({ ...acc, [key]: def }),\n\t\t\t\t{},\n\t\t\t)\n\n\t\treturn Object.entries(document).reduce((acc, [key, content]) => {\n\t\t\tconst fieldModel = fieldModels && fieldModels[key]\n\n\t\t\tconst path = ContentPath.make([\n\t\t\t\t{ key: model?.customTypeId, type: \"CustomType\" },\n\t\t\t\t{ key, type: \"Widget\" },\n\t\t\t])\n\n\t\t\tconst transformedWidget = (() => {\n\t\t\t\tswitch (content.__TYPE__) {\n\t\t\t\t\tcase \"SliceContentType\":\n\t\t\t\t\t\treturn traverseSlices({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tmodel:\n\t\t\t\t\t\t\t\tfieldModel?.type === \"Slices\" || fieldModel?.type === \"Choice\"\n\t\t\t\t\t\t\t\t\t? fieldModel\n\t\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t\tcontent,\n\t\t\t\t\t\t})({ transformWidget, transformSlice })\n\t\t\t\t\tcase \"GroupContentType\":\n\t\t\t\t\t\treturn traverseGroupContent({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tapiId: key,\n\t\t\t\t\t\t\tmodel: fieldModel?.type === \"Group\" ? fieldModel : undefined,\n\t\t\t\t\t\t\tcontent,\n\t\t\t\t\t\t})(transformWidget)\n\t\t\t\t\tcase \"RepeatableContent\":\n\t\t\t\t\t\treturn traverseRepeatableContent({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tapiId: key,\n\t\t\t\t\t\t\tmodel: fieldModel?.type === \"Link\" ? fieldModel : undefined,\n\t\t\t\t\t\t\tcontent,\n\t\t\t\t\t\t})(transformWidget)\n\t\t\t\t\tcase \"TableContent\":\n\t\t\t\t\t\treturn traverseTableContent({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tapiId: key,\n\t\t\t\t\t\t\tmodel: fieldModel?.type === \"Table\" ? fieldModel : undefined,\n\t\t\t\t\t\t\tcontent,\n\t\t\t\t\t\t})(transformWidget)\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn transformWidget({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tapiId: key,\n\t\t\t\t\t\t\tmodel:\n\t\t\t\t\t\t\t\tfieldModel?.type !== \"Group\" &&\n\t\t\t\t\t\t\t\tfieldModel?.type !== \"Slices\" &&\n\t\t\t\t\t\t\t\tfieldModel?.type !== \"Choice\"\n\t\t\t\t\t\t\t\t\t? fieldModel\n\t\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t\tcontent,\n\t\t\t\t\t\t})\n\t\t\t\t}\n\t\t\t})()\n\n\t\t\treturn {\n\t\t\t\t...acc,\n\t\t\t\t...(transformedWidget ? { [key]: transformedWidget } : {}),\n\t\t\t}\n\t\t}, {})\n\t}\n}\n\n// /**\n//  * The goal is to be able to collect all widgets or slices of a given type at any level of nesting inside a prismic content\n//  *\n//  * @param document parsed prismic content\n//  * @param is typeguard to match specifically the type of widget we want to collect\n//  * @returns a record containing the path of the widget as key and the typed collected content as value\n//  */\nexport function collectWidgets<W extends WidgetContent>(\n\tdocument: Document,\n\tis: (content: WidgetContent, path: ContentPath) => content is W,\n): Record<string, W> {\n\tconst collected: Record<string, W> = {}\n\n\ttraverseDocument({ document })({\n\t\ttransformWidget: ({ content, path }) => {\n\t\t\tconst key = ContentPath.serialize(path)\n\t\t\tif (is(content, path)) collected[key] = content\n\t\t\treturn content\n\t\t},\n\t})\n\treturn collected\n}\n\nexport function migrateDocument(\n\tdocument: Document,\n\tcustomType:\n\t\t| StaticCustomType\n\t\t| {\n\t\t\t\tcustomTypeId: string\n\t\t\t\tfields: Record<string, StaticWidget>\n\t\t  },\n) {\n\tconst model = StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType\n\tconst needsMigration = Object.values(collectSharedSlices(model)).some((slice) =>\n\t\tBoolean(slice.legacyPaths),\n\t)\n\n\tif (!needsMigration) return document\n\n\treturn traverseDocument({\n\t\tdocument,\n\t\tcustomType,\n\t})({\n\t\ttransformSlice: migrateSliceItem,\n\t})\n}\n\nexport function traverseDocumentWithModel({\n\tdocument,\n\tcustomType,\n}: {\n\tdocument: Document\n\tcustomType:\n\t\t| StaticCustomType\n\t\t| {\n\t\t\t\tcustomTypeId: string\n\t\t\t\tfields: Record<string, StaticWidget>\n\t\t  }\n}) {\n\tconst model = StaticCustomType.is(customType) ? simplifyCustomType(customType) : customType\n\n\treturn ({\n\t\ttransformWidget,\n\t\ttransformSlice,\n\t}: {\n\t\ttransformWidget: TraverseWidgetContentWithModelFn\n\t\ttransformSlice: TraverseSliceContentWithModelFn\n\t}): Document => {\n\t\treturn Object.entries(model.fields).reduce<Document>((acc, [key, fieldModel]) => {\n\t\t\tconst content = document[key]\n\n\t\t\tconst path = ContentPath.make([\n\t\t\t\t{ key: model.customTypeId, type: \"CustomType\" },\n\t\t\t\t{ key, type: \"Widget\" },\n\t\t\t])\n\n\t\t\tconst transformedWidget = (() => {\n\t\t\t\tswitch (fieldModel.type) {\n\t\t\t\t\tcase \"Choice\":\n\t\t\t\t\tcase \"Slices\": {\n\t\t\t\t\t\tconst slicesContent = isSlicesContent(content) ? content : undefined\n\t\t\t\t\t\treturn traverseSlicesWithModel({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tmodel: fieldModel,\n\t\t\t\t\t\t\tcontent: slicesContent,\n\t\t\t\t\t\t})({ transformWidget, transformSlice })\n\t\t\t\t\t}\n\t\t\t\t\tcase \"Group\": {\n\t\t\t\t\t\tconst groupContent = isGroupContent(content) ? content : undefined\n\t\t\t\t\t\treturn traverseGroupContentWithModel({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tmodel: fieldModel,\n\t\t\t\t\t\t\tcontent: groupContent,\n\t\t\t\t\t\t})(transformWidget)\n\t\t\t\t\t}\n\t\t\t\t\tcase \"Link\": {\n\t\t\t\t\t\tif (fieldModel.config?.repeat === true) {\n\t\t\t\t\t\t\tconst repeatableContent = isRepeatableContent(content) ? content : undefined\n\t\t\t\t\t\t\treturn traverseRepeatableContentWithModel({\n\t\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\t\tmodel: fieldModel,\n\t\t\t\t\t\t\t\tcontent: repeatableContent,\n\t\t\t\t\t\t\t})(transformWidget)\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst nestableContent = isNestableContent(content) ? content : undefined\n\t\t\t\t\t\treturn transformWidget({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tapiId: key,\n\t\t\t\t\t\t\tmodel: fieldModel,\n\t\t\t\t\t\t\tcontent: nestableContent,\n\t\t\t\t\t\t})\n\t\t\t\t\t}\n\t\t\t\t\tcase \"Table\": {\n\t\t\t\t\t\tconst tableContent = isTableContent(content) ? content : undefined\n\t\t\t\t\t\treturn traverseTableContentWithModel({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tmodel: fieldModel,\n\t\t\t\t\t\t\tcontent: tableContent,\n\t\t\t\t\t\t})(transformWidget)\n\t\t\t\t\t}\n\t\t\t\t\tcase \"UID\": {\n\t\t\t\t\t\treturn transformWidget({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tapiId: key,\n\t\t\t\t\t\t\tmodel: fieldModel,\n\t\t\t\t\t\t\tcontent,\n\t\t\t\t\t\t})\n\t\t\t\t\t}\n\t\t\t\t\tdefault: {\n\t\t\t\t\t\tconst nestableContent = isNestableContent(content) ? content : undefined\n\t\t\t\t\t\treturn transformWidget({\n\t\t\t\t\t\t\tpath,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\tapiId: key,\n\t\t\t\t\t\t\tmodel: fieldModel,\n\t\t\t\t\t\t\tcontent: nestableContent,\n\t\t\t\t\t\t})\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t})()\n\n\t\t\treturn {\n\t\t\t\t...acc,\n\t\t\t\t...(transformedWidget ? { [key]: transformedWidget } : {}),\n\t\t\t}\n\t\t}, {})\n\t}\n}\n"],"mappings":"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"}

package/dist/content/LegacyContentCtx.cjs

@@ -0,0 +1,79 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_SlicesTypes = require('../customtypes/widgets/slices/SlicesTypes.cjs');
+const require_Widget = require('../customtypes/widgets/Widget.cjs');
+require('../customtypes/widgets/index.cjs');
+let io_ts = require("io-ts");
+io_ts = require_runtime.__toESM(io_ts);
+
+//#region src/content/LegacyContentCtx.ts
+const FieldOrSliceType = io_ts.union([io_ts.union([require_Widget.FieldType, require_SlicesTypes.SlicesTypes]), io_ts.literal("Repeatable.Link")]);
+var LegacyContentCtx = class LegacyContentCtx {
+	fieldKey;
+	prefixedKey;
+	keyOfType;
+	keyOfKey;
+	fieldPath;
+	fieldType;
+	allTypes;
+	allKeys;
+	contentKey;
+	contentPath;
+	fieldContentKey;
+	constructor({ fieldKey, contentKey, contentPath, fieldPath, allTypes, allKeys }) {
+		this.fieldKey = fieldKey;
+		this.contentKey = contentKey || fieldKey;
+		this.fieldPath = fieldPath || [];
+		this.contentPath = contentPath || [];
+		this.allTypes = allTypes || /* @__PURE__ */ new Map();
+		this.allKeys = allKeys || /* @__PURE__ */ new Map();
+		const prefixedKey = Array.of(this.fieldPath, [this.fieldKey]).flat().join(".");
+		const prefixedContentKey = Array.of(this.contentPath, [this.contentKey]).flat().join(".");
+		this.prefixedKey = prefixedKey;
+		this.keyOfType = `${prefixedKey}_TYPE`;
+		this.keyOfKey = `${prefixedContentKey}_KEY`;
+		this.fieldType = this.allTypes.get(this.prefixedKey);
+		this.fieldContentKey = this.allKeys.get(prefixedContentKey) ?? crypto.randomUUID();
+	}
+	withContentKey(contentKey) {
+		return new LegacyContentCtx({
+			...this,
+			contentPath: [...this.contentPath, this.contentKey],
+			contentKey
+		});
+	}
+};
+function getFieldCtx({ fieldKey, contentKey: contentKeyParam, ctx, prefixes }) {
+	return new LegacyContentCtx({
+		fieldKey,
+		contentKey: contentKeyParam || fieldKey,
+		contentPath: [
+			...ctx.contentPath,
+			ctx.contentKey,
+			...prefixes || []
+		],
+		fieldPath: [
+			...ctx.fieldPath,
+			ctx.fieldKey,
+			...prefixes || []
+		],
+		allTypes: ctx.allTypes,
+		allKeys: ctx.allKeys
+	});
+}
+function defaultCtx(key, allTypes = /* @__PURE__ */ new Map(), allKeys = /* @__PURE__ */ new Map()) {
+	return new LegacyContentCtx({
+		fieldKey: key,
+		contentKey: key,
+		contentPath: [],
+		fieldPath: [],
+		allTypes,
+		allKeys
+	});
+}
+
+//#endregion
+exports.FieldOrSliceType = FieldOrSliceType;
+exports.LegacyContentCtx = LegacyContentCtx;
+exports.defaultCtx = defaultCtx;
+exports.getFieldCtx = getFieldCtx;
+//# sourceMappingURL=LegacyContentCtx.cjs.map

package/dist/content/LegacyContentCtx.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegacyContentCtx.cjs","names":["t","FieldType","SlicesTypes"],"sources":["../../src/content/LegacyContentCtx.ts"],"sourcesContent":["import * as t from \"io-ts\"\n\nimport { FieldType, SlicesTypes } from \"../customtypes/widgets\"\n\nexport const FieldOrSliceType = t.union([\n\tt.union([FieldType, SlicesTypes]),\n\tt.literal(\"Repeatable.Link\"),\n])\nexport type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>\n\ninterface LegacyContentCtxParams {\n\tfieldKey: string\n\tcontentKey?: string\n\tfieldPath?: Array<string>\n\tcontentPath?: Array<string>\n\tallTypes?: Map<string, FieldOrSliceType>\n\tallKeys?: Map<string, string>\n}\n\nexport class LegacyContentCtx {\n\tfieldKey: string\n\tprefixedKey: string\n\tkeyOfType: string\n\tkeyOfKey: string\n\tfieldPath: Array<string>\n\tfieldType?: FieldOrSliceType | undefined\n\tallTypes: Map<string, FieldOrSliceType>\n\tallKeys: Map<string, string>\n\tcontentKey: string\n\tcontentPath: Array<string>\n\tfieldContentKey: string\n\n\tconstructor({\n\t\tfieldKey,\n\t\tcontentKey,\n\t\tcontentPath,\n\t\tfieldPath,\n\t\tallTypes,\n\t\tallKeys,\n\t}: LegacyContentCtxParams) {\n\t\tthis.fieldKey = fieldKey\n\t\tthis.contentKey = contentKey || fieldKey\n\t\tthis.fieldPath = fieldPath || []\n\t\tthis.contentPath = contentPath || []\n\t\tthis.allTypes = allTypes || new Map<string, FieldOrSliceType>()\n\t\tthis.allKeys = allKeys || new Map<string, string>()\n\n\t\tconst prefixedKey = Array.of(this.fieldPath, [this.fieldKey]).flat().join(\".\")\n\n\t\tconst prefixedContentKey = Array.of(this.contentPath, [this.contentKey]).flat().join(\".\")\n\n\t\tthis.prefixedKey = prefixedKey\n\t\tthis.keyOfType = `${prefixedKey}_TYPE`\n\t\tthis.keyOfKey = `${prefixedContentKey}_KEY`\n\t\tthis.fieldType = this.allTypes.get(this.prefixedKey)\n\t\tthis.fieldContentKey = this.allKeys.get(prefixedContentKey) ?? crypto.randomUUID()\n\t}\n\n\twithContentKey(contentKey: string): LegacyContentCtx {\n\t\treturn new LegacyContentCtx({\n\t\t\t...this,\n\t\t\tcontentPath: [...this.contentPath, this.contentKey],\n\t\t\tcontentKey,\n\t\t})\n\t}\n}\n\ninterface GetFieldCtxParams {\n\tfieldKey: string\n\tcontentKey?: string\n\tctx: LegacyContentCtx\n\tprefixes?: Array<string>\n}\n\nexport function getFieldCtx({\n\tfieldKey,\n\tcontentKey: contentKeyParam,\n\tctx,\n\tprefixes,\n}: GetFieldCtxParams): LegacyContentCtx {\n\tconst contentKey = contentKeyParam || fieldKey\n\treturn new LegacyContentCtx({\n\t\tfieldKey,\n\t\tcontentKey,\n\t\tcontentPath: [...ctx.contentPath, ctx.contentKey, ...(prefixes || [])],\n\t\tfieldPath: [...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])],\n\t\tallTypes: ctx.allTypes,\n\t\tallKeys: ctx.allKeys,\n\t})\n}\n\nexport function defaultCtx(\n\tkey: string,\n\tallTypes: Map<string, FieldOrSliceType> = new Map(),\n\tallKeys: Map<string, string> = new Map(),\n): LegacyContentCtx {\n\treturn new LegacyContentCtx({\n\t\tfieldKey: key,\n\t\tcontentKey: key,\n\t\tcontentPath: [],\n\t\tfieldPath: [],\n\t\tallTypes,\n\t\tallKeys,\n\t})\n}\n\nexport type WithTypes<T> = {\n\tkeys: Record<string, string>\n\ttypes: Record<string, FieldOrSliceType>\n\tcontent: T\n}\n"],"mappings":";;;;;;;;AAIA,MAAa,mBAAmBA,MAAE,MAAM,CACvCA,MAAE,MAAM,CAACC,0BAAWC,gCAAY,CAAC,EACjCF,MAAE,QAAQ,kBAAkB,CAC5B,CAAC;AAYF,IAAa,mBAAb,MAAa,iBAAiB;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,EACX,UACA,YACA,aACA,WACA,UACA,WAC0B;AAC1B,OAAK,WAAW;AAChB,OAAK,aAAa,cAAc;AAChC,OAAK,YAAY,aAAa,EAAE;AAChC,OAAK,cAAc,eAAe,EAAE;AACpC,OAAK,WAAW,4BAAY,IAAI,KAA+B;AAC/D,OAAK,UAAU,2BAAW,IAAI,KAAqB;EAEnD,MAAM,cAAc,MAAM,GAAG,KAAK,WAAW,CAAC,KAAK,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,IAAI;EAE9E,MAAM,qBAAqB,MAAM,GAAG,KAAK,aAAa,CAAC,KAAK,WAAW,CAAC,CAAC,MAAM,CAAC,KAAK,IAAI;AAEzF,OAAK,cAAc;AACnB,OAAK,YAAY,GAAG,YAAY;AAChC,OAAK,WAAW,GAAG,mBAAmB;AACtC,OAAK,YAAY,KAAK,SAAS,IAAI,KAAK,YAAY;AACpD,OAAK,kBAAkB,KAAK,QAAQ,IAAI,mBAAmB,IAAI,OAAO,YAAY;;CAGnF,eAAe,YAAsC;AACpD,SAAO,IAAI,iBAAiB;GAC3B,GAAG;GACH,aAAa,CAAC,GAAG,KAAK,aAAa,KAAK,WAAW;GACnD;GACA,CAAC;;;AAWJ,SAAgB,YAAY,EAC3B,UACA,YAAY,iBACZ,KACA,YACuC;AAEvC,QAAO,IAAI,iBAAiB;EAC3B;EACA,YAHkB,mBAAmB;EAIrC,aAAa;GAAC,GAAG,IAAI;GAAa,IAAI;GAAY,GAAI,YAAY,EAAE;GAAE;EACtE,WAAW;GAAC,GAAG,IAAI;GAAW,IAAI;GAAU,GAAI,YAAY,EAAE;GAAE;EAChE,UAAU,IAAI;EACd,SAAS,IAAI;EACb,CAAC;;AAGH,SAAgB,WACf,KACA,2BAA0C,IAAI,KAAK,EACnD,0BAA+B,IAAI,KAAK,EACrB;AACnB,QAAO,IAAI,iBAAiB;EAC3B,UAAU;EACV,YAAY;EACZ,aAAa,EAAE;EACf,WAAW,EAAE;EACb;EACA;EACA,CAAC"}

package/dist/content/LegacyContentCtx.d.cts

@@ -0,0 +1,80 @@
+import * as t from "io-ts";
+
+//#region src/content/LegacyContentCtx.d.ts
+declare const FieldOrSliceType: t.UnionC<[t.UnionC<[t.KeyofC<{
+  Color: null;
+  Boolean: null;
+  Number: null;
+  Embed: null;
+  GeoPoint: null;
+  Date: null;
+  Range: null;
+  StructuredText: null;
+  Select: null;
+  Separator: null;
+  Table: null;
+  Text: null;
+  Timestamp: null;
+  Link: null;
+  Image: null;
+  IntegrationFields: null;
+  UID: null;
+  Group: null;
+  Slices: null;
+  Choice: null;
+}>, t.KeyofC<{
+  Slice: null;
+  SharedSlice: null;
+}>]>, t.LiteralC<"Repeatable.Link">]>;
+type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>;
+interface LegacyContentCtxParams {
+  fieldKey: string;
+  contentKey?: string;
+  fieldPath?: Array<string>;
+  contentPath?: Array<string>;
+  allTypes?: Map<string, FieldOrSliceType>;
+  allKeys?: Map<string, string>;
+}
+declare class LegacyContentCtx {
+  fieldKey: string;
+  prefixedKey: string;
+  keyOfType: string;
+  keyOfKey: string;
+  fieldPath: Array<string>;
+  fieldType?: FieldOrSliceType | undefined;
+  allTypes: Map<string, FieldOrSliceType>;
+  allKeys: Map<string, string>;
+  contentKey: string;
+  contentPath: Array<string>;
+  fieldContentKey: string;
+  constructor({
+    fieldKey,
+    contentKey,
+    contentPath,
+    fieldPath,
+    allTypes,
+    allKeys
+  }: LegacyContentCtxParams);
+  withContentKey(contentKey: string): LegacyContentCtx;
+}
+interface GetFieldCtxParams {
+  fieldKey: string;
+  contentKey?: string;
+  ctx: LegacyContentCtx;
+  prefixes?: Array<string>;
+}
+declare function getFieldCtx({
+  fieldKey,
+  contentKey: contentKeyParam,
+  ctx,
+  prefixes
+}: GetFieldCtxParams): LegacyContentCtx;
+declare function defaultCtx(key: string, allTypes?: Map<string, FieldOrSliceType>, allKeys?: Map<string, string>): LegacyContentCtx;
+type WithTypes<T> = {
+  keys: Record<string, string>;
+  types: Record<string, FieldOrSliceType>;
+  content: T;
+};
+//#endregion
+export { FieldOrSliceType, LegacyContentCtx, WithTypes, defaultCtx, getFieldCtx };
+//# sourceMappingURL=LegacyContentCtx.d.cts.map

package/dist/content/LegacyContentCtx.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegacyContentCtx.d.cts","names":[],"sources":["../../src/content/LegacyContentCtx.ts"],"mappings":";;;cAIa,gBAAA,EAAgB,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAIjB,gBAAA,GAAmB,CAAA,CAAE,MAAA,QAAc,gBAAA;AAAA,UAErC,sBAAA;EACT,QAAA;EACA,UAAA;EACA,SAAA,GAAY,KAAA;EACZ,WAAA,GAAc,KAAA;EACd,QAAA,GAAW,GAAA,SAAY,gBAAA;EACvB,OAAA,GAAU,GAAA;AAAA;AAAA,cAGE,gBAAA;EACZ,QAAA;EACA,WAAA;EACA,SAAA;EACA,QAAA;EACA,SAAA,EAAW,KAAA;EACX,SAAA,GAAY,gBAAA;EACZ,QAAA,EAAU,GAAA,SAAY,gBAAA;EACtB,OAAA,EAAS,GAAA;EACT,UAAA;EACA,WAAA,EAAa,KAAA;EACb,eAAA;;IAGC,QAAA;IACA,UAAA;IACA,WAAA;IACA,SAAA;IACA,QAAA;IACA;EAAA,GACE,sBAAA;EAmBH,cAAA,CAAe,UAAA,WAAqB,gBAAA;AAAA;AAAA,UAS3B,iBAAA;EACT,QAAA;EACA,UAAA;EACA,GAAA,EAAK,gBAAA;EACL,QAAA,GAAW,KAAA;AAAA;AAAA,iBAGI,WAAA,CAAA;EACf,QAAA;EACA,UAAA,EAAY,eAAA;EACZ,GAAA;EACA;AAAA,GACE,iBAAA,GAAoB,gBAAA;AAAA,iBAYP,UAAA,CACf,GAAA,UACA,QAAA,GAAU,GAAA,SAAY,gBAAA,GACtB,OAAA,GAAS,GAAA,mBACP,gBAAA;AAAA,KAWS,SAAA;EACX,IAAA,EAAM,MAAA;EACN,KAAA,EAAO,MAAA,SAAe,gBAAA;EACtB,OAAA,EAAS,CAAA;AAAA"}

package/dist/content/LegacyContentCtx.d.ts

@@ -0,0 +1,80 @@
+import * as t from "io-ts";
+
+//#region src/content/LegacyContentCtx.d.ts
+declare const FieldOrSliceType: t.UnionC<[t.UnionC<[t.KeyofC<{
+  Color: null;
+  Boolean: null;
+  Number: null;
+  Embed: null;
+  GeoPoint: null;
+  Date: null;
+  Range: null;
+  StructuredText: null;
+  Select: null;
+  Separator: null;
+  Table: null;
+  Text: null;
+  Timestamp: null;
+  Link: null;
+  Image: null;
+  IntegrationFields: null;
+  UID: null;
+  Group: null;
+  Slices: null;
+  Choice: null;
+}>, t.KeyofC<{
+  Slice: null;
+  SharedSlice: null;
+}>]>, t.LiteralC<"Repeatable.Link">]>;
+type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>;
+interface LegacyContentCtxParams {
+  fieldKey: string;
+  contentKey?: string;
+  fieldPath?: Array<string>;
+  contentPath?: Array<string>;
+  allTypes?: Map<string, FieldOrSliceType>;
+  allKeys?: Map<string, string>;
+}
+declare class LegacyContentCtx {
+  fieldKey: string;
+  prefixedKey: string;
+  keyOfType: string;
+  keyOfKey: string;
+  fieldPath: Array<string>;
+  fieldType?: FieldOrSliceType | undefined;
+  allTypes: Map<string, FieldOrSliceType>;
+  allKeys: Map<string, string>;
+  contentKey: string;
+  contentPath: Array<string>;
+  fieldContentKey: string;
+  constructor({
+    fieldKey,
+    contentKey,
+    contentPath,
+    fieldPath,
+    allTypes,
+    allKeys
+  }: LegacyContentCtxParams);
+  withContentKey(contentKey: string): LegacyContentCtx;
+}
+interface GetFieldCtxParams {
+  fieldKey: string;
+  contentKey?: string;
+  ctx: LegacyContentCtx;
+  prefixes?: Array<string>;
+}
+declare function getFieldCtx({
+  fieldKey,
+  contentKey: contentKeyParam,
+  ctx,
+  prefixes
+}: GetFieldCtxParams): LegacyContentCtx;
+declare function defaultCtx(key: string, allTypes?: Map<string, FieldOrSliceType>, allKeys?: Map<string, string>): LegacyContentCtx;
+type WithTypes<T> = {
+  keys: Record<string, string>;
+  types: Record<string, FieldOrSliceType>;
+  content: T;
+};
+//#endregion
+export { FieldOrSliceType, LegacyContentCtx, WithTypes, defaultCtx, getFieldCtx };
+//# sourceMappingURL=LegacyContentCtx.d.ts.map

package/dist/content/LegacyContentCtx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegacyContentCtx.d.ts","names":[],"sources":["../../src/content/LegacyContentCtx.ts"],"mappings":";;;cAIa,gBAAA,EAAgB,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,MAAA,EAAA,CAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAIjB,gBAAA,GAAmB,CAAA,CAAE,MAAA,QAAc,gBAAA;AAAA,UAErC,sBAAA;EACT,QAAA;EACA,UAAA;EACA,SAAA,GAAY,KAAA;EACZ,WAAA,GAAc,KAAA;EACd,QAAA,GAAW,GAAA,SAAY,gBAAA;EACvB,OAAA,GAAU,GAAA;AAAA;AAAA,cAGE,gBAAA;EACZ,QAAA;EACA,WAAA;EACA,SAAA;EACA,QAAA;EACA,SAAA,EAAW,KAAA;EACX,SAAA,GAAY,gBAAA;EACZ,QAAA,EAAU,GAAA,SAAY,gBAAA;EACtB,OAAA,EAAS,GAAA;EACT,UAAA;EACA,WAAA,EAAa,KAAA;EACb,eAAA;;IAGC,QAAA;IACA,UAAA;IACA,WAAA;IACA,SAAA;IACA,QAAA;IACA;EAAA,GACE,sBAAA;EAmBH,cAAA,CAAe,UAAA,WAAqB,gBAAA;AAAA;AAAA,UAS3B,iBAAA;EACT,QAAA;EACA,UAAA;EACA,GAAA,EAAK,gBAAA;EACL,QAAA,GAAW,KAAA;AAAA;AAAA,iBAGI,WAAA,CAAA;EACf,QAAA;EACA,UAAA,EAAY,eAAA;EACZ,GAAA;EACA;AAAA,GACE,iBAAA,GAAoB,gBAAA;AAAA,iBAYP,UAAA,CACf,GAAA,UACA,QAAA,GAAU,GAAA,SAAY,gBAAA,GACtB,OAAA,GAAS,GAAA,mBACP,gBAAA;AAAA,KAWS,SAAA;EACX,IAAA,EAAM,MAAA;EACN,KAAA,EAAO,MAAA,SAAe,gBAAA;EACtB,OAAA,EAAS,CAAA;AAAA"}