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

package/lib/src/content/fields/nestable/NestableContent.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestableLegacy = exports.isNestableContent = exports.NestableContentDefaultValue = exports.NestableContent = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/lib/Either");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const EmptyContent_1 = require("../EmptyContent");
+const BooleanContent_1 = require("./BooleanContent");
+const EmbedContent_1 = require("./EmbedContent");
+const FieldContent_1 = require("./FieldContent");
+const common_1 = require("./FieldContent/common");
+const GeoPointContent_1 = require("./GeoPointContent");
+const ImageContent_1 = require("./ImageContent");
+const IntegrationFieldContent_1 = require("./IntegrationFieldContent");
+const LinkContent_1 = require("./LinkContent");
+const RepeatableContent_1 = require("./RepeatableContent");
+const RichTextContent_1 = require("./RichTextContent");
+const SeparatorContent_1 = require("./SeparatorContent");
+const TableContent_1 = require("./TableContent");
+exports.NestableContent = t.union([
+    EmptyContent_1.EmptyContent,
+    BooleanContent_1.BooleanContent,
+    EmbedContent_1.EmbedContent,
+    FieldContent_1.TextContent,
+    FieldContent_1.TimestampContent,
+    FieldContent_1.SelectContent,
+    FieldContent_1.RangeContent,
+    FieldContent_1.NumberContent,
+    FieldContent_1.DateContent,
+    FieldContent_1.ColorContent,
+    GeoPointContent_1.GeoPointContent,
+    ImageContent_1.ImageContent,
+    IntegrationFieldContent_1.IntegrationFieldContent,
+    LinkContent_1.LinkContent,
+    RichTextContent_1.RichTextContent,
+    SeparatorContent_1.SeparatorContent,
+    TableContent_1.TableContent,
+    RepeatableContent_1.RepeatableContent,
+]);
+const NestableContentDefaultValue = (widgetDef) => {
+    switch (widgetDef.type) {
+        case "Boolean":
+            return (0, BooleanContent_1.BooleanContentDefaultValue)(widgetDef);
+        case "Select":
+            return (0, FieldContent_1.SelectContentDefaultValue)(widgetDef);
+        default:
+            return undefined;
+    }
+};
+exports.NestableContentDefaultValue = NestableContentDefaultValue;
+const isNestableContent = (u) => (0, FieldContent_1.isTextContent)(u) ||
+    (0, FieldContent_1.isColorContent)(u) ||
+    (0, FieldContent_1.isDateContent)(u) ||
+    (0, FieldContent_1.isTimestampContent)(u) ||
+    (0, FieldContent_1.isNumberContent)(u) ||
+    (0, FieldContent_1.isRangeContent)(u) ||
+    (0, FieldContent_1.isSelectContent)(u) ||
+    (0, GeoPointContent_1.isGeoPointContent)(u) ||
+    (0, RichTextContent_1.isRichTextContent)(u) ||
+    (0, BooleanContent_1.isBooleanContent)(u) ||
+    (0, EmbedContent_1.isEmbedContent)(u) ||
+    (0, ImageContent_1.isImageContent)(u) ||
+    (0, IntegrationFieldContent_1.isIntegrationFieldContent)(u) ||
+    (0, LinkContent_1.isLinkContent)(u) ||
+    (0, SeparatorContent_1.isSeparatorContent)(u) ||
+    (0, TableContent_1.isTableContent)(u) ||
+    (0, EmptyContent_1.isEmptyContent)(u) ||
+    (0, RepeatableContent_1.isRepeatableContent)(u);
+exports.isNestableContent = isNestableContent;
+const NestableLegacy = (ctx) => {
+    return {
+        decode(value) {
+            if (!ctx.fieldType)
+                return;
+            const nullValue = (0, EmptyContent_1.EmptyLegacy)(ctx.fieldType).decode(value);
+            if ((0, Either_1.isRight)(nullValue))
+                return nullValue;
+            const codec = (() => {
+                switch (ctx.fieldType) {
+                    case "Text":
+                        return (0, FieldContent_1.TextLegacy)(ctx);
+                    case "Color":
+                        return (0, FieldContent_1.ColorLegacy)(ctx);
+                    case "Date":
+                        return (0, FieldContent_1.DateLegacy)(ctx);
+                    case "Timestamp":
+                        return (0, FieldContent_1.TimestampLegacy)(ctx);
+                    case "Number":
+                        return (0, FieldContent_1.NumberLegacy)(ctx);
+                    case "Range":
+                        return (0, FieldContent_1.RangeLegacy)(ctx);
+                    case "Select":
+                        return (0, FieldContent_1.SelectLegacy)(ctx);
+                    case "GeoPoint":
+                        return (0, GeoPointContent_1.GeoPointLegacy)(ctx);
+                    case "StructuredText":
+                        return (0, RichTextContent_1.RichTextLegacy)(ctx);
+                    case "Boolean":
+                        return (0, BooleanContent_1.BooleanLegacy)(ctx);
+                    case "Embed":
+                        return (0, EmbedContent_1.EmbedLegacy)(ctx);
+                    case "Image":
+                        return (0, ImageContent_1.ImageLegacy)(ctx);
+                    case "IntegrationFields":
+                        return (0, IntegrationFieldContent_1.IntegrationFieldLegacy)(ctx);
+                    case "Link":
+                        return (0, LinkContent_1.LinkContentLegacy)(ctx);
+                    case "Separator":
+                        return (0, SeparatorContent_1.SeparatorLegacy)(ctx);
+                    case "Table":
+                        return (0, TableContent_1.TableLegacy)(ctx);
+                    case "Repeatable.Link":
+                        return (0, RepeatableContent_1.RepeatableLegacy)(ctx, "Link");
+                    default:
+                        return;
+                }
+            })();
+            if (!codec)
+                return;
+            return codec.decode(value);
+        },
+        encode(value) {
+            switch (value.__TYPE__) {
+                case common_1.FieldContentType: {
+                    if (value.type === "Text")
+                        return (0, FieldContent_1.TextLegacy)(ctx).encode(value);
+                    if (value.type === "Color")
+                        return (0, FieldContent_1.ColorLegacy)(ctx).encode(value);
+                    if (value.type === "Range")
+                        return (0, FieldContent_1.RangeLegacy)(ctx).encode(value);
+                    if (value.type === "Date")
+                        return (0, FieldContent_1.DateLegacy)(ctx).encode(value);
+                    if (value.type === "Number")
+                        return (0, FieldContent_1.NumberLegacy)(ctx).encode(value);
+                    if (value.type === "Timestamp")
+                        return (0, FieldContent_1.TimestampLegacy)(ctx).encode(value);
+                    if (value.type === "Select")
+                        return (0, FieldContent_1.SelectLegacy)(ctx).encode(value);
+                    return;
+                }
+                case GeoPointContent_1.GeoPointContentType:
+                    return (0, GeoPointContent_1.GeoPointLegacy)(ctx).encode(value);
+                case RichTextContent_1.RichTextContentType:
+                    return (0, RichTextContent_1.RichTextLegacy)(ctx).encode(value);
+                case EmbedContent_1.EmbedContentType:
+                    return (0, EmbedContent_1.EmbedLegacy)(ctx).encode(value);
+                case BooleanContent_1.BooleanContentType:
+                    return (0, BooleanContent_1.BooleanLegacy)(ctx).encode(value);
+                case ImageContent_1.ImageContentType:
+                    return (0, ImageContent_1.ImageLegacy)(ctx).encode(value);
+                case IntegrationFieldContent_1.IntegrationFieldContentType:
+                    return (0, IntegrationFieldContent_1.IntegrationFieldLegacy)(ctx).encode(value);
+                case LinkContent_1.LinkContentType:
+                    return (0, LinkContent_1.LinkContentLegacy)(ctx).encode(value);
+                case SeparatorContent_1.SeparatorContentType:
+                    return (0, SeparatorContent_1.SeparatorLegacy)(ctx).encode(value);
+                case TableContent_1.TableContentType:
+                    return (0, TableContent_1.TableLegacy)(ctx).encode(value);
+                case "RepeatableContent":
+                    return (0, RepeatableContent_1.RepeatableLegacy)(ctx, value.type).encode(value);
+                default:
+                    return;
+            }
+        },
+    };
+};
+exports.NestableLegacy = NestableLegacy;

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

@@ -0,0 +1,176 @@
+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.IntersectionC<[t.ExactC<t.TypeC<{
+        key: t.Type<string, string, unknown>;
+    }>>, t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"LinkContent">;
+        value: t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"ImageLink">;
+        }>>, t.IntersectionC<[t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            kind: t.Type<"image", "image", unknown>;
+            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.TypeC<{
+            kind: t.LiteralC<"image">;
+        }>>]>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+            variant: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"FileLink">;
+        }>>, t.IntersectionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+            kind: t.Type<"file", "file", unknown>;
+            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.TypeC<{
+            kind: t.LiteralC<"file">;
+        }>>]>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+            variant: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"DocumentLink">;
+        }>>, t.IntersectionC<[t.UnionC<[t.ExactC<t.TypeC<{
+            id: t.Type<string, string, unknown>;
+        }>>, t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"document">;
+        }>>]>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+            variant: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"ExternalLink">;
+        }>>, t.IntersectionC<[t.UnionC<[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.TypeC<{
+            kind: t.LiteralC<"web">;
+        }>>]>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+            variant: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"MediaLink">;
+        }>>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            kind: t.LiteralC<"media">;
+        }>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+            variant: t.StringC;
+        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+            __TYPE__: t.LiteralC<"AnyLink">;
+        }>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+            kind: t.LiteralC<"any">;
+        }>, t.PartialC<{
+            text: t.StringC;
+            variant: t.StringC;
+        }>]>>]>]>;
+    }>>]>>;
+}>>;
+export declare type RepeatableContent = t.TypeOf<typeof RepeatableContent>;
+export declare const isRepeatableContent: (u: unknown) => u is {
+    __TYPE__: "RepeatableContent";
+    type: "Link";
+    value: ({
+        key: string;
+    } & {
+        __TYPE__: "LinkContent";
+        value: ({
+            __TYPE__: "ImageLink";
+        } & ((({
+            kind: "image";
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+        } & {
+            date?: string | null | undefined;
+        }) | {
+            kind: "image";
+        }) & {
+            text?: string;
+            variant?: string;
+        })) | ({
+            __TYPE__: "FileLink";
+        } & ((({
+            kind: "file";
+            id: string;
+            url: string;
+            name: string;
+            size: string;
+        } & {
+            date?: string | null | undefined;
+        }) | {
+            kind: "file";
+        }) & {
+            text?: string;
+            variant?: string;
+        })) | ({
+            __TYPE__: "MediaLink";
+        } & {
+            kind: "media";
+        } & {
+            text?: string;
+            variant?: string;
+        }) | ({
+            __TYPE__: "DocumentLink";
+        } & (({
+            id: string;
+        } | {
+            kind: "document";
+        }) & {
+            text?: string;
+            variant?: string;
+        })) | ({
+            __TYPE__: "ExternalLink";
+        } & ((({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        }) | {
+            kind: "web";
+        }) & {
+            text?: string;
+            variant?: string;
+        })) | ({
+            __TYPE__: "AnyLink";
+        } & {
+            kind: "any";
+        } & {
+            text?: string;
+            variant?: 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/src/content/fields/nestable/RepeatableContent.js

@@ -0,0 +1,104 @@
+"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 utils_1 = require("../../utils");
+const LinkContent_1 = require("./LinkContent");
+const RepeatableContentType = "RepeatableContent";
+exports.RepeatableContent = t.strict({
+    __TYPE__: t.literal(RepeatableContentType),
+    type: t.literal("Link"),
+    value: t.array(LinkContent_1.LinkContent),
+});
+const isRepeatableContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === RepeatableContentType;
+exports.isRepeatableContent = isRepeatableContent;
+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, LinkContent_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(LinkContent_1.LinkContent).encode(r.value);
+        const encodedItems = res.reduce((acc, item) => {
+            let encoded;
+            switch (item.__TYPE__) {
+                case LinkContent_1.LinkContentType:
+                    encoded = (0, LinkContent_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}` },
+            keys: encodedItems.reduce((acc, item) => ({ ...acc, ...item.keys }), {}),
+        };
+    });
+};
+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" },
+            ]);
+            // Content inside repeatable can't be repeatable.
+            const newModel = (model === null || model === void 0 ? void 0 : model.type) === "Link" && model.config
+                ? {
+                    ...model,
+                    config: { ...model.config, repeat: false },
+                }
+                : model;
+            const transformedField = transform({
+                path: itemPath,
+                key: key,
+                apiId: apiId,
+                model: newModel,
+                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, LinkContent_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;