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

package/lib/content/Document.js

@@ -1,15 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Document = exports.WidgetKey = void 0;
+exports.DocumentLegacy = exports.Document = 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 widgets_1 = require("../documents/widgets");
+const common_1 = require("../common");
 const fields_1 = require("./fields");
-exports.WidgetKey = widgets_1.WidgetKey;
-const WidgetContent = t.union([
-    fields_1.SlicesContent,
-    fields_1.UIDContent,
-    fields_1.NestableContent,
-    fields_1.GroupContent,
-]);
-exports.Document = t.record(exports.WidgetKey, WidgetContent);
+const LegacyContentCtx_1 = require("./LegacyContentCtx");
+exports.Document = t.record(common_1.WidgetKey, fields_1.WidgetContent);
+const legacyDocReader = t.record(common_1.WidgetKey, t.unknown);
+const DocumentLegacyCodec = (allTypes) => {
+    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);
+                const parsedW = (0, fields_1.WidgetLegacy)(widgetCtx).decode(widgetValue);
+                if (!parsedW || (parsedW === null || parsedW === void 0 ? void 0 : parsedW._tag) === "Left")
+                    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 },
+            };
+        }, { content: {}, types: {} });
+    });
+};
+function extractMetadata(data) {
+    const fields = Object.entries(data);
+    const { types, widgets } = fields.reduce((acc, [k, v]) => {
+        if (k.endsWith("_TYPE")) {
+            const decodedValue = LegacyContentCtx_1.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(),
+        widgets: {},
+    });
+    const slugs = data["slugs_INTERNAL"] || [];
+    const uid = data["uid"];
+    return {
+        widgets,
+        types,
+        uid,
+        slugs,
+    };
+}
+function parseLegacyDocument(legacyDoc) {
+    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 } = extractMetadata(doc);
+        // parse the actual widgets
+        return DocumentLegacyCodec(types).decode(widgets);
+    }));
+    return result._tag === "Left" ? undefined : result.right;
+}
+function encodeToLegacyDocument(document) {
+    const encoded = DocumentLegacyCodec().encode(document);
+    return { ...encoded.content, ...encoded.types };
+}
+exports.DocumentLegacy = {
+    _codec: DocumentLegacyCodec,
+    extractMetadata,
+    parse: parseLegacyDocument,
+    encode: encodeToLegacyDocument,
+};

package/lib/content/LegacyContentCtx.d.ts

@@ -0,0 +1,41 @@
+import * as t from "io-ts";
+export declare const FieldOrSliceType: t.UnionC<[t.KeyofC<{
+    Color: null;
+    Boolean: null;
+    Number: null;
+    Embed: null;
+    GeoPoint: null;
+    Date: null;
+    Range: null;
+    StructuredText: null;
+    Select: null;
+    Separator: 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;
+}>]>;
+export declare type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>;
+export declare 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>);
+}
+export declare function getFieldCtx(fieldKey: string, ctx: LegacyContentCtx, prefixes?: Array<string>): LegacyContentCtx;
+export declare function defaultCtx(key: string, allTypes?: Map<string, FieldOrSliceType>): LegacyContentCtx;
+export declare type WithTypes<T> = {
+    types: Record<string, FieldOrSliceType>;
+    content: T;
+};

package/lib/content/LegacyContentCtx.js

@@ -0,0 +1,65 @@
+"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 widgets_1 = require("../customtypes/widgets");
+exports.FieldOrSliceType = t.union([widgets_1.FieldTypes, widgets_1.SlicesTypes]);
+class LegacyContentCtx {
+    constructor(fieldKey, fieldPath, allTypes) {
+        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, "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
+        });
+        this.fieldKey = fieldKey;
+        this.fieldPath = fieldPath || [];
+        this.allTypes = allTypes || new Map();
+        const prefixedKey = Array.of(this.fieldPath, [this.fieldKey])
+            .flat()
+            .join(".");
+        this.prefixedKey = prefixedKey;
+        this.keyOfType = `${prefixedKey}_TYPE`;
+        this.fieldType = this.allTypes.get(this.prefixedKey);
+    }
+}
+exports.LegacyContentCtx = LegacyContentCtx;
+function getFieldCtx(fieldKey, ctx, prefixes) {
+    return new LegacyContentCtx(fieldKey, [...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])], ctx.allTypes);
+}
+exports.getFieldCtx = getFieldCtx;
+function defaultCtx(key, allTypes = new Map()) {
+    return new LegacyContentCtx(key, [], allTypes);
+}
+exports.defaultCtx = defaultCtx;

package/lib/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/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),
+});