@prismicio/types-internal 3.13.0 → 3.14.0

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;