@prismicio/types-internal 2.2.0-alpha.2 → 2.2.0-alpha.21

package/lib/import/validators/fields/nestable/Image/index.d.ts

@@ -0,0 +1,45 @@
+import * as t from "io-ts";
+import type { ImageFieldWithThumbnails } from "./model";
+export declare const ImageFieldCodec: (field?: ({
+    type: "Image";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        constraint?: {
+            width?: number | null;
+            height?: number | null;
+        };
+        thumbnails?: readonly ({
+            name: string;
+        } & {
+            width?: number | null;
+            height?: number | null;
+        })[];
+    };
+}) | undefined) => t.Type<ImageFieldWithThumbnails, ImageFieldWithThumbnails, unknown>;
+export declare const ImportImage: (field?: ({
+    type: "Image";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        constraint?: {
+            width?: number | null;
+            height?: number | null;
+        };
+        thumbnails?: readonly ({
+            name: string;
+        } & {
+            width?: number | null;
+            height?: number | null;
+        })[];
+    };
+}) | undefined) => t.Type<{
+    type: "Image";
+    value: ImageFieldWithThumbnails | null;
+}, ImageFieldWithThumbnails | undefined, unknown>;
+export declare type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>;
+export * from "./model";

package/lib/import/validators/fields/nestable/Image/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportImage = exports.ImageFieldCodec = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../validators");
+const function_2 = require("../../../../../validators/function");
+const ImportContent_1 = require("../../ImportContent");
+const default_1 = require("./default");
+const merge_1 = require("./merge");
+const validators_2 = require("./validators");
+/* For code clarity, the output of this validator will be simplified
+ *
+ *  Input -> type ImageAPIV2 = ImportImageView & ImportThumbnails
+ *  Output -> type ImageWithThumbnails 👇
+ */
+const ImageFieldCodec = (field) => new t.Type("ImageField", (u) => validators_2.ImportImageView.is(u) &&
+    "thumbnails" in u &&
+    validators_2.ImportThumbnails.is(u["thumbnails"]), (u, ctx) => {
+    return (0, function_1.pipe)(
+    // Validating the higher level image
+    validators_2.ImportImageView.validate(u, ctx), (0, Either_1.chain)((imageApiV2) => {
+        const { id, dimensions, edit, copyright, alt, ...thumbnails } = imageApiV2;
+        return (0, function_1.pipe)(
+        // Validating the thumbnails
+        validators_2.ImportThumbnails.validate(thumbnails, ctx), (0, Either_1.map)((thumbnails) => {
+            var _a;
+            return ({
+                ...(0, merge_1.mergeImageViewWithCtConstraints)(imageApiV2, imageApiV2, (_a = field === null || field === void 0 ? void 0 : field.config) === null || _a === void 0 ? void 0 : _a.constraint),
+                thumbnails: (0, merge_1.mergeThumbnailsWithCtConstraints)(thumbnails, imageApiV2, field),
+            });
+        }));
+    }));
+}, t.identity);
+exports.ImageFieldCodec = ImageFieldCodec;
+const ImageCodec = (field) => (0, function_2.withCustomError)((0, validators_1.DefaultOrElse)((0, default_1.defaultImportImage)(field))((0, exports.ImageFieldCodec)(field)), () => "An image field must be an object");
+const ImportImage = (field) => (0, ImportContent_1.ImportContent)("Image", ImageCodec(field));
+exports.ImportImage = ImportImage;
+(0, tslib_1.__exportStar)(require("./model"), exports);

package/lib/import/validators/fields/nestable/Image/merge.d.ts

@@ -0,0 +1,23 @@
+import type ImageConstraint from "../../../../../customtypes/widgets/shared/ImageConstraint";
+import type { ImageField } from "./model";
+import type { ImportImageView, ImportThumbnails } from "./validators";
+export declare const mergeImageViewWithCtConstraints: (image: ImportImageView | undefined, defaultImage: ImportImageView, constraints: ImageConstraint | undefined) => ImageField;
+export declare const mergeThumbnailsWithCtConstraints: (thumbnails: ImportThumbnails, defaultImage: ImportImageView, field?: ({
+    type: "Image";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        constraint?: {
+            width?: number | null;
+            height?: number | null;
+        };
+        thumbnails?: readonly ({
+            name: string;
+        } & {
+            width?: number | null;
+            height?: number | null;
+        })[];
+    };
+}) | undefined) => {};

package/lib/import/validators/fields/nestable/Image/merge.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeThumbnailsWithCtConstraints = exports.mergeImageViewWithCtConstraints = void 0;
+/* This function merges user input with custom type constraints.
+ *  If a thumbnails' data are missing (`image`) then the default is used (`defaultImage`)
+ */
+const mergeImageViewWithCtConstraints = (image, defaultImage, constraints) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    const background = (_a = image === null || image === void 0 ? void 0 : image.edit) === null || _a === void 0 ? void 0 : _a.background;
+    const width = (_d = (_b = constraints === null || constraints === void 0 ? void 0 : constraints.width) !== null && _b !== void 0 ? _b : (_c = image === null || image === void 0 ? void 0 : image.dimensions) === null || _c === void 0 ? void 0 : _c.width) !== null && _d !== void 0 ? _d : (_e = defaultImage === null || defaultImage === void 0 ? void 0 : defaultImage.dimensions) === null || _e === void 0 ? void 0 : _e.width;
+    const height = (_h = (_f = constraints === null || constraints === void 0 ? void 0 : constraints.height) !== null && _f !== void 0 ? _f : (_g = image === null || image === void 0 ? void 0 : image.dimensions) === null || _g === void 0 ? void 0 : _g.height) !== null && _h !== void 0 ? _h : (_j = defaultImage === null || defaultImage === void 0 ? void 0 : defaultImage.dimensions) === null || _j === void 0 ? void 0 : _j.height;
+    const alt = image === null || image === void 0 ? void 0 : image.alt;
+    const copyright = image === null || image === void 0 ? void 0 : image.copyright;
+    return {
+        id: (_k = image === null || image === void 0 ? void 0 : image.id) !== null && _k !== void 0 ? _k : defaultImage === null || defaultImage === void 0 ? void 0 : defaultImage.id,
+        edit: {
+            x: (_m = (_l = image === null || image === void 0 ? void 0 : image.edit) === null || _l === void 0 ? void 0 : _l.x) !== null && _m !== void 0 ? _m : 0,
+            y: (_p = (_o = image === null || image === void 0 ? void 0 : image.edit) === null || _o === void 0 ? void 0 : _o.y) !== null && _p !== void 0 ? _p : 0,
+            zoom: (_r = (_q = image === null || image === void 0 ? void 0 : image.edit) === null || _q === void 0 ? void 0 : _q.zoom) !== null && _r !== void 0 ? _r : 1,
+            ...(background !== undefined ? { background } : {}),
+        },
+        dimensions: {
+            ...(width !== undefined ? { width } : {}),
+            ...(height !== undefined ? { height } : {}),
+        },
+        ...(alt !== undefined ? { alt } : {}),
+        ...(copyright !== undefined ? { copyright } : {}),
+    };
+};
+exports.mergeImageViewWithCtConstraints = mergeImageViewWithCtConstraints;
+/* This function handles each thumbnail defined in the custom type.
+ *
+ *  For each of them it merges the user input with custom type constraints.
+ *
+ *  If a thumbnail is missing, the data from the default image is used.
+ */
+const mergeThumbnailsWithCtConstraints = (thumbnails, defaultImage, field) => {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = field === null || field === void 0 ? void 0 : field.config) === null || _a === void 0 ? void 0 : _a.thumbnails) === null || _b === void 0 ? void 0 : _b.reduce((acc, thumbnail) => ({
+        ...acc,
+        [thumbnail.name]: (0, exports.mergeImageViewWithCtConstraints)(thumbnails[thumbnail.name], defaultImage, thumbnail),
+    }), {})) !== null && _c !== void 0 ? _c : {};
+};
+exports.mergeThumbnailsWithCtConstraints = mergeThumbnailsWithCtConstraints;

package/lib/import/validators/fields/nestable/Image/model.d.ts

@@ -0,0 +1,18 @@
+export declare type ImageField = {
+    id: string;
+    edit: {
+        x: number;
+        y: number;
+        zoom: number;
+        background?: string;
+    };
+    dimensions: {
+        width?: number;
+        height?: number;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+};
+export declare type ImageFieldWithThumbnails = ImageField & {
+    thumbnails: Record<string, ImageField>;
+};

package/lib/import/validators/fields/nestable/Image/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/import/validators/fields/nestable/Image/validators.d.ts

@@ -0,0 +1,35 @@
+import * as t from "io-ts";
+export declare const ImportImageView: t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+}>, t.PartialC<{
+    dimensions: t.PartialC<{
+        width: t.NumberC;
+        height: t.NumberC;
+    }>;
+    edit: t.PartialC<{
+        x: t.NumberC;
+        y: t.NumberC;
+        zoom: t.NumberC;
+        background: t.StringC;
+    }>;
+    copyright: t.UnionC<[t.StringC, t.NullC]>;
+    alt: t.UnionC<[t.StringC, t.NullC]>;
+}>]>;
+export declare type ImportImageView = t.TypeOf<typeof ImportImageView>;
+export declare const ImportThumbnails: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+}>, t.PartialC<{
+    dimensions: t.PartialC<{
+        width: t.NumberC;
+        height: t.NumberC;
+    }>;
+    edit: t.PartialC<{
+        x: t.NumberC;
+        y: t.NumberC;
+        zoom: t.NumberC;
+        background: t.StringC;
+    }>;
+    copyright: t.UnionC<[t.StringC, t.NullC]>;
+    alt: t.UnionC<[t.StringC, t.NullC]>;
+}>]>>;
+export declare type ImportThumbnails = t.TypeOf<typeof ImportThumbnails>;

package/lib/import/validators/fields/nestable/Image/validators.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportThumbnails = exports.ImportImageView = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const BasicTypes_1 = require("../../../../../validators/BasicTypes");
+const function_1 = require("../../../../../validators/function");
+exports.ImportImageView = (0, function_1.withCustomError)(t.intersection([
+    t.type({
+        // Image Id
+        id: BasicTypes_1.String,
+    }),
+    t.partial({
+        // Dimensions here will be used if they are not defined in the custom type
+        dimensions: (0, function_1.withCustomError)(t.partial({
+            width: BasicTypes_1.Number,
+            height: BasicTypes_1.Number,
+        }), () => "The value must be an object"),
+        // Crop information
+        edit: (0, function_1.withCustomError)(t.partial({
+            x: BasicTypes_1.Number,
+            y: BasicTypes_1.Number,
+            zoom: BasicTypes_1.Number,
+            background: BasicTypes_1.String,
+        }), () => "The value must be an object"),
+        // Copyrights and alt are set in the Asset by default but they can be overrided
+        copyright: BasicTypes_1.StringOrNull,
+        alt: BasicTypes_1.StringOrNull,
+    }),
+]), () => "The value must be an object");
+exports.ImportThumbnails = t.record(t.string, exports.ImportImageView);

package/lib/import/validators/fields/nestable/ImportRichText/ImportBlock.d.ts

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+import { ImportBlockType, ImportEmbedBlock, ImportImageBlock, ImportTextBlock } from "./blocks";
+export declare type ImportBlock = ImportTextBlock | ImportImageBlock | ImportEmbedBlock;
+export declare const ImportBlock: (allowedBlockTypes: string[]) => t.Type<ImportBlock, {
+    type: ImportBlockType;
+}, unknown>;

package/lib/import/validators/fields/nestable/ImportRichText/ImportBlock.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportBlock = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../../../validators/function");
+const blocks_1 = require("./blocks");
+const ImportBlock = (allowedBlockTypes) => (0, function_1.withCustomError)(t
+    .type({
+    type: (0, blocks_1.ImportBlockType)(allowedBlockTypes),
+})
+    .pipe(new t.Type("ImportBlock", (u) => t
+    .union([blocks_1.ImportTextBlock, blocks_1.ImportImageBlock, blocks_1.ImportEmbedBlock])
+    .is(u), (u, c) => {
+    if (u.type === "image") {
+        return blocks_1.ImportImageBlock.validate(u, c);
+    }
+    else if (u.type === "embed") {
+        return blocks_1.ImportEmbedBlock.validate(u, c);
+    }
+    else {
+        return blocks_1.ImportTextBlock.validate(u, c);
+    }
+}, t.identity)), () => "Rich text block must be an object");
+exports.ImportBlock = ImportBlock;

package/lib/import/validators/fields/nestable/ImportRichText/ImportRichText.d.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+import { ImportBlock } from "./ImportBlock";
+export declare const ImportRichText: (customType?: ({
+    type: "StructuredText";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        useAsTitle?: boolean;
+        single?: string;
+        multi?: string;
+        imageConstraint?: {
+            width?: number | null;
+            height?: number | null;
+        };
+        labels?: readonly string[];
+        allowTargetBlank?: boolean;
+    };
+}) | undefined) => t.Type<{
+    type: "StructuredText";
+    value: ImportBlock[] | null;
+}, unknown[] | undefined, unknown>;
+export declare type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>;

package/lib/import/validators/fields/nestable/ImportRichText/ImportRichText.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportRichText = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../validators");
+const function_1 = require("../../../../../validators/function");
+const ImportContent_1 = require("../../ImportContent");
+const ImportBlock_1 = require("./ImportBlock");
+const ImportRichText = (customType) => (0, ImportContent_1.ImportContent)("StructuredText", (0, validators_1.EmptyArrayOrElse)((0, function_1.withCustomError)(t.array(t.unknown).pipe(new t.Type("RichTextField", (u) => t.array((0, ImportBlock_1.ImportBlock)([])).is(u), (u, c) => {
+    var _a, _b, _c, _d;
+    const single = (_b = (_a = customType === null || customType === void 0 ? void 0 : customType.config) === null || _a === void 0 ? void 0 : _a.single) === null || _b === void 0 ? void 0 : _b.split(",");
+    const multi = (_d = (_c = customType === null || customType === void 0 ? void 0 : customType.config) === null || _c === void 0 ? void 0 : _c.multi) === null || _d === void 0 ? void 0 : _d.split(",");
+    if (multi) {
+        return t.array((0, ImportBlock_1.ImportBlock)(multi)).validate(u, c);
+    }
+    else if (single) {
+        return u.length > 1
+            ? t.failure(u, c, "This field only allows one block")
+            : t.array((0, ImportBlock_1.ImportBlock)(single)).validate(u, c);
+    }
+    else {
+        throw new Error("Rich text config must have either a 'single' or 'multi' field defined");
+    }
+}, t.identity)), () => "Rich text field must be an array")));
+exports.ImportRichText = ImportRichText;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportBlockType.d.ts

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+import { ImportEmbedBlockType } from "./ImportEmbedBlock";
+import { ImportImageBlockType } from "./ImportImageBlock";
+import { ImportTextBlockType } from "./ImportTextBlock";
+export declare type ImportBlockType = ImportTextBlockType | ImportImageBlockType | ImportEmbedBlockType;
+export declare const ImportBlockType: (allowedBlockTypes: string[]) => t.Type<ImportBlockType, ImportBlockType, unknown>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportBlockType.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportBlockType = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_2 = require("../../../../../../validators/function");
+const ImportEmbedBlock_1 = require("./ImportEmbedBlock");
+const ImportImageBlock_1 = require("./ImportImageBlock");
+const ImportTextBlock_1 = require("./ImportTextBlock");
+const ImportBlockTypeValidator = (0, function_2.withCustomError)(t.union([ImportTextBlock_1.ImportTextBlockType, ImportImageBlock_1.ImportImageBlockType, ImportEmbedBlock_1.ImportEmbedBlockType]), () => `Invalid block type. Supported block types are: ${Object.keys(ImportTextBlock_1.ImportTextBlockType.keys).join(", ")}, ${ImportImageBlock_1.ImportImageBlockType.value}, ${ImportEmbedBlock_1.ImportEmbedBlockType.value}`);
+const ImportBlockType = (allowedBlockTypes) => new t.Type("ImportBlockType", (u) => ImportBlockTypeValidator.is(u), (u, c) => {
+    return (0, function_1.pipe)(ImportBlockTypeValidator.validate(u, c), E.chain((validBlockType) => allowedBlockTypes.includes(validBlockType)
+        ? t.success(validBlockType)
+        : t.failure(u, c, `The block type '${validBlockType}' is not allowed in your document type. Enable the type for this rich text field to create the document.`)));
+}, t.identity);
+exports.ImportBlockType = ImportBlockType;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportEmbedBlock.d.ts

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+export declare const ImportEmbedBlockType: t.LiteralC<"embed">;
+export declare type ImportEmbedBlockType = t.TypeOf<typeof ImportEmbedBlockType>;
+export declare const ImportEmbedBlock: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"embed">;
+    oembed: t.ExactC<t.TypeC<{
+        embed_url: t.Type<string, string, unknown>;
+    }>>;
+}>>;
+export declare type ImportEmbedBlock = t.TypeOf<typeof ImportEmbedBlock>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportEmbedBlock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEmbedBlock = exports.ImportEmbedBlockType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const Embed_1 = require("../../Embed");
+exports.ImportEmbedBlockType = t.literal("embed");
+exports.ImportEmbedBlock = t.strict({
+    type: exports.ImportEmbedBlockType,
+    oembed: Embed_1.ImportEmbedValue,
+});

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.d.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+export declare const ImportImageBlockType: t.LiteralC<"image">;
+export declare type ImportImageBlockType = t.TypeOf<typeof ImportImageBlockType>;
+export declare const ImportImageBlock: t.ExactC<t.TypeC<{
+    type: t.LiteralC<"image">;
+    id: t.StringC;
+}>>;
+export declare type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportImageBlock = exports.ImportImageBlockType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../../validators");
+exports.ImportImageBlockType = t.literal("image");
+exports.ImportImageBlock = t.strict({
+    type: exports.ImportImageBlockType,
+    id: validators_1.String,
+});

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportTextBlock.d.ts

@@ -0,0 +1,70 @@
+import * as t from "io-ts";
+export declare const ImportTextBlockTypes: {
+    readonly Paragraph: "paragraph";
+    readonly OListItem: "o-list-item";
+    readonly ListItem: "list-item";
+    readonly Heading1: "heading1";
+    readonly Heading2: "heading2";
+    readonly Heading3: "heading3";
+    readonly Heading4: "heading4";
+    readonly Heading5: "heading5";
+    readonly Heading6: "heading6";
+    readonly Preformatted: "preformatted";
+};
+export declare const ImportTextBlockType: t.KeyofC<{
+    paragraph: null;
+    "o-list-item": null;
+    "list-item": null;
+    heading1: null;
+    heading2: null;
+    heading3: null;
+    heading4: null;
+    heading5: null;
+    heading6: null;
+    preformatted: null;
+}>;
+export declare type ImportTextBlockType = t.TypeOf<typeof ImportTextBlockType>;
+export declare const ImportTextBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.KeyofC<{
+        paragraph: null;
+        "o-list-item": null;
+        "list-item": null;
+        heading1: null;
+        heading2: null;
+        heading3: null;
+        heading4: null;
+        heading5: null;
+        heading6: null;
+        preformatted: null;
+    }>;
+    text: t.StringC;
+}>, t.PartialC<{
+    spans: t.ArrayC<t.Type<({
+        type: "hyperlink";
+    } & {
+        start: number;
+        end: number;
+    } & {
+        data: ({
+            link_type: "Web";
+            url: string;
+        } & {
+            target?: string;
+        }) | {
+            link_type: "Document";
+            id: string;
+        } | {
+            link_type: "Media";
+            id: string;
+        };
+    }) | ({
+        type: "label" | "strong" | "em";
+    } & {
+        start: number;
+        end: number;
+    }), {
+        type: "label" | "strong" | "em" | "hyperlink";
+    }, unknown>>;
+    direction: t.UnionC<[t.LiteralC<"ltr">, t.LiteralC<"rtl">]>;
+}>]>>;
+export declare type ImportTextBlock = t.TypeOf<typeof ImportTextBlock>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportTextBlock.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportTextBlock = exports.ImportTextBlockType = exports.ImportTextBlockTypes = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../../validators");
+const function_1 = require("../../../../../../validators/function");
+const Span_1 = require("./Span");
+exports.ImportTextBlockTypes = {
+    Paragraph: "paragraph",
+    OListItem: "o-list-item",
+    ListItem: "list-item",
+    Heading1: "heading1",
+    Heading2: "heading2",
+    Heading3: "heading3",
+    Heading4: "heading4",
+    Heading5: "heading5",
+    Heading6: "heading6",
+    Preformatted: "preformatted",
+};
+exports.ImportTextBlockType = t.keyof({
+    [exports.ImportTextBlockTypes.Paragraph]: null,
+    [exports.ImportTextBlockTypes.OListItem]: null,
+    [exports.ImportTextBlockTypes.ListItem]: null,
+    [exports.ImportTextBlockTypes.Heading1]: null,
+    [exports.ImportTextBlockTypes.Heading2]: null,
+    [exports.ImportTextBlockTypes.Heading3]: null,
+    [exports.ImportTextBlockTypes.Heading4]: null,
+    [exports.ImportTextBlockTypes.Heading5]: null,
+    [exports.ImportTextBlockTypes.Heading6]: null,
+    [exports.ImportTextBlockTypes.Preformatted]: null,
+});
+const TextDirection = (0, function_1.withCustomError)(t.union([t.literal("ltr"), t.literal("rtl")]), () => "The 'direction' property must be one of the following: ltr, rtl");
+exports.ImportTextBlock = t.exact(t.intersection([
+    t.type({
+        type: exports.ImportTextBlockType,
+        text: validators_1.String,
+    }),
+    t.partial({
+        spans: (0, function_1.withCustomError)(t.array(Span_1.Span), () => "The 'spans' field must be an array"),
+        direction: TextDirection,
+    }),
+]));

package/lib/import/validators/fields/nestable/ImportRichText/blocks/Span.d.ts

@@ -0,0 +1,65 @@
+import * as t from "io-ts";
+declare const SpanType: t.UnionC<[t.LiteralC<"hyperlink">, t.KeyofC<{
+    strong: null;
+    em: null;
+    label: null;
+}>]>;
+export declare type SpanType = t.TypeOf<typeof SpanType>;
+declare const SpanShape: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"hyperlink">;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>, t.TypeC<{
+    data: t.Type<({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    }, {
+        link_type: "Document" | "Web" | "Media";
+    }, unknown>;
+}>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.KeyofC<{
+        strong: null;
+        em: null;
+        label: null;
+    }>;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>]>>]>;
+export declare type Span = t.TypeOf<typeof SpanShape>;
+export declare const Span: t.Type<({
+    type: "hyperlink";
+} & {
+    start: number;
+    end: number;
+} & {
+    data: ({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    };
+}) | ({
+    type: "label" | "strong" | "em";
+} & {
+    start: number;
+    end: number;
+}), {
+    type: "label" | "strong" | "em" | "hyperlink";
+}, unknown>;
+export {};

package/lib/import/validators/fields/nestable/ImportRichText/blocks/Span.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Span = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../../../../validators/function");
+const spans_1 = require("./spans");
+const SpanType = (0, function_1.withCustomError)(t.union([spans_1.HyperlinkSpanType, spans_1.TextSpanType]), () => `Span 'type' field must be specified and have one of the following values: ${Object.keys(spans_1.TextSpanType.keys).join(", ")} or ${spans_1.HyperlinkSpanType.value}`);
+const SpanTypeValidator = (0, function_1.withCustomError)(t.type({
+    type: SpanType,
+}), () => "Span must be an object");
+const SpanShape = t.union([spans_1.HyperlinkSpan, spans_1.TextSpan]);
+exports.Span = SpanTypeValidator.pipe(new t.Type("Span", (u) => SpanShape.is(u), (u, c) => {
+    if (spans_1.HyperlinkSpanType.is(u.type)) {
+        return spans_1.HyperlinkSpan.validate(u, c);
+    }
+    else {
+        return spans_1.TextSpan.validate(u, c);
+    }
+}, t.identity));

package/lib/import/validators/fields/nestable/ImportRichText/blocks/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ImportBlockType";
+export * from "./ImportEmbedBlock";
+export * from "./ImportImageBlock";
+export * from "./ImportTextBlock";

package/lib/import/validators/fields/nestable/ImportRichText/blocks/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./ImportBlockType"), exports);
+(0, tslib_1.__exportStar)(require("./ImportEmbedBlock"), exports);
+(0, tslib_1.__exportStar)(require("./ImportImageBlock"), exports);
+(0, tslib_1.__exportStar)(require("./ImportTextBlock"), exports);

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/HyperlinkSpan.d.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+export declare const HyperlinkSpanType: t.LiteralC<"hyperlink">;
+export declare type HyperlinkSpanType = t.TypeOf<typeof HyperlinkSpanType>;
+export declare const HyperlinkSpan: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"hyperlink">;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>, t.TypeC<{
+    data: t.Type<({
+        link_type: "Web";
+        url: string;
+    } & {
+        target?: string;
+    }) | {
+        link_type: "Document";
+        id: string;
+    } | {
+        link_type: "Media";
+        id: string;
+    }, {
+        link_type: "Document" | "Web" | "Media";
+    }, unknown>;
+}>]>>;