@prismicio/types-internal 2.8.0 → 2.9.0-alpha.1

package/lib/content/Document.js

@@ -158,6 +158,7 @@ function traverseDocument({ document, customType, }) {
                 { key, type: "Widget" },
             ]);
             const transformedWidget = (() => {
+                var _a;
                 switch (content.__TYPE__) {
                     case "SliceContentType":
                         return (0, fields_1.traverseSlices)({
@@ -176,6 +177,16 @@ function traverseDocument({ document, customType, }) {
                             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" && ((_a = fieldModel.config) === null || _a === void 0 ? void 0 : _a.repeat)
+                                ? fieldModel
+                                : undefined,
+                            content,
+                        })(transformWidget);
                     default:
                         return transformWidget({
                             path,

package/lib/content/LegacyContentCtx.d.ts

@@ -1,5 +1,5 @@
 import * as t from "io-ts";
-export declare const FieldOrSliceType: t.UnionC<[t.KeyofC<{
+export declare const FieldOrSliceType: t.UnionC<[t.UnionC<[t.KeyofC<{
     Color: null;
     Boolean: null;
     Number: null;
@@ -22,7 +22,7 @@ export declare const FieldOrSliceType: t.UnionC<[t.KeyofC<{
 }>, t.KeyofC<{
     Slice: null;
     SharedSlice: null;
-}>]>;
+}>]>, t.LiteralC<"Repeatable.Link">]>;
 export declare type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>;
 export declare class LegacyContentCtx {
     fieldKey: string;

package/lib/content/LegacyContentCtx.js

@@ -4,7 +4,10 @@ exports.defaultCtx = exports.getFieldCtx = exports.LegacyContentCtx = exports.Fi
 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.FieldType, widgets_1.SlicesTypes]);
+exports.FieldOrSliceType = t.union([
+    t.union([widgets_1.FieldType, widgets_1.SlicesTypes]),
+    t.literal("Repeatable.Link"),
+]);
 class LegacyContentCtx {
     constructor(fieldKey, fieldPath, allTypes) {
         Object.defineProperty(this, "fieldKey", {

package/lib/content/fields/GroupContent.js

@@ -10,6 +10,7 @@ const customtypes_1 = require("../../customtypes");
 const LegacyContentCtx_1 = require("../LegacyContentCtx");
 const utils_1 = require("../utils");
 const nestable_1 = require("./nestable");
+const RepeatableContent_1 = require("./RepeatableContent");
 const withDefaultValues_1 = require("./withDefaultValues");
 exports.GroupItemContentType = "GroupItemContent";
 exports.GroupContentType = "GroupContentType";
@@ -129,6 +130,7 @@ function traverseGroupItemsContent({ path, model, content, }) {
                 { key: index.toString(), type: "GroupItem" },
             ]);
             const groupItemFields = groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
+                var _a;
                 const fieldDef = model === null || model === void 0 ? void 0 : model[fieldKey];
                 let transformedField;
                 if ((!fieldDef || (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type) === customtypes_1.GroupFieldType) &&
@@ -141,6 +143,17 @@ function traverseGroupItemsContent({ path, model, content, }) {
                         content: fieldContent,
                     })(transform);
                 }
+                else if ((!fieldDef ||
+                    ((fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type) === "Link" && ((_a = fieldDef.config) === null || _a === void 0 ? void 0 : _a.repeat))) &&
+                    fieldContent.__TYPE__ === "RepeatableContent") {
+                    transformedField = (0, RepeatableContent_1.traverseRepeatableContent)({
+                        path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
+                        key: fieldKey,
+                        apiId: fieldKey,
+                        model: fieldDef,
+                        content: fieldContent,
+                    })(transform);
+                }
                 else {
                     transformedField = transform({
                         path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),

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

@@ -0,0 +1,162 @@
+import * as t from "io-ts";
+import type { ContentPath, TraverseWidgetContentFn } from "../../_internal/utils";
+import type { Link, NestableWidget } from "../../customtypes";
+import type { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
+export declare const RepeatableContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"RepeatableContent">;
+    type: t.LiteralC<"Link">;
+    value: t.ArrayC<t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"LinkContent">;
+        value: t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"ImageLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            kind: t.StringC;
+            id: t.StringC;
+            url: t.StringC;
+            height: t.StringC;
+            width: t.StringC;
+            size: t.StringC;
+            name: t.StringC;
+        }>>, t.ExactC<t.PartialC<{
+            date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        }>>]>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"image">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"FileLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+            kind: t.StringC;
+            id: t.StringC;
+            url: t.StringC;
+            name: t.StringC;
+            size: t.StringC;
+        }>, t.PartialC<{
+            date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        }>]>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"file">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"DocumentLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            id: t.Type<string, string, unknown>;
+        }>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"document">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"ExternalLink">;
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+            url: t.StringC;
+        }>, t.PartialC<{
+            kind: t.LiteralC<"web">;
+            target: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+            preview: t.UnionC<[t.Type<{
+                title?: string;
+            }, {
+                title?: string;
+            }, unknown>, t.NullC, t.UndefinedC]>;
+        }>]>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"web">;
+            text: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"MediaLink">;
+        }>>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"media">;
+            text: t.StringC;
+        }>>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"AnyLink">;
+        }>>, t.ExactC<t.TypeC<{
+            text: t.StringC;
+        }>>]>]>;
+    }>>>;
+}>>;
+export declare type RepeatableContent = t.TypeOf<typeof RepeatableContent>;
+export declare const isRepeatableContent: t.Is<{
+    __TYPE__: "RepeatableContent";
+    type: "Link";
+    value: {
+        __TYPE__: "LinkContent";
+        value: ({
+            __TYPE__: "ImageLink";
+        } & (({
+            kind: string;
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+        } & {
+            date?: string | null | undefined;
+        } & {
+            text?: string;
+        }) | {
+            kind: "image";
+            text: string;
+        })) | ({
+            __TYPE__: "FileLink";
+        } & (({
+            kind: string;
+            id: string;
+            url: string;
+            name: string;
+            size: string;
+        } & {
+            date?: string | null | undefined;
+        } & {
+            text?: string;
+        }) | {
+            kind: "file";
+            text: string;
+        })) | ({
+            __TYPE__: "MediaLink";
+        } & {
+            kind: "media";
+            text: string;
+        }) | ({
+            __TYPE__: "DocumentLink";
+        } & (({
+            id: string;
+        } & {
+            text?: string;
+        }) | {
+            kind: "document";
+            text: string;
+        })) | ({
+            __TYPE__: "ExternalLink";
+        } & (({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        } & {
+            text?: string;
+        }) | {
+            kind: "web";
+            text: string;
+        })) | ({
+            __TYPE__: "AnyLink";
+        } & {
+            text: string;
+        });
+    }[];
+}>;
+export declare const RepeatableLegacy: (ctx: LegacyContentCtx, fieldType: "Link") => t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown>;
+export declare type RepeatableCustomType = Link;
+export declare function traverseRepeatableContent({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    content: RepeatableContent;
+    model?: NestableWidget | undefined;
+}): (transform: TraverseWidgetContentFn) => RepeatableContent | undefined;

package/lib/content/fields/RepeatableContent.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseRepeatableContent = exports.RepeatableLegacy = exports.isRepeatableContent = exports.RepeatableContent = 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 nestable_1 = require("./nestable");
+exports.RepeatableContent = t.strict({
+    __TYPE__: t.literal("RepeatableContent"),
+    type: t.literal("Link"),
+    value: t.array(nestable_1.LinkContent),
+});
+exports.isRepeatableContent = exports.RepeatableContent.is;
+const RepeatableLegacy = (ctx, fieldType) => {
+    return new t.Type("RepeatableLegacy", exports.isRepeatableContent, (items) => {
+        const parsed = (0, function_1.pipe)(t.array(t.unknown).decode(items), fp_ts_1.either.map((items) => {
+            const parsedItems = items.reduce((acc, item) => {
+                let result;
+                switch (fieldType) {
+                    case "Link":
+                        result = (0, nestable_1.LinkContentLegacy)(ctx).decode(item);
+                        break;
+                }
+                if (!result)
+                    return acc;
+                if ((0, Either_1.isLeft)(result))
+                    return acc;
+                return [...acc, result.right];
+            }, []);
+            return {
+                value: parsedItems,
+                type: fieldType,
+                __TYPE__: "RepeatableContent",
+            };
+        }));
+        return parsed;
+    }, (r) => {
+        const res = t.array(nestable_1.LinkContent).encode(r.value);
+        const encodedItems = res.reduce((acc, item) => {
+            let encoded;
+            switch (item.__TYPE__) {
+                case nestable_1.LinkContentType:
+                    encoded = (0, nestable_1.LinkContentLegacy)(ctx).encode(item);
+                    break;
+            }
+            if (!encoded)
+                return acc;
+            return [...acc, encoded];
+        }, []);
+        return {
+            content: encodedItems.map((encodedItem) => encodedItem.content),
+            types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
+        };
+    });
+};
+exports.RepeatableLegacy = RepeatableLegacy;
+function traverseRepeatableContent({ path, key, apiId, model, content, }) {
+    return (transform) => {
+        const items = content.value.reduce((acc, fieldContent, index) => {
+            const itemPath = path.concat([
+                { key: index.toString(), type: "Widget" },
+            ]);
+            const transformedField = transform({
+                path: itemPath,
+                key: key,
+                apiId: apiId,
+                model: model,
+                content: fieldContent,
+            });
+            // Can happen if the transform function returns undefined to filter out a field
+            if (!transformedField)
+                return acc;
+            // If the transformed field is not a link content, we don't include it
+            if (!(0, nestable_1.isLinkContent)(transformedField))
+                return acc;
+            return acc.concat(transformedField);
+        }, []);
+        return transform({
+            path,
+            key,
+            apiId,
+            model,
+            content: {
+                __TYPE__: content.__TYPE__,
+                type: content.type,
+                value: items,
+            },
+        });
+    };
+}
+exports.traverseRepeatableContent = traverseRepeatableContent;