@prismicio/types-internal 3.16.0 → 3.16.1-alpha.0

package/lib/src/content/Document.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateDocument = exports.collectWidgets = exports.traverseDocument = exports.fillDocumentWithDefaultValues = exports.DocumentLegacy = exports.Document = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const Either_1 = require("fp-ts/lib/Either");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const utils_1 = require("../_internal/utils");
+const common_1 = require("../common");
+const UUID_1 = require("../common/UUID");
+const customtypes_1 = require("../customtypes");
+const fields_1 = require("./fields");
+const LegacyContentCtx_1 = require("./LegacyContentCtx");
+exports.Document = t.record(common_1.WidgetKey, fields_1.WidgetContent);
+const legacyDocReader = t.record(common_1.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 (0, function_1.pipe)(legacyDocReader.decode(doc), fp_ts_1.either.map((parsedDoc) => {
+            return Object.entries(parsedDoc).reduce((acc, [widgetKey, widgetValue]) => {
+                const widgetCtx = (0, LegacyContentCtx_1.defaultCtx)(widgetKey, allTypes, allKeys);
+                const parsedW = (0, fields_1.WidgetLegacy)(widgetCtx).decode(widgetValue);
+                if (!parsedW || (0, Either_1.isLeft)(parsedW))
+                    return acc;
+                return { ...acc, [widgetKey]: parsedW.right };
+            }, {});
+        }));
+    }, (g) => {
+        return Object.entries(g).reduce((acc, [key, value]) => {
+            const widgetCtx = (0, LegacyContentCtx_1.defaultCtx)(key, allTypes);
+            const result = (0, fields_1.WidgetLegacy)(widgetCtx).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 fields = Object.entries(data);
+    const { types, widgets, keys } = fields.reduce((acc, [k, v]) => {
+        if (k.endsWith("_TYPE")) {
+            const decodedValue = LegacyContentCtx_1.FieldOrSliceType.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("_KEY")) {
+            const decodedValue = UUID_1.UUID.decode(v);
+            if ((0, Either_1.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: new Map(),
+        widgets: {},
+        keys: new Map(),
+    });
+    const slugs = data["slugs_INTERNAL"] || [];
+    const uid = data["uid"];
+    return {
+        widgets,
+        types,
+        keys,
+        uid,
+        slugs,
+    };
+}
+function parseLegacyDocument(legacyDoc, customType) {
+    const result = (0, function_1.pipe)(
+    // ensure it's the right document format first
+    t.record(common_1.WidgetKey, t.unknown).decode(legacyDoc), fp_ts_1.either.chain((doc) => {
+        // extract all metadata, meaning all _TYPES keys from legacy format + the widgets as unknown
+        const { types, widgets, keys } = extractMetadata(doc);
+        // parse the actual widgets
+        return DocumentLegacyCodec(types, keys).decode(widgets);
+    }));
+    return (0, Either_1.isLeft)(result) ? undefined : migrateDocument(result.right, customType);
+}
+function encodeToLegacyDocument(document) {
+    const encoded = DocumentLegacyCodec().encode(document);
+    return { ...encoded.content, ...encoded.types, ...encoded.keys };
+}
+exports.DocumentLegacy = {
+    _codec: DocumentLegacyCodec,
+    extractMetadata,
+    parse: parseLegacyDocument,
+    encode: encodeToLegacyDocument,
+};
+function simplifyCustomType(customType) {
+    return {
+        customTypeId: customType === null || customType === void 0 ? void 0 : customType.id,
+        fields: Object.fromEntries((0, customtypes_1.flattenSections)(customType)),
+    };
+}
+function fillDocumentWithDefaultValues(customType, document) {
+    const { fields } = customType && customtypes_1.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 (0, fields_1.isGroupContent)(fieldContent)
+                        ? (0, fields_1.groupContentWithDefaultValues)(fieldDef, fieldContent)
+                        : fieldContent;
+                case "Choice":
+                case "Slices":
+                    return (0, fields_1.isSlicesContent)(fieldContent)
+                        ? (0, fields_1.slicesContentWithDefaultValues)(fieldDef, fieldContent)
+                        : fieldContent;
+                default:
+                    return fieldContent === undefined && customtypes_1.NestableWidget.is(fieldDef)
+                        ? (0, fields_1.NestableContentDefaultValue)(fieldDef)
+                        : fieldContent;
+            }
+        })();
+        return updatedField
+            ? {
+                ...updatedDocument,
+                [fieldKey]: updatedField,
+            }
+            : updatedDocument;
+    }, document);
+}
+exports.fillDocumentWithDefaultValues = fillDocumentWithDefaultValues;
+/**
+ * @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 && customtypes_1.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 = utils_1.ContentPath.make([
+                { key: model === null || model === void 0 ? void 0 : model.customTypeId, type: "CustomType" },
+                { key, type: "Widget" },
+            ]);
+            const transformedWidget = (() => {
+                switch (content.__TYPE__) {
+                    case "SliceContentType":
+                        return (0, fields_1.traverseSlices)({
+                            path,
+                            key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Slices" || (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Choice"
+                                ? fieldModel
+                                : undefined,
+                            content,
+                        })({ transformWidget, transformSlice });
+                    case "GroupContentType":
+                        return (0, fields_1.traverseGroupContent)({
+                            path,
+                            key,
+                            apiId: key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Group" ? fieldModel : undefined,
+                            content,
+                        })(transformWidget);
+                    case "RepeatableContent":
+                        return (0, fields_1.traverseRepeatableContent)({
+                            path,
+                            key,
+                            apiId: key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Link" ? fieldModel : undefined,
+                            content,
+                        })(transformWidget);
+                    case "TableContent":
+                        return (0, fields_1.traverseTableContent)({
+                            path,
+                            key,
+                            apiId: key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Table" ? fieldModel : undefined,
+                            content,
+                        })(transformWidget);
+                    default:
+                        return transformWidget({
+                            path,
+                            key,
+                            apiId: key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) !== "Group" &&
+                                (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) !== "Slices" &&
+                                (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) !== "Choice"
+                                ? fieldModel
+                                : undefined,
+                            content,
+                        });
+                }
+            })();
+            return {
+                ...acc,
+                ...(transformedWidget ? { [key]: transformedWidget } : {}),
+            };
+        }, {});
+    };
+}
+exports.traverseDocument = traverseDocument;
+// /**
+//  * 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
+//  *
+//  * @param document parsed prismic content
+//  * @param is typeguard to match specifically the type of widget we want to collect
+//  * @returns a record containing the path of the widget as key and the typed collected content as value
+//  */
+function collectWidgets(document, is) {
+    const collected = {};
+    traverseDocument({ document })({
+        transformWidget: ({ content, path }) => {
+            const key = utils_1.ContentPath.serialize(path);
+            if (is(content, path))
+                collected[key] = content;
+            return content;
+        },
+    });
+    return collected;
+}
+exports.collectWidgets = collectWidgets;
+function migrateDocument(document, customType) {
+    const model = customtypes_1.StaticCustomType.is(customType)
+        ? simplifyCustomType(customType)
+        : customType;
+    const needsMigration = Object.values((0, customtypes_1.collectSharedSlices)(model)).some((slice) => Boolean(slice.legacyPaths));
+    if (!needsMigration)
+        return document;
+    return traverseDocument({
+        document,
+        customType,
+    })({
+        transformSlice: fields_1.migrateSliceItem,
+    });
+}
+exports.migrateDocument = migrateDocument;

package/lib/src/content/LegacyContentCtx.d.ts

@@ -0,0 +1,64 @@
+import * as t from "io-ts";
+export 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">]>;
+export declare 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>;
+}
+export 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>;
+}
+export declare function getFieldCtx({ fieldKey, contentKey: contentKeyParam, ctx, prefixes, }: GetFieldCtxParams): LegacyContentCtx;
+export declare function defaultCtx(key: string, allTypes?: Map<string, FieldOrSliceType>, allKeys?: Map<string, string>): LegacyContentCtx;
+export declare type WithTypes<T> = {
+    keys: Record<string, string>;
+    types: Record<string, FieldOrSliceType>;
+    content: T;
+};
+export {};

package/lib/src/content/LegacyContentCtx.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCtx = exports.getFieldCtx = exports.LegacyContentCtx = exports.FieldOrSliceType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const uuid_1 = require("uuid");
+const widgets_1 = require("../customtypes/widgets");
+exports.FieldOrSliceType = t.union([
+    t.union([widgets_1.FieldType, widgets_1.SlicesTypes]),
+    t.literal("Repeatable.Link"),
+]);
+class LegacyContentCtx {
+    constructor({ fieldKey, contentKey, contentPath, fieldPath, allTypes, allKeys, }) {
+        var _a;
+        Object.defineProperty(this, "fieldKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prefixedKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyOfType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keyOfKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fieldPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fieldType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "allTypes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "allKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contentKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contentPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fieldContentKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fieldKey = fieldKey;
+        this.contentKey = contentKey || fieldKey;
+        this.fieldPath = fieldPath || [];
+        this.contentPath = contentPath || [];
+        this.allTypes = allTypes || new Map();
+        this.allKeys = allKeys || 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 = (_a = this.allKeys.get(prefixedContentKey)) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)();
+    }
+    withContentKey(contentKey) {
+        return new LegacyContentCtx({
+            ...this,
+            contentPath: [...this.contentPath, this.contentKey],
+            contentKey,
+        });
+    }
+}
+exports.LegacyContentCtx = LegacyContentCtx;
+function getFieldCtx({ fieldKey, contentKey: contentKeyParam, ctx, prefixes, }) {
+    const contentKey = contentKeyParam || fieldKey;
+    return new LegacyContentCtx({
+        fieldKey,
+        contentKey,
+        contentPath: [...ctx.contentPath, ctx.contentKey, ...(prefixes || [])],
+        fieldPath: [...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])],
+        allTypes: ctx.allTypes,
+        allKeys: ctx.allKeys,
+    });
+}
+exports.getFieldCtx = getFieldCtx;
+function defaultCtx(key, allTypes = new Map(), allKeys = new Map()) {
+    return new LegacyContentCtx({
+        fieldKey: key,
+        contentKey: key,
+        contentPath: [],
+        fieldPath: [],
+        allTypes,
+        allKeys,
+    });
+}
+exports.defaultCtx = defaultCtx;

package/lib/src/content/fields/EmptyContent.d.ts

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import type { FieldOrSliceType } from "../LegacyContentCtx";
+export declare const EmptyContentType = "EmptyContent";
+export declare const isEmptyContent: (u: unknown) => u is {
+    type: string;
+    __TYPE__: "EmptyContent";
+};
+export declare const EmptyLegacy: (type: FieldOrSliceType) => t.Type<{
+    type: string;
+    __TYPE__: "EmptyContent";
+}, unknown, unknown>;
+export declare const EmptyContent: t.ExactC<t.TypeC<{
+    type: t.StringC;
+    __TYPE__: t.LiteralC<"EmptyContent">;
+}>>;
+export declare type EmptyContent = t.TypeOf<typeof EmptyContent>;

package/lib/src/content/fields/EmptyContent.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyContent = exports.EmptyLegacy = exports.isEmptyContent = exports.EmptyContentType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const utils_1 = require("../utils");
+exports.EmptyContentType = "EmptyContent";
+const isEmptyContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.EmptyContentType;
+exports.isEmptyContent = isEmptyContent;
+const legacyReader = t.union([
+    t.null,
+    t.type({
+        value: t.null,
+    }),
+]);
+const EmptyLegacy = (type) => new t.Type("EmptyLegacy", exports.isEmptyContent, (content) => {
+    return (0, function_1.pipe)(legacyReader.decode(content), fp_ts_1.either.map(() => {
+        return {
+            type,
+            __TYPE__: exports.EmptyContentType,
+        };
+    }));
+}, () => null);
+exports.EmptyLegacy = EmptyLegacy;
+exports.EmptyContent = t.strict({
+    type: t.string,
+    __TYPE__: t.literal(exports.EmptyContentType),
+});

package/lib/src/content/fields/GroupContent.d.ts

@@ -0,0 +1,42 @@
+import * as t from "io-ts";
+import type { ContentPath, TraverseWidgetContentFn } from "../../_internal/utils";
+import { type Group, type NestableWidget } from "../../customtypes";
+import { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
+import { NestableContent } from "./nestable";
+export declare const GroupItemContentType: "GroupItemContent";
+export declare const GroupContentType: "GroupContentType";
+export declare const GroupItemContent: t.Type<GroupItemContent>;
+export declare type GroupItemContent = {
+    __TYPE__: typeof GroupItemContentType;
+    key: string;
+    value: [string, NestableContent | GroupContent][];
+};
+export declare const GroupContent: t.Type<GroupContent>;
+export declare type GroupContent = {
+    __TYPE__: typeof GroupContentType;
+    value: GroupItemContent[];
+};
+export declare const isGroupContent: (u: unknown) => u is GroupContent;
+export declare const GroupContentDefaultValue: GroupContent;
+declare const itemLegacyReader: t.RecordC<t.StringC, t.UnknownC>;
+export declare type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>;
+export declare const GroupItemLegacy: (ctx: LegacyContentCtx, index: number) => t.Type<GroupItemContent, WithTypes<{
+    [x: string]: unknown;
+}>, unknown>;
+export declare function arrayWithIndexCodec<T, O>(f: (index: number) => t.Type<T, O, unknown>): t.Type<Array<T>, O[], unknown>;
+declare type GroupLegacy = Array<GroupItemLegacy>;
+export declare const GroupLegacy: (ctx: LegacyContentCtx) => t.Type<GroupContent, WithTypes<GroupLegacy>, unknown>;
+export declare function groupContentWithDefaultValues(customType: Group, content: GroupContent): GroupContent;
+export declare function traverseGroupContent({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    content: GroupContent;
+    model?: Group | undefined;
+}): (transform: TraverseWidgetContentFn) => GroupContent | undefined;
+export declare function traverseGroupItemsContent({ path, model, content, }: {
+    path: ContentPath;
+    content: Array<GroupItemContent>;
+    model?: Record<string, Group | NestableWidget> | undefined;
+}): (transform: TraverseWidgetContentFn) => Array<GroupItemContent>;
+export {};