@prismicio/types-internal 2.2.1 → 2.3.0

package/lib/import/validators/fields/UID.d.ts

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+export declare const ImportUID: t.Type<{
+    type: "UID";
+    value: string;
+}, string, unknown>;
+export declare type ImportUID = t.TypeOf<typeof ImportUID>;

package/lib/import/validators/fields/UID.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportUID = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const ImportContent_1 = require("./ImportContent");
+const regex = /^[a-z0-9-_.]+$/;
+const uidValue = validators_1.String.pipe(new t.Type("ImportUIDField", (u) => validators_1.String.is(u), (n, c) => {
+    if (regex.test(n)) {
+        return t.success(n);
+    }
+    return t.failure(n, c, "UID can only contain alphanumeric characters, dashes, underscores, and dots");
+}, t.identity));
+exports.ImportUID = (0, ImportContent_1.ImportContent)("UID", uidValue);

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

@@ -0,0 +1,4 @@
+export * from "./nestable";
+export * from "./RepeatableZone";
+export * from "./RepeatableZoneItem";
+export * from "./UID";

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./nestable"), exports);
+(0, tslib_1.__exportStar)(require("./RepeatableZone"), exports);
+(0, tslib_1.__exportStar)(require("./RepeatableZoneItem"), exports);
+(0, tslib_1.__exportStar)(require("./UID"), exports);

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

@@ -0,0 +1,6 @@
+import type { TypeOf } from "io-ts";
+export declare const ImportBoolean: import("io-ts").Type<{
+    type: "Boolean";
+    value: boolean | null;
+}, boolean | undefined, unknown>;
+export declare type ImportBoolean = TypeOf<typeof ImportBoolean>;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportBoolean = void 0;
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+exports.ImportBoolean = (0, ImportContent_1.ImportContent)("Boolean", (0, validators_1.NullOrElse)(validators_1.Boolean));

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

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+export declare const ImportColor: t.Type<{
+    type: "Color";
+    value: `#${string}` | null;
+}, string | undefined, unknown>;
+export declare type ImportColor = t.TypeOf<typeof ImportColor>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportColor = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const HexaColorCode_1 = require("../../../../common/HexaColorCode");
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+const colorValue = new t.Type("ImportColorValue", (u) => validators_1.String.is(u) && HexaColorCode_1.HexaColor.is(u), (s, c) => {
+    if (!HexaColorCode_1.HexaColor.is(s)) {
+        return t.failure(s, c, "The color value must be an hexadecimal color code");
+    }
+    return t.success(s);
+}, t.identity);
+exports.ImportColor = (0, ImportContent_1.ImportContent)("Color", (0, validators_1.NullOrElse)(validators_1.String.pipe(colorValue)));

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

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+export declare const ImportDate: t.Type<{
+    type: "Date";
+    value: Date | null;
+}, Date | undefined, unknown>;
+export declare type ImportDate = t.TypeOf<typeof ImportDate>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportDate = 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 ImportContent_1 = require("../ImportContent");
+const DATE_INPUT_REGEX = /^(\d{1,4})-(\d{1,2})-(\d{1,2})$/;
+const dateValue = new t.Type("ImportNumberValue", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(validators_1.String.validate(u, c), (0, Either_1.chain)((s) => {
+    const date = new Date(s);
+    const isInvalidDate = isNaN(date.getTime());
+    if (isInvalidDate || !DATE_INPUT_REGEX.test(s)) {
+        return t.failure(u, c, "The value must be a Date in the format YYYY-MM-DD");
+    }
+    return t.success(date);
+})), t.identity);
+exports.ImportDate = (0, ImportContent_1.ImportContent)("Date", (0, validators_1.NullOrElse)(dateValue));

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

@@ -0,0 +1,13 @@
+import * as t from "io-ts";
+export declare const ImportEmbedValue: t.ExactC<t.TypeC<{
+    embed_url: t.Type<string, string, unknown>;
+}>>;
+export declare const ImportEmbed: t.Type<{
+    type: "Embed";
+    value: {
+        embed_url: string;
+    } | null;
+}, {
+    embed_url: string;
+} | undefined, unknown>;
+export declare type ImportEmbed = t.TypeOf<typeof ImportEmbed>;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEmbed = exports.ImportEmbedValue = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+function isValidHttpUrl(param) {
+    try {
+        if (typeof param !== "string") {
+            return false;
+        }
+        const url = new URL(param);
+        return ["http:", "https:"].includes(url.protocol);
+    }
+    catch (err) {
+        return false;
+    }
+}
+const EmbedUrl = new t.Type("EmbedUrl", (u) => isValidHttpUrl(u), (u, c) => {
+    if (isValidHttpUrl(u)) {
+        return t.success(u);
+    }
+    else {
+        return t.failure(u, c, "The value must be a valid http/https url");
+    }
+}, t.identity);
+exports.ImportEmbedValue = t.strict({
+    embed_url: EmbedUrl,
+});
+exports.ImportEmbed = (0, ImportContent_1.ImportContent)("Embed", (0, validators_1.EmptyObjectOrElse)(exports.ImportEmbedValue));

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

@@ -0,0 +1,13 @@
+import type { TypeOf } from "io-ts";
+import * as t from "io-ts";
+export declare const ImportGeoPoint: t.Type<{
+    type: "GeoPoint";
+    value: {
+        latitude: number;
+        longitude: number;
+    } | null;
+}, {
+    latitude: number;
+    longitude: number;
+} | undefined, unknown>;
+export declare type ImportGeoPoint = TypeOf<typeof ImportGeoPoint>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportGeoPoint = 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 GeoPoint = (0, function_1.withCustomError)(t.strict({
+    latitude: (0, validators_1.NumberRange)(-90, 90, "latitude"),
+    longitude: (0, validators_1.NumberRange)(-180, 180, "longitude"),
+}), () => "GeoPoint must be an object with the properties `latitude` and `longitude` between the given ranges");
+exports.ImportGeoPoint = (0, ImportContent_1.ImportContent)("GeoPoint", (0, validators_1.EmptyObjectOrElse)(GeoPoint));

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

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+export declare const defaultImportImage: (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<Record<never, never>, {
+    [key: string]: unknown;
+}, unknown>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultImportImage = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../validators");
+const defaultImportImage = (field) => {
+    var _a;
+    // If there is not thumbnails we expect an empty object
+    if (!((_a = field === null || field === void 0 ? void 0 : field.config) === null || _a === void 0 ? void 0 : _a.thumbnails) || !field.config.thumbnails.length)
+        return validators_1.EmptyObject;
+    // If there are thumbnails, we can expect an object with thumbnails as empty objects,
+    // however we don't accept any other properties for the empty state
+    return t.strict(field.config.thumbnails.reduce((acc, thumbnail) => ({
+        ...acc,
+        [thumbnail.name]: validators_1.EmptyObject,
+    }), {}));
+};
+exports.defaultImportImage = defaultImportImage;

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

@@ -0,0 +1,26 @@
+import * as t from "io-ts";
+import type { ImageFieldWithThumbnails } from "./model";
+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,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportImage = 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) => {
+    const ImageCodec = (0, validators_2.ImportImageWithThumbnails)(field);
+    return new t.Type("ImageField", (u) => ImageCodec.is(u), (u, ctx) => (0, function_1.pipe)(ImageCodec.validate(u, ctx), (0, Either_1.map)((imageApiV2) => {
+        var _a;
+        const { id, dimensions, edit, copyright, alt, ...thumbnails } = imageApiV2;
+        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);
+};
+const ImportImage = (field) => (0, ImportContent_1.ImportContent)("Image", (0, function_2.withCustomError)((0, validators_1.DefaultOrElse)((0, default_1.defaultImportImage)(field))(ImageFieldCodec(field)), () => "An image field must be an object"));
+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,132 @@
+import * as t from "io-ts";
+import type { Thumbnail } from "../../../../../customtypes";
+export declare const ImportImageViewShape: 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 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>;
+declare const ImportThumbnails: (thumbnails: readonly Thumbnail[]) => t.Type<Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, unknown>;
+export declare type ImportThumbnails = t.TypeOf<ReturnType<typeof ImportThumbnails>>;
+export declare const ImportImageWithThumbnails: (def?: ({
+    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.IntersectionC<[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]>;
+}>]>, t.Type<Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, unknown>]>;
+export {};

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportImageWithThumbnails = exports.ImportImageView = exports.ImportImageViewShape = 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.ImportImageViewShape = 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,
+    }),
+]);
+exports.ImportImageView = (0, function_1.withCustomError)(exports.ImportImageViewShape, () => "The value must be an object");
+const ImportThumbnails = (thumbnails) => t.partial(thumbnails.reduce((acc, thumbnail) => ({
+    ...acc,
+    [thumbnail.name]: exports.ImportImageView,
+}), {}));
+const ImportImageWithThumbnails = (def) => {
+    var _a, _b;
+    return (0, function_1.withCustomError)(t.intersection([
+        exports.ImportImageViewShape,
+        ImportThumbnails((_b = (_a = def === null || def === void 0 ? void 0 : def.config) === null || _a === void 0 ? void 0 : _a.thumbnails) !== null && _b !== void 0 ? _b : []),
+    ]), () => "The value must be an object");
+};
+exports.ImportImageWithThumbnails = ImportImageWithThumbnails;

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;
+}, ImportBlock[] | undefined, unknown>;
+export declare type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportRichText = 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 validators_1 = require("../../../../../validators");
+const function_2 = require("../../../../../validators/function");
+const ImportContent_1 = require("../../ImportContent");
+const ImportBlock_1 = require("./ImportBlock");
+const ImportRichText = (customType) => {
+    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(",");
+    const allowedBlockTypes = multi || single;
+    const isSingleBlockAllowed = multi === undefined && single !== undefined;
+    const BlockCodec = (0, ImportBlock_1.ImportBlock)(allowedBlockTypes !== null && allowedBlockTypes !== void 0 ? allowedBlockTypes : []);
+    const RichTextArrayCodec = (0, function_2.withCustomError)(t.array(BlockCodec), () => "Rich text field must be an array");
+    return (0, ImportContent_1.ImportContent)("StructuredText", (0, validators_1.EmptyArrayOrElse)(new t.ArrayType(RichTextArrayCodec.name, (u) => RichTextArrayCodec.is(u), (u, c) => {
+        if (allowedBlockTypes === undefined) {
+            throw new Error("Invalid custom type for the rich text field: the model is missing a 'single' or 'multi' field defining a list of allowed block types");
+        }
+        return (0, function_1.pipe)(RichTextArrayCodec.validate(u, c), E.chain((blocks) => {
+            if (isSingleBlockAllowed && blocks.length > 1) {
+                return t.failure(blocks, c, "This field only allows one block");
+            }
+            return t.success(blocks);
+        }));
+    }, t.identity, BlockCodec)));
+};
+exports.ImportRichText = ImportRichText;