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

package/lib/content/fields/GroupContent.js

@@ -1,17 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GroupContentType = exports.GroupContent = exports.GroupItemContentType = exports.GroupItemContent = void 0;
+exports.GroupContent = exports.isGroupContent = exports.GroupContentType = exports.GroupLegacy = exports.GroupItemLegacy = exports.GroupItemContent = exports.GroupItemContentType = 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 GroupContent_1 = require("../../documents/widgets/GroupContent");
+const LegacyContentCtx_1 = require("../LegacyContentCtx");
+const utils_1 = require("../utils");
 const nestable_1 = require("./nestable");
+exports.GroupItemContentType = "GroupItemContent";
 exports.GroupItemContent = t.strict({
-    __TYPE__: t.literal(GroupContent_1.GroupItemContentType),
+    __TYPE__: t.literal(exports.GroupItemContentType),
     value: t.array(t.tuple([t.string, nestable_1.NestableContent])),
 });
-exports.GroupItemContentType = GroupContent_1.GroupItemContentType;
+const itemLegacyReader = t.array(t.tuple([t.string, t.unknown]));
+const GroupItemLegacy = (ctx) => {
+    return new t.Type("GroupItemLegacy", (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.GroupItemContentType, (u) => {
+        const parsed = (0, function_1.pipe)(itemLegacyReader.decode(u), fp_ts_1.either.map((items) => {
+            const parsedItems = items.reduce((acc, [itemKey, itemValue]) => {
+                const itemCtx = (0, LegacyContentCtx_1.getFieldCtx)(itemKey, ctx);
+                const result = (0, nestable_1.NestableLegacy)(itemCtx).decode(itemValue);
+                if (!result)
+                    return acc;
+                if (result._tag === "Right")
+                    return [...acc, [itemKey, result.right]];
+                else
+                    return acc;
+            }, []);
+            return {
+                value: parsedItems,
+                __TYPE__: exports.GroupItemContentType,
+            };
+        }));
+        return parsed;
+    }, (item) => {
+        return item.value.reduce((acc, [key, value]) => {
+            const itemCtx = (0, LegacyContentCtx_1.getFieldCtx)(key, ctx);
+            const encoded = (0, nestable_1.NestableLegacy)(itemCtx).encode(value);
+            if (!encoded)
+                return acc;
+            return {
+                content: [...acc.content, [key, encoded.content]],
+                types: { ...acc.types, ...encoded.types },
+            };
+        }, { content: [], types: {} });
+    });
+};
+exports.GroupItemLegacy = GroupItemLegacy;
+const GroupLegacy = (ctx) => {
+    const codec = t.array((0, exports.GroupItemLegacy)(ctx));
+    return new t.Type("GroupLegacy", exports.isGroupContent, (items) => {
+        return (0, function_1.pipe)(codec.decode(items), fp_ts_1.either.map((parsedItems) => {
+            return {
+                value: parsedItems,
+                __TYPE__: exports.GroupContentType,
+            };
+        }));
+    }, (g) => {
+        const res = codec.encode(g.value);
+        return {
+            content: res.map((block) => block.content),
+            types: res.reduce((acc, block) => {
+                return { ...acc, ...block.types };
+            }, { [ctx.keyOfType]: "Group" }),
+        };
+    });
+};
+exports.GroupLegacy = GroupLegacy;
+exports.GroupContentType = "GroupContentType";
+const isGroupContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.GroupContentType;
+exports.isGroupContent = isGroupContent;
 exports.GroupContent = t.strict({
-    __TYPE__: t.literal(GroupContent_1.GroupContentType),
+    __TYPE__: t.literal(exports.GroupContentType),
     value: t.array(exports.GroupItemContent),
 });
-exports.GroupContentType = GroupContent_1.GroupContentType;

package/lib/content/fields/UIDContent.d.ts

@@ -1,7 +1,16 @@
 import * as t from "io-ts";
+import type { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
+export declare const UIDContentType = "UIDContent";
+export declare const isUIDContent: (u: unknown) => u is {
+    __TYPE__: "UIDContent";
+    value: string;
+};
+export declare const UIDLegacy: (ctx: LegacyContentCtx) => t.Type<{
+    __TYPE__: "UIDContent";
+    value: string;
+}, WithTypes<string>, unknown>;
 export declare const UIDContent: t.TypeC<{
     __TYPE__: t.LiteralC<"UIDContent">;
     value: t.StringC;
 }>;
 export declare type UIDContent = t.TypeOf<typeof UIDContent>;
-export declare const UIDContentType = "UIDContent";

package/lib/content/fields/UIDContent.js

@@ -1,11 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UIDContentType = exports.UIDContent = void 0;
+exports.UIDContent = exports.UIDLegacy = exports.isUIDContent = exports.UIDContentType = 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 UIDContent_1 = require("../../documents/widgets/UIDContent");
+const utils_1 = require("../utils");
+exports.UIDContentType = "UIDContent";
+const isUIDContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.UIDContentType;
+exports.isUIDContent = isUIDContent;
+const UIDLegacy = (ctx) => new t.Type("UIDLegacy", exports.isUIDContent, (u) => {
+    return (0, function_1.pipe)(t.string.decode(u), fp_ts_1.either.map((uid) => exports.UIDContent.encode({ value: uid, __TYPE__: exports.UIDContentType })));
+}, (uid) => {
+    return {
+        content: uid.value,
+        types: { [ctx.keyOfType]: "UID" },
+    };
+});
+exports.UIDLegacy = UIDLegacy;
 exports.UIDContent = t.type({
-    __TYPE__: t.literal(UIDContent_1.UIDContentType),
+    __TYPE__: t.literal(exports.UIDContentType),
     value: t.string,
 });
-exports.UIDContentType = UIDContent_1.UIDContentType;