@prismicio/types-internal 3.4.0-alpha.2 → 3.4.0-alpha.4

package/lib/content/fields/nestable/RichTextContent/Block.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = exports.BlockLegacy = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const EmbedBlock_1 = require("./EmbedBlock");
+const ImageBlock_1 = require("./ImageBlock");
+const TableBlock_1 = require("./TableBlock");
+const TextBlock_1 = require("./TextBlock");
+const legacyBlockCodec = t.union([
+    EmbedBlock_1.EmbedBlockLegacy,
+    ImageBlock_1.ImageBlockLegacy,
+    TextBlock_1.TextBlockLegacy,
+    TableBlock_1.TableBlockLegacy,
+]);
+exports.BlockLegacy = new t.Type("BlockLegacy", (u) => EmbedBlock_1.EmbedBlockLegacy.is(u) ||
+    ImageBlock_1.ImageBlockLegacy.is(u) ||
+    TextBlock_1.TextBlockLegacy.is(u) ||
+    TableBlock_1.TableBlockLegacy.is(u), (legacyBlock) => legacyBlockCodec.decode(legacyBlock), (block) => {
+    return (() => {
+        if (ImageBlock_1.ImageBlock.is(block))
+            return ImageBlock_1.ImageBlockLegacy.encode(block);
+        else if (EmbedBlock_1.EmbedBlock.is(block))
+            return EmbedBlock_1.EmbedBlockLegacy.encode(block);
+        else if (TableBlock_1.TableBlock.is(block))
+            return TableBlock_1.TableBlockLegacy.encode(block);
+        else
+            return TextBlock_1.TextBlockLegacy.encode(block);
+    })();
+});
+exports.Block = t.union([ImageBlock_1.ImageBlock, EmbedBlock_1.EmbedBlock, TextBlock_1.TextBlock, TableBlock_1.TableBlock]);

package/lib/content/fields/nestable/RichTextContent/EmbedBlock.d.ts

@@ -0,0 +1,60 @@
+import * as t from "io-ts";
+import type { Block } from "./Block";
+export declare const EmbedBlockLegacy: t.Type<{
+    type: "embed";
+    data: {
+        embed_url: string;
+        type: string;
+    } & {
+        version?: string | number | null;
+        title?: string | null | undefined;
+        author_name?: string | null | undefined;
+        author_url?: string | null | undefined;
+        provider_name?: string | null | undefined;
+        provider_url?: string | null | undefined;
+        cache_age?: string | number | null;
+        thumbnail_url?: string | null | undefined;
+        thumbnail_width?: number | null | undefined;
+        thumbnail_height?: number | null | undefined;
+        html?: string | null | undefined;
+    } & {
+        __TYPE__: "EmbedContent";
+        all: unknown;
+    };
+} & {
+    label?: string | null | undefined;
+    direction?: string | null | undefined;
+}, {
+    type: "embed";
+    data: unknown;
+} & {
+    label?: string | null | undefined;
+    direction?: string | null | undefined;
+}, unknown>;
+export declare const EmbedBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"embed">;
+    data: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        embed_url: t.StringC;
+        type: t.StringC;
+    }>, t.PartialC<{
+        version: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+        title: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        author_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        author_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        provider_name: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        provider_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        cache_age: t.UnionC<[t.StringC, t.NumberC, t.NullC]>;
+        thumbnail_url: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        thumbnail_width: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+        thumbnail_height: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+        html: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"EmbedContent">;
+        all: t.UnknownC;
+    }>>]>;
+}>, t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type EmbedBlock = t.TypeOf<typeof EmbedBlock>;
+export declare function checkEmbedBlock(block: Block): block is EmbedBlock;

package/lib/content/fields/nestable/RichTextContent/EmbedBlock.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEmbedBlock = exports.EmbedBlock = exports.EmbedBlockLegacy = 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 nestable_1 = require("../../../../customtypes/widgets/nestable");
+const validators_1 = require("../../../../validators");
+const EmbedContent_1 = require("../EmbedContent");
+const embedBlockLegacyCodec = t.exact(t.intersection([
+    t.type({
+        type: t.literal(nestable_1.RichTextNodeType.embed),
+        data: t.unknown,
+    }),
+    t.partial({
+        label: validators_1.StringOrNull,
+        direction: validators_1.StringOrNull,
+    }),
+]));
+exports.EmbedBlockLegacy = new t.Type("EmbedBlockLegacy", (u) => u.type === "embed", (block) => (0, function_1.pipe)(embedBlockLegacyCodec.decode(block), fp_ts_1.either.chain((decodedBlock) => {
+    return fp_ts_1.either.map((decodedData) => {
+        return [decodedBlock, decodedData];
+    })(EmbedContent_1.EmbedContentLegacy.decode(decodedBlock.data));
+}), fp_ts_1.either.map(([block, parsedData]) => {
+    return exports.EmbedBlock.encode({
+        ...block,
+        data: {
+            ...parsedData,
+            __TYPE__: EmbedContent_1.EmbedContentType,
+            all: block.data,
+        },
+    });
+})), (embedBlock) => {
+    return {
+        ...embedBlockLegacyCodec.encode(embedBlock),
+        data: EmbedContent_1.EmbedContentLegacy.encode(embedBlock.data),
+    };
+});
+exports.EmbedBlock = t.exact(t.intersection([
+    t.type({
+        type: t.literal(nestable_1.RichTextNodeType.embed),
+        data: EmbedContent_1.EmbedContent,
+    }),
+    t.partial({
+        label: validators_1.StringOrNull,
+        direction: validators_1.StringOrNull,
+    }),
+]));
+function checkEmbedBlock(block) {
+    return block.type === nestable_1.RichTextNodeType.embed;
+}
+exports.checkEmbedBlock = checkEmbedBlock;

package/lib/content/fields/nestable/RichTextContent/ImageBlock.d.ts

@@ -0,0 +1,203 @@
+import * as t from "io-ts";
+import type { Block } from "./Block";
+export declare const ImageBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"image">;
+    data: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        origin: t.ExactC<t.TypeC<{
+            id: t.StringC;
+            url: t.StringC;
+            width: t.NumberC;
+            height: t.NumberC;
+        }>>;
+        width: t.NumberC;
+        height: t.NumberC;
+        edit: t.TypeC<{
+            zoom: t.NumberC;
+            crop: t.TypeC<{
+                x: t.NumberC;
+                y: t.NumberC;
+            }>;
+            background: t.StringC;
+        }>;
+    }>, t.PartialC<{
+        url: t.StringC;
+        credits: t.Type<string | null, string | null, unknown>;
+        alt: t.Type<string | null, string | null, unknown>;
+        provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.PartialC<{
+        linkTo: t.UnionC<[t.Type<({
+            __TYPE__: "ImageLink";
+        } & {
+            kind: "image";
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+        } & {
+            date?: string | null | undefined;
+        }) | ({
+            __TYPE__: "FileLink";
+        } & {
+            kind: "file";
+            id: string;
+            url: string;
+            name: string;
+            size: string;
+        } & {
+            date?: string | null | undefined;
+        }) | ({
+            __TYPE__: "DocumentLink";
+        } & {
+            id: string;
+        }) | ({
+            __TYPE__: "ExternalLink";
+        } & {
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        }), ({
+            __TYPE__: "ImageLink";
+        } & {
+            kind: "image";
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+        } & {
+            date?: string | null | undefined;
+        }) | ({
+            __TYPE__: "FileLink";
+        } & {
+            kind: "file";
+            id: string;
+            url: string;
+            name: string;
+            size: string;
+        } & {
+            date?: string | null | undefined;
+        }) | ({
+            __TYPE__: "DocumentLink";
+        } & {
+            id: string;
+        }) | ({
+            __TYPE__: "ExternalLink";
+        } & {
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        }), unknown>, t.NullC, t.UndefinedC]>;
+    }>]>;
+}>, t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type ImageBlock = t.TypeOf<typeof ImageBlock>;
+export declare const ImageBlockLegacy: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"image">;
+    data: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        origin: t.ExactC<t.TypeC<{
+            id: t.StringC;
+            url: t.StringC;
+            width: t.NumberC;
+            height: t.NumberC;
+        }>>;
+        width: t.NumberC;
+        height: t.NumberC;
+        edit: t.TypeC<{
+            zoom: t.NumberC;
+            crop: t.TypeC<{
+                x: t.NumberC;
+                y: t.NumberC;
+            }>;
+            background: t.StringC;
+        }>;
+    }>, t.PartialC<{
+        url: t.StringC;
+        credits: t.Type<string | null, string | null, unknown>;
+        alt: t.Type<string | null, string | null, unknown>;
+        provider: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.PartialC<{
+        linkTo: t.UnionC<[t.Type<({
+            __TYPE__: "ImageLink";
+        } & {
+            kind: "image";
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+        } & {
+            date?: string | null | undefined;
+        }) | ({
+            __TYPE__: "FileLink";
+        } & {
+            kind: "file";
+            id: string;
+            url: string;
+            name: string;
+            size: string;
+        } & {
+            date?: string | null | undefined;
+        }) | ({
+            __TYPE__: "DocumentLink";
+        } & {
+            id: string;
+        }) | ({
+            __TYPE__: "ExternalLink";
+        } & {
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        }), ({
+            kind: "image";
+            id: string;
+            url: string;
+            height: string;
+            width: string;
+            size: string;
+            name: string;
+        } & {
+            date?: string | null | undefined;
+        }) | ({
+            kind: "file";
+            id: string;
+            url: string;
+            name: string;
+            size: string;
+        } & {
+            date?: string | null | undefined;
+        }) | {
+            id: string;
+        } | ({
+            url: string;
+        } & {
+            kind?: "web";
+            target?: string | null | undefined;
+            preview?: {
+                title?: string;
+            } | null | undefined;
+        }), unknown>, t.NullC, t.UndefinedC]>;
+    }>]>;
+}>, t.PartialC<{
+    label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+}>]>>;
+export declare type ImageBlockLegacy = t.TypeOf<typeof ImageBlockLegacy>;
+export declare function checkImageBlock(block: Block): block is ImageBlock;

package/lib/content/fields/nestable/RichTextContent/ImageBlock.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImageBlock = exports.ImageBlockLegacy = exports.ImageBlock = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const nestable_1 = require("../../../../customtypes/widgets/nestable");
+const validators_1 = require("../../../../validators");
+const function_1 = require("../../../../validators/function");
+const ImageContent_1 = require("../ImageContent");
+const LinkContent_1 = require("../LinkContent");
+// We allow any codec here and let TypeScript infer the resulting codec.
+// Typing it more precisely creates conflicts.
+//
+// Using `t.Mixed` rather than `t.Type<A, O>` causes `data.linkTo` to be
+// typed as `any`. It seems to be an issue with the `nullable` helper.
+const ImageBlockCodec = (linkCodec) => t.exact(t.intersection([
+    t.type({
+        type: t.literal(nestable_1.RichTextNodeType.image),
+        data: t.intersection([
+            ImageContent_1.ImageContentView,
+            t.partial({
+                linkTo: (0, function_1.nullable)(linkCodec),
+            }),
+        ]),
+    }),
+    t.partial({
+        label: validators_1.StringOrNull,
+        direction: validators_1.StringOrNull,
+    }),
+]));
+exports.ImageBlock = ImageBlockCodec(LinkContent_1.FilledLink);
+exports.ImageBlockLegacy = ImageBlockCodec(LinkContent_1.FilledLinkLegacy);
+function checkImageBlock(block) {
+    return block.type === nestable_1.RichTextNodeType.image;
+}
+exports.checkImageBlock = checkImageBlock;