@prismicio/types-internal 1.5.2 → 2.0.0-alpha.0

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

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = void 0;
+exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = exports.SlicesFieldType = exports.LegacySlicesFieldType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
-const widgets_1 = require("../../../documents/widgets");
+const common_1 = require("../../../common");
 const validators_1 = require("../../../validators");
-const WidgetTypes_1 = require("../WidgetTypes");
 const CompositeSlice_1 = (0, tslib_1.__importDefault)(require("./CompositeSlice"));
 const LegacySlice_1 = (0, tslib_1.__importDefault)(require("./LegacySlice"));
 const SharedSlice_1 = require("./SharedSlice");
 const SharedSliceRef_1 = (0, tslib_1.__importDefault)(require("./SharedSliceRef"));
-const SlicesTypes_1 = require("./SlicesTypes");
+exports.LegacySlicesFieldType = "Choice";
+exports.SlicesFieldType = "Slices";
 exports.SlicesLabels = t.union([
     t.record(t.string, t.readonlyArray(t.exact(t.intersection([
         t.type({
@@ -26,7 +26,7 @@ function slicesConfigReader(codec) {
     return t.exact(t.partial({
         label: validators_1.StringOrNull,
         labels: exports.SlicesLabels,
-        choices: t.record(widgets_1.WidgetKey, t.union([LegacySlice_1.default, CompositeSlice_1.default, codec])),
+        choices: t.record(common_1.WidgetKey, t.union([LegacySlice_1.default, CompositeSlice_1.default, codec])),
     }));
 }
 exports.slicesConfigReader = slicesConfigReader;
@@ -35,7 +35,7 @@ exports.DynamicSlicesConfig = slicesConfigReader(SharedSliceRef_1.default);
 const SlicesConfig = {
     toStatic(config, sharedSlices) {
         const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
-            if (slice.type === SlicesTypes_1.SlicesTypes.SharedSlice) {
+            if (slice.type === "SharedSlice") {
                 const sharedSlice = sharedSlices.get(ref);
                 if (sharedSlice)
                     return { ...acc, [ref]: sharedSlice };
@@ -53,8 +53,8 @@ function slicesReader(codec) {
     return t.exact(t.intersection([
         t.type({
             type: t.union([
-                t.literal(WidgetTypes_1.WidgetTypes.Slices),
-                t.literal(WidgetTypes_1.WidgetTypes.LegacySlices),
+                t.literal(exports.SlicesFieldType),
+                t.literal(exports.LegacySlicesFieldType),
             ]),
         }),
         t.partial({

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

@@ -1,5 +1,6 @@
-export declare const SlicesTypes: {
-    readonly Slice: "Slice";
-    readonly SharedSlice: "SharedSlice";
-};
-export declare type SlicesTypes = typeof SlicesTypes[keyof typeof SlicesTypes];
+import * as t from "io-ts";
+export declare const SlicesTypes: t.KeyofC<{
+    Slice: null;
+    SharedSlice: null;
+}>;
+export declare type SlicesTypes = t.TypeOf<typeof SlicesTypes>;

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

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlicesTypes = void 0;
-exports.SlicesTypes = {
-    Slice: "Slice",
-    SharedSlice: "SharedSlice",
-};
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const CompositeSlice_1 = require("./CompositeSlice");
+const SharedSlice_1 = require("./SharedSlice");
+exports.SlicesTypes = t.keyof({
+    [CompositeSlice_1.CompositeSliceType]: null,
+    [SharedSlice_1.SharedSliceType]: null,
+});

package/lib/documents/DocumentData.d.ts

@@ -1,17 +1,6 @@
-import * as O from "fp-ts/lib/Option";
-import { type WidgetContent, type WidgetKey } from "./widgets";
-declare type DocumentData = Map<WidgetKey, O.Option<WidgetContent>>;
+import { WidgetContent, WidgetKey } from "../content";
+import type { FieldTypes } from "../customtypes/widgets";
 declare const DocumentData: {
-    getWidget(key: WidgetKey, widgets: Map<WidgetKey, unknown>, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>, parsed: Map<string, O.Option<WidgetContent>>): O.Option<WidgetContent>;
-    fromJson(widgets: Map<WidgetKey, unknown>, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>): DocumentData;
-    partitionData(data: {
-        [p: string]: unknown;
-    }): {
-        types: Map<string, string>;
-        positions: Map<string, number>;
-        widgets: Map<WidgetKey, unknown>;
-        slugs: ReadonlyArray<string>;
-        uid: string | undefined;
-    };
+    getWidget(key: WidgetKey, widgetTypes: Map<WidgetKey, FieldTypes>, parsed: Map<string, WidgetContent>): WidgetContent | undefined;
 };
 export default DocumentData;

package/lib/documents/DocumentData.js

@@ -1,70 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const Either_1 = require("fp-ts/lib/Either");
-const O = (0, tslib_1.__importStar)(require("fp-ts/lib/Option"));
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const widgets_1 = require("./widgets");
-function computeWidget(key, widgets, widgetTypes, widgetPositions) {
-    const widget = widgets.get(key);
-    if (widget === undefined) {
-        return O.none;
-    }
-    return widgets_1.Widget.fromJson(key, widget, widgetTypes, widgetPositions);
-}
+const content_1 = require("../content");
+const LegacyContentCtx_1 = require("../content/LegacyContentCtx");
 const DocumentData = {
-    getWidget(key, widgets, widgetTypes, widgetPositions, parsed) {
+    getWidget(key, widgetTypes, parsed) {
         const widget = parsed.get(key);
         if (widget === undefined) {
-            return computeWidget(key, widgets, widgetTypes, widgetPositions);
+            const res = (0, content_1.WidgetLegacy)((0, LegacyContentCtx_1.defaultCtx)(key, widgetTypes)).decode(parsed);
+            return !res || res._tag === "Left" ? undefined : res.right;
         }
         return widget;
     },
-    fromJson(widgets, widgetTypes, widgetPositions) {
-        return Array.from(widgets.keys()).reduce((acc, widgetKey) => {
-            const parsedWidget = this.getWidget(widgetKey, widgets, widgetTypes, widgetPositions, acc);
-            return new Map([...Array.from(acc.entries()), [widgetKey, parsedWidget]]);
-        }, new Map());
-    },
-    partitionData(data) {
-        const fields = Object.entries(data);
-        const { types, positions, widgets } = fields.reduce((acc, [k, v]) => {
-            if (k.endsWith("_TYPE")) {
-                const decodedValue = t.string.decode(v);
-                if ((0, Either_1.isRight)(decodedValue)) {
-                    return {
-                        ...acc,
-                        types: acc.types.set(k.substring(0, k.length - 5), decodedValue.right),
-                    };
-                }
-            }
-            if (k.endsWith("_POSITION") && typeof v === "number") {
-                return {
-                    ...acc,
-                    positions: acc.positions.set(k.substring(0, k.length - 9), v),
-                };
-            }
-            if (!k.endsWith("_POSITION") && !k.endsWith("_TYPE")) {
-                return {
-                    ...acc,
-                    widgets: acc.widgets.set(k, v),
-                };
-            }
-            return acc;
-        }, {
-            types: new Map(),
-            positions: new Map(),
-            widgets: new Map(),
-        });
-        const slugs = data["slugs_INTERNAL"] || [];
-        const uid = data["uid"];
-        return {
-            widgets,
-            types,
-            positions,
-            uid,
-            slugs,
-        };
-    },
 };
 exports.default = DocumentData;

package/lib/documents/widgets/nestable/ImageContent.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+export declare const ImageContentType = "ImageContent";
 export declare const ImageContentView: t.ExactC<t.IntersectionC<[t.TypeC<{
     origin: t.ExactC<t.TypeC<{
         id: t.StringC;
@@ -23,7 +24,6 @@ export declare const ImageContentView: t.ExactC<t.IntersectionC<[t.TypeC<{
     provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
 }>]>>;
 export declare type ImageContentView = t.TypeOf<typeof ImageContentView>;
-export declare const ImageContentType = "ImageContent";
 export declare const ImageContent: t.Type<{
     origin: {
         id: string;

package/lib/documents/widgets/nestable/ImageContent.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageContent = exports.ImageContentType = exports.ImageContentView = void 0;
+exports.ImageContent = exports.ImageContentView = exports.ImageContentType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const validators_1 = require("../../../validators");
 const function_1 = require("../../../validators/function");
+exports.ImageContentType = "ImageContent";
 const Origin = t.exact(t.type({
     id: t.string,
     url: t.string,
@@ -32,7 +33,6 @@ exports.ImageContentView = t.exact(t.intersection([
         provider: validators_1.StringOrNull,
     }),
 ]));
-exports.ImageContentType = "ImageContent";
 exports.ImageContent = (0, function_1.addType)(t.intersection([
     exports.ImageContentView,
     t.partial({

package/lib/utils/Objects.d.ts

@@ -3,3 +3,4 @@ export declare function zipObjects<A, B = A>(objLeft?: Partial<Record<string, A>
     right?: B | undefined;
 }>>;
 export declare function isNotEmpty<A extends object>(obj: A): boolean;
+export declare function withOptionals<T extends object>(object: T, optionals: Array<[keyof T, T[keyof T] | null | undefined]>): T;

package/lib/utils/Objects.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNotEmpty = exports.zipObjects = void 0;
+exports.withOptionals = exports.isNotEmpty = exports.zipObjects = void 0;
 function zipObjects(objLeft, objRight) {
     const allKeys = [
         ...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {}))),
@@ -19,3 +19,12 @@ function isNotEmpty(obj) {
     return Boolean(Object.keys(obj).length);
 }
 exports.isNotEmpty = isNotEmpty;
+function withOptionals(object, optionals) {
+    return {
+        ...object,
+        ...optionals.reduce((acc, [key, value]) => {
+            return value ? { ...acc, [key]: value } : acc;
+        }, {}),
+    };
+}
+exports.withOptionals = withOptionals;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "1.5.2",
+	"version": "2.0.0-alpha.0",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/common/WidgetKey.ts

@@ -0,0 +1,13 @@
+import * as t from "io-ts"
+
+import { refineType } from "../validators/function"
+
+const widgetKeyRegex = new RegExp("^[^<>]+$")
+
+export const WidgetKey = refineType(
+	t.string,
+	"WidgetKey",
+	(s: string) => s.length === 0 || widgetKeyRegex.test(s),
+)
+
+export type WidgetKey = t.TypeOf<typeof WidgetKey>

package/src/common/index.ts

@@ -0,0 +1 @@
+export * from "./WidgetKey"

package/src/content/Document.ts

@@ -1,21 +1,134 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import { WidgetKey as KeyForWidgetContent } from "../documents/widgets"
+import { WidgetKey } from "../common"
+import { WidgetContent, WidgetLegacy } from "./fields"
 import {
-	GroupContent,
-	NestableContent,
-	SlicesContent,
-	UIDContent,
-} from "./fields"
-
-export const WidgetKey = KeyForWidgetContent
-export type WidgetKey = KeyForWidgetContent
-
-const WidgetContent = t.union([
-	SlicesContent,
-	UIDContent,
-	NestableContent,
-	GroupContent,
-])
+	defaultCtx,
+	FieldOrSliceType,
+	LegacyContentCtx,
+	WithTypes,
+} from "./LegacyContentCtx"
+
 export const Document = t.record(WidgetKey, WidgetContent)
 export type Document = t.TypeOf<typeof Document>
+
+const legacyDocReader = t.record(WidgetKey, t.unknown)
+type DocumentLegacy = t.TypeOf<typeof legacyDocReader>
+
+const DocumentLegacyCodec = (allTypes?: LegacyContentCtx["allTypes"]) => {
+	return new t.Type<Document, WithTypes<DocumentLegacy>, unknown>(
+		"Document",
+		(u): u is Document => !!u && typeof u === "object",
+		(doc) => {
+			return pipe(
+				legacyDocReader.decode(doc),
+				either.map((parsedDoc) => {
+					return Object.entries(parsedDoc).reduce(
+						(acc, [widgetKey, widgetValue]) => {
+							const widgetCtx = defaultCtx(widgetKey, allTypes)
+							const parsedW = WidgetLegacy(widgetCtx).decode(widgetValue)
+							if (!parsedW || parsedW?._tag === "Left") return acc
+
+							return { ...acc, [widgetKey]: parsedW.right }
+						},
+						{},
+					)
+				}),
+			)
+		},
+		(g: Document) => {
+			return Object.entries(g).reduce(
+				(acc, [key, value]) => {
+					const widgetCtx = defaultCtx(key, allTypes)
+					const result = WidgetLegacy(widgetCtx).encode(value)
+					if (!result) return acc
+
+					return {
+						content: { ...acc.content, [key]: result.content },
+						types: { ...acc.types, ...result.types },
+					}
+				},
+				{ content: {}, types: {} },
+			)
+		},
+	)
+}
+
+function extractMetadata(data: { [p: string]: unknown }): {
+	types: Map<string, FieldOrSliceType>
+	widgets: Partial<Record<WidgetKey, unknown>>
+	slugs: ReadonlyArray<string>
+	uid: string | undefined
+} {
+	const fields: [string, unknown][] = Object.entries(data)
+
+	const { types, widgets } = fields.reduce(
+		(acc, [k, v]) => {
+			if (k.endsWith("_TYPE")) {
+				const decodedValue = FieldOrSliceType.decode(v)
+				if (decodedValue._tag === "Right") {
+					return {
+						...acc,
+						types: acc.types.set(
+							k.substring(0, k.length - 5),
+							decodedValue.right,
+						),
+					}
+				}
+			}
+			if (!k.endsWith("_POSITION") && !k.endsWith("_TYPE")) {
+				return {
+					...acc,
+					widgets: {
+						...acc.widgets,
+						[k]: v,
+					},
+				}
+			}
+			return acc
+		},
+		{
+			types: new Map<string, FieldOrSliceType>(),
+			widgets: {},
+		},
+	)
+
+	const slugs = (data["slugs_INTERNAL"] as string[]) || []
+	const uid = data["uid"] as string | undefined
+
+	return {
+		widgets,
+		types,
+		uid,
+		slugs,
+	}
+}
+
+function parseLegacyDocument(legacyDoc: unknown): Document | undefined {
+	const result = pipe(
+		// ensure it's the right document format first
+		t.record(WidgetKey, t.unknown).decode(legacyDoc),
+		either.chain((doc) => {
+			// extract all metadata, meaning all _TYPES keys from legacy format + the widgets as unknown
+			const { types, widgets } = extractMetadata(doc)
+			// parse the actual widgets
+			return DocumentLegacyCodec(types).decode(widgets)
+		}),
+	)
+
+	return result._tag === "Left" ? undefined : result.right
+}
+
+function encodeToLegacyDocument(document: Document): DocumentLegacy {
+	const encoded = DocumentLegacyCodec().encode(document)
+	return { ...encoded.content, ...encoded.types }
+}
+
+export const DocumentLegacy = {
+	_codec: DocumentLegacyCodec,
+	extractMetadata,
+	parse: parseLegacyDocument,
+	encode: encodeToLegacyDocument,
+}

package/src/content/LegacyContentCtx.ts

@@ -0,0 +1,57 @@
+import * as t from "io-ts"
+
+import { FieldTypes, SlicesTypes } from "../customtypes/widgets"
+
+export const FieldOrSliceType = t.union([FieldTypes, SlicesTypes])
+export type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>
+export class LegacyContentCtx {
+	fieldKey: string
+	prefixedKey: string
+	keyOfType: string
+	fieldPath: Array<string>
+	fieldType?: FieldOrSliceType | undefined
+	allTypes: Map<string, FieldOrSliceType>
+
+	constructor(
+		fieldKey: string,
+		fieldPath?: Array<string>,
+		allTypes?: Map<string, FieldOrSliceType>,
+	) {
+		this.fieldKey = fieldKey
+		this.fieldPath = fieldPath || []
+		this.allTypes = allTypes || new Map<string, FieldOrSliceType>()
+
+		const prefixedKey = Array.of(this.fieldPath, [this.fieldKey])
+			.flat()
+			.join(".")
+
+		this.prefixedKey = prefixedKey
+		this.keyOfType = `${prefixedKey}_TYPE`
+
+		this.fieldType = this.allTypes.get(this.prefixedKey)
+	}
+}
+
+export function getFieldCtx(
+	fieldKey: string,
+	ctx: LegacyContentCtx,
+	prefixes?: Array<string>,
+): LegacyContentCtx {
+	return new LegacyContentCtx(
+		fieldKey,
+		[...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])],
+		ctx.allTypes,
+	)
+}
+
+export function defaultCtx(
+	key: string,
+	allTypes: Map<string, FieldOrSliceType> = new Map(),
+): LegacyContentCtx {
+	return new LegacyContentCtx(key, [], allTypes)
+}
+
+export type WithTypes<T> = {
+	types: Record<string, FieldOrSliceType>
+	content: T
+}

package/src/content/fields/EmptyContent.ts

@@ -0,0 +1,45 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import type { FieldOrSliceType } from "../LegacyContentCtx"
+import { hasContentType } from "../utils"
+
+export const EmptyContentType = "EmptyContent"
+
+export const isEmptyContent = (u: unknown): u is EmptyContent =>
+	hasContentType(u) && u.__TYPE__ === EmptyContentType
+
+const legacyReader = t.union([
+	t.null,
+	t.type({
+		value: t.null,
+	}),
+])
+type EmptyLegacy = t.TypeOf<typeof legacyReader>
+
+export const EmptyLegacy = (type: FieldOrSliceType) =>
+	new t.Type<EmptyContent, unknown, unknown>(
+		"EmptyLegacy",
+		isEmptyContent,
+		(content) => {
+			return pipe(
+				legacyReader.decode(content),
+				either.map(() => {
+					return {
+						type,
+						__TYPE__: EmptyContentType,
+					}
+				}),
+			)
+		},
+
+		() => null,
+	)
+
+export const EmptyContent = t.strict({
+	type: t.string,
+	__TYPE__: t.literal(EmptyContentType),
+})
+
+export type EmptyContent = t.TypeOf<typeof EmptyContent>

package/src/content/fields/GroupContent.ts

@@ -1,21 +1,116 @@
+import { either } from "fp-ts"
+import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
 import {
-	GroupContentType as groupType,
-	GroupItemContentType as groupItemType,
-} from "../../documents/widgets/GroupContent"
-import { NestableContent } from "./nestable"
+	FieldOrSliceType,
+	getFieldCtx,
+	LegacyContentCtx,
+	WithTypes,
+} from "../LegacyContentCtx"
+import { hasContentType } from "../utils"
+import { NestableContent, NestableLegacy } from "./nestable"
+
+export const GroupItemContentType = "GroupItemContent" as const
 
 export const GroupItemContent = t.strict({
-	__TYPE__: t.literal(groupItemType),
+	__TYPE__: t.literal(GroupItemContentType),
 	value: t.array(t.tuple([t.string, NestableContent])),
 })
 export type GroupItemContent = t.TypeOf<typeof GroupItemContent>
-export const GroupItemContentType = groupItemType
+
+const itemLegacyReader = t.array(t.tuple([t.string, t.unknown]))
+export type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>
+
+export const GroupItemLegacy = (ctx: LegacyContentCtx) => {
+	return new t.Type<GroupItemContent, WithTypes<GroupItemLegacy>>(
+		"GroupItemLegacy",
+		(u): u is GroupItemContent =>
+			hasContentType(u) && u.__TYPE__ === GroupItemContentType,
+		(u) => {
+			const parsed = pipe(
+				itemLegacyReader.decode(u),
+				either.map((items) => {
+					const parsedItems = items.reduce<Array<[string, NestableContent]>>(
+						(acc, [itemKey, itemValue]) => {
+							const itemCtx = getFieldCtx(itemKey, ctx)
+							const result = NestableLegacy(itemCtx).decode(itemValue)
+							if (!result) return acc
+
+							if (result._tag === "Right")
+								return [...acc, [itemKey, result.right]]
+							else return acc
+						},
+						[],
+					)
+
+					return {
+						value: parsedItems,
+						__TYPE__: GroupItemContentType,
+					}
+				}),
+			)
+			return parsed
+		},
+		(item) => {
+			return item.value.reduce<WithTypes<GroupItemLegacy>>(
+				(acc, [key, value]) => {
+					const itemCtx = getFieldCtx(key, ctx)
+					const encoded = NestableLegacy(itemCtx).encode(value)
+					if (!encoded) return acc
+
+					return {
+						content: [...acc.content, [key, encoded.content]],
+						types: { ...acc.types, ...encoded.types },
+					}
+				},
+				{ content: [], types: {} },
+			)
+		},
+	)
+}
+
+type GroupLegacy = Array<GroupItemLegacy>
+export const GroupLegacy = (ctx: LegacyContentCtx) => {
+	const codec = t.array(GroupItemLegacy(ctx))
+
+	return new t.Type<GroupContent, WithTypes<GroupLegacy>, unknown>(
+		"GroupLegacy",
+		isGroupContent,
+		(items) => {
+			return pipe(
+				codec.decode(items),
+				either.map((parsedItems) => {
+					return {
+						value: parsedItems,
+						__TYPE__: GroupContentType,
+					}
+				}),
+			)
+		},
+		(g: GroupContent) => {
+			const res = codec.encode(g.value)
+
+			return {
+				content: res.map((block) => block.content),
+				types: res.reduce<Record<string, FieldOrSliceType>>(
+					(acc, block) => {
+						return { ...acc, ...block.types }
+					},
+					{ [ctx.keyOfType]: "Group" },
+				),
+			}
+		},
+	)
+}
+
+export const GroupContentType = "GroupContentType" as const
+
+export const isGroupContent = (u: unknown): u is GroupContent =>
+	hasContentType(u) && u.__TYPE__ === GroupContentType
 
 export const GroupContent = t.strict({
-	__TYPE__: t.literal(groupType),
+	__TYPE__: t.literal(GroupContentType),
 	value: t.array(GroupItemContent),
 })
 export type GroupContent = t.TypeOf<typeof GroupContent>
-export const GroupContentType = groupType