@prismicio/types-internal 2.2.0-alpha.11 → 2.2.0-alpha.13

package/lib/import/converters/fields/utils.d.ts

@@ -0,0 +1 @@
+export declare const nullableConverter: <I, O>(value: I | null, converter: (value: I) => O) => O | undefined;

package/lib/import/converters/fields/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nullableConverter = void 0;
+const nullableConverter = (value, converter) => {
+    if (value === null)
+        return undefined;
+    else
+        return converter(value);
+};
+exports.nullableConverter = nullableConverter;

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

@@ -5,10 +5,20 @@ 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 io_ts_types_1 = require("io-ts-types");
 const validators_1 = require("../../../../../validators");
 const ImportContent_1 = require("../../ImportContent");
 const Decoder_1 = require("./Decoder");
 const Validator_1 = require("./Validator");
+const defaultImage = (field) => {
+    var _a, _b;
+    const thumbnailsNames = ((_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.map((t) => t.name)) || [];
+    const thumbnailsCodec = (0, io_ts_types_1.withMessage)(t.type(thumbnailsNames.reduce((acc, name) => ({
+        ...acc,
+        [name]: validators_1.EmptyObject,
+    }), {})), () => "The value must be an object with thumbnails as empty objects");
+    return validators_1.AnyObject.pipe(thumbnailsCodec);
+};
 const ImageField = (field) => new t.Type("ImageField", (u) => Validator_1.ImageFieldValidator.is(u) &&
     "thumbnails" in u &&
     Validator_1.ThumbnailsValidator.is(u["thumbnails"]), (u, ctx) => {
@@ -23,6 +33,7 @@ const ImageField = (field) => new t.Type("ImageField", (u) => Validator_1.ImageF
         }));
     }));
 }, t.identity);
-const ImportImage = (field) => (0, ImportContent_1.ImportContent)("Image", (0, validators_1.NullOrElse)(ImageField(field)));
+const ImageCodec = (field) => (0, validators_1.DefaultOrElse)(defaultImage(field))(ImageField(field));
+const ImportImage = (field) => (0, ImportContent_1.ImportContent)("Image", ImageCodec(field));
 exports.ImportImage = ImportImage;
 (0, tslib_1.__exportStar)(require("./model"), exports);

package/lib/validators/DefaultOrElse.js

@@ -6,7 +6,7 @@ const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const BasicTypes_1 = require("./BasicTypes");
 const DefaultOrElse = (inputValidator) => {
-    return (codec) => new t.Type("NullOrT", (u) => null === u || codec.is(u), (u) => {
+    return (codec) => new t.Type("DefaultOrT", (u) => null === u || codec.is(u), (u) => {
         if ((0, Either_1.isRight)(inputValidator.decode(u)))
             return t.success(null);
         return codec.decode(u);

package/lib/validators/NullOrT.d.ts

@@ -0,0 +1,2 @@
+import * as t from "io-ts";
+export declare const NullOrT: <T, O = T>(codec: t.Type<T, T, unknown>) => (asO: (value: T | null) => O) => t.Type<O, O, unknown>;

package/lib/validators/NullOrT.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullOrT = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const NullOrT = (codec) => {
+    return (asO) => new t.Type(`NullOr${codec.name}`, (u) => t.null.is(u) || codec.is(u), (u) => {
+        return (0, function_1.pipe)(t.union([t.null, codec]).decode(u), fp_ts_1.either.map((decoded) => asO(decoded)));
+    }, (f) => f);
+};
+exports.NullOrT = NullOrT;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-alpha.11",
+	"version": "2.2.0-alpha.13",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/import/validators/fields/nestable/Image/index.ts

@@ -2,14 +2,37 @@ import { chain, map } from "fp-ts/Either"
 import { pipe } from "fp-ts/function"
 import type { Validation } from "io-ts"
 import * as t from "io-ts"
+import { withMessage } from "io-ts-types"
 
 import type { Image as ImageDefinition } from "../../../../../customtypes"
-import { NullOrElse } from "../../../../../validators"
+import {
+	AnyObject,
+	DefaultOrElse,
+	EmptyObject,
+} from "../../../../../validators"
 import { ImportContent } from "../../ImportContent"
 import { decodeImageField, decodeThumbnails } from "./Decoder"
 import type { ImageFieldWithThumbnails } from "./model"
 import { ImageFieldValidator, ThumbnailsValidator } from "./Validator"
 
+const defaultImage = (field?: ImageDefinition) => {
+	const thumbnailsNames = field?.config?.thumbnails?.map((t) => t.name) || []
+	const thumbnailsCodec = withMessage(
+		t.type(
+			thumbnailsNames.reduce(
+				(acc, name) => ({
+					...acc,
+					[name]: EmptyObject,
+				}),
+				{},
+			),
+		),
+		() => "The value must be an object with thumbnails as empty objects",
+	)
+
+	return AnyObject.pipe(thumbnailsCodec)
+}
+
 const ImageField = (field?: ImageDefinition) =>
 	new t.Type<ImageFieldWithThumbnails>(
 		"ImageField",
@@ -39,7 +62,15 @@ const ImageField = (field?: ImageDefinition) =>
 		},
 		t.identity,
 	)
+
+const ImageCodec = (field?: ImageDefinition) =>
+	DefaultOrElse<
+		Record<string, unknown>,
+		ImageFieldWithThumbnails,
+		ImageFieldWithThumbnails
+	>(defaultImage(field))(ImageField(field))
+
 export const ImportImage = (field?: ImageDefinition) =>
-	ImportContent("Image", NullOrElse(ImageField(field)))
+	ImportContent("Image", ImageCodec(field))
 export type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>
 export * from "./model"

package/src/validators/DefaultOrElse.ts

@@ -6,7 +6,7 @@ import { EmptyArray, EmptyObject } from "./BasicTypes"
 export const DefaultOrElse = <I, A, O = A>(inputValidator: t.Type<I>) => {
 	return (codec: t.Type<A, O>) =>
 		new t.Type<A | null, O | undefined>(
-			"NullOrT",
+			"DefaultOrT",
 			(u: unknown): u is A | null => null === u || codec.is(u),
 			(u: unknown) => {
 				if (isRight(inputValidator.decode(u))) return t.success(null)

package/lib/import/converters/fields/Slices/SliceItem.d.ts

@@ -1,4 +0,0 @@
-import type { Asset } from "../../../../common";
-import type { SharedSliceContent } from "../../../../content";
-import type { SharedSlice as ImportSharedSlice } from "../../../validators/fields/Slices/SharedSlice";
-export declare const importSliceItemConverter: (field: ImportSharedSlice, assets: Record<string, Asset>) => SharedSliceContent;

package/lib/import/converters/fields/Slices/SliceItem.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.importSliceItemConverter = void 0;
-const tslib_1 = require("tslib");
-const function_1 = require("fp-ts/function");
-const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
-const R = (0, tslib_1.__importStar)(require("fp-ts/Record"));
-const content_1 = require("../../../../content");
-const nestable_1 = require("../nestable");
-const importSliceItemContentConverter = (content, assets) => (0, function_1.pipe)(content, 
-// convertNestableWidget can theoretically return undefined, so we need to filter out those values
-R.filterMap((contentValue) => (0, function_1.pipe)(contentValue, (content) => (0, nestable_1.convertNestableWidget)(content, assets), O.fromNullable)));
-const itemsToRepeatableWidgetsConverter = (items, assets) => items.map((item) => (0, function_1.pipe)(importSliceItemContentConverter(item, assets), (record) => Object.entries(record), (entries) => ({ __TYPE__: content_1.GroupItemContentType, value: entries })));
-const importSliceItemConverter = (field, assets) => ({
-    __TYPE__: content_1.SharedSliceContentType,
-    primary: field.primary
-        ? importSliceItemContentConverter(field.primary, assets)
-        : {},
-    items: field.items
-        ? itemsToRepeatableWidgetsConverter(field.items, assets)
-        : [],
-    variation: field.variation,
-});
-exports.importSliceItemConverter = importSliceItemConverter;

package/lib/import/validators/fields/ImportSlices/ImportSliceId.d.ts

@@ -1,9 +0,0 @@
-import * as t from "io-ts";
-import { UUID } from "../../../../common/UUID";
-export declare type ImportSliceId = `${string}$${UUID}`;
-export declare const ImportSliceIdValidationError: {
-    readonly Base: "Slice id must be a non empty string matching the following pattern 'slice_type$uuid'";
-    readonly IncorrectUUID: (uuid: string | undefined) => string;
-    readonly IncorrectSliceType: (sliceType: string | undefined) => string;
-};
-export declare const ImportSliceId: t.Type<string, string, unknown>;

package/lib/import/validators/fields/ImportSlices/ImportSliceId.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportSliceId = exports.ImportSliceIdValidationError = 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 UUID_1 = require("../../../../common/UUID");
-const validators_1 = require("../../../../validators");
-const baseErrorText = "Slice id must be a non empty string matching the following pattern 'slice_type$uuid'";
-exports.ImportSliceIdValidationError = {
-    Base: baseErrorText,
-    IncorrectUUID: (uuid) => `Incorrect UUID: '${uuid}' - ${baseErrorText}`,
-    IncorrectSliceType: (sliceType) => `Incorrect slice_type: '${sliceType}' - ${baseErrorText}`,
-};
-exports.ImportSliceId = new t.Type("ImportSliceId", (u) => {
-    if (typeof u !== "string") {
-        return false;
-    }
-    const [sliceName, uuid] = u.split("$");
-    return validators_1.NonEmptyString.is(sliceName) && UUID_1.UUID.is(uuid);
-}, (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.mapLeft((errors) => errors.map((error) => ({
-    ...error,
-    message: exports.ImportSliceIdValidationError.Base,
-}))), E.chain((sliceId) => {
-    const [sliceName, uuid] = sliceId.split("$");
-    return (0, function_1.pipe)(t.tuple([validators_1.NonEmptyString, UUID_1.UUID]).validate([sliceName, uuid], c), E.mapLeft((errors) => errors.map((error) => {
-        const tupleErrorContext = error.context[error.context.length - 1];
-        const correctErrorKey = (tupleErrorContext === null || tupleErrorContext === void 0 ? void 0 : tupleErrorContext.key) === "0" ? "slice_type" : "uuid";
-        const codec = (tupleErrorContext === null || tupleErrorContext === void 0 ? void 0 : tupleErrorContext.key) === "0" ? validators_1.NonEmptyString : UUID_1.UUID;
-        const actual = (tupleErrorContext === null || tupleErrorContext === void 0 ? void 0 : tupleErrorContext.key) === "0" ? sliceName : uuid;
-        return {
-            ...error,
-            context: [
-                ...error.context.slice(0, -1),
-                { key: correctErrorKey, type: codec, actual },
-            ],
-            message: (tupleErrorContext === null || tupleErrorContext === void 0 ? void 0 : tupleErrorContext.key) === "0"
-                ? exports.ImportSliceIdValidationError.IncorrectSliceType(sliceName)
-                : exports.ImportSliceIdValidationError.IncorrectUUID(uuid),
-        };
-    })));
-}), E.map(([sliceName, uuid]) => `${sliceName}$${uuid}`)), (sliceId) => sliceId);

package/lib/import/validators/fields/ImportSlices/ImportSliceItem.d.ts

@@ -1,24 +0,0 @@
-import * as t from "io-ts";
-import { SharedSlice } from "../../../../customtypes";
-import { ImportSliceId } from "./ImportSliceId";
-import { ImportSliceItemContent } from "./ImportSliceItemContent";
-export declare const ImportSliceItemErrors: {
-    readonly SliceTypeNotFound: (slice_type: string) => string;
-    readonly VariationNotFound: (variation: string, slice_type: string) => string;
-    readonly SliceContentItemErrors: {
-        readonly UnknownField: (sliceName: string, sliceContentField: "primary" | "items", fieldName: string) => string;
-        readonly InvalidSliceItemContent: (sliceName: string, sliceContentField: "primary" | "items") => string;
-    };
-    readonly InvalidItemsArray: (slice_type: string) => string;
-};
-export declare type ImportSliceItem = {
-    id: ImportSliceId | null | undefined;
-    slice_type: string;
-    name: string;
-    variation: string;
-    primary: ImportSliceItemContent | null | undefined;
-    items: ImportSliceItemContent[] | null | undefined;
-    slice_label: string | null | undefined;
-    version: string | null | undefined;
-};
-export declare const ImportSliceItem: (sharedSlices: SharedSlice[]) => t.Type<ImportSliceItem, ImportSliceItem, unknown>;

package/lib/import/validators/fields/ImportSlices/ImportSliceItem.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportSliceItem = exports.ImportSliceItemErrors = 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 io_ts_types_1 = require("io-ts-types");
-const customtypes_1 = require("../../../../customtypes");
-const validators_1 = require("../../../../validators");
-const ImportSliceId_1 = require("./ImportSliceId");
-const ImportSliceItemContent_1 = require("./ImportSliceItemContent");
-exports.ImportSliceItemErrors = {
-    SliceTypeNotFound: (slice_type) => `Slice '${slice_type}' not found in document's custom type`,
-    VariationNotFound: (variation, slice_type) => `Variation '${variation}' not found for Slice '${slice_type}'`,
-    SliceContentItemErrors: ImportSliceItemContent_1.SliceItemContentErrors,
-    InvalidItemsArray: (slice_type) => `Invalid value for 'items' array in Slice '${slice_type}'. Must be an array of key-value records.`,
-};
-const SliceTypeWithSliceDataShape = t.type({
-    slice_type: validators_1.NonEmptyString,
-    slice: customtypes_1.SharedSlice,
-});
-const findSlice = (slices) => (sliceId) => (0, function_1.pipe)(slices.find((slice) => slice.id === sliceId), E.fromNullable(exports.ImportSliceItemErrors.SliceTypeNotFound(sliceId)));
-const SliceTypeWithSliceData = (slices) => new t.Type("slice_type", (u) => SliceTypeWithSliceDataShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((slice_type) => (0, function_1.pipe)(findSlice(slices)(slice_type), E.fold((err) => t.failure(u, c, err), (data) => t.success({ slice_type, data }))))), ({ slice_type }) => slice_type);
-const SliceVariationWithVariationDataShape = t.type({
-    variation: validators_1.NonEmptyString,
-    data: customtypes_1.Variation,
-});
-const findSliceVariation = (slice) => (variation) => (0, function_1.pipe)(slice.variations.find((v) => v.id === variation), E.fromNullable(exports.ImportSliceItemErrors.VariationNotFound(variation, slice.id)));
-const SliceVariationWithVariationData = (slice) => new t.Type("variation", (u) => SliceVariationWithVariationDataShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((variation) => (0, function_1.pipe)(findSliceVariation(slice)(variation), E.fold((err) => t.failure(u, c, err), (data) => t.success({ variation, data }))))), ({ variation }) => variation);
-const SliceId = new t.Type("ImportSliceId", (u) => u === null || u === undefined || ImportSliceId_1.ImportSliceId.is(u), (u, c) => {
-    if (u === null || u === undefined)
-        return t.success(u);
-    return ImportSliceId_1.ImportSliceId.validate(u, c);
-}, t.identity);
-const SliceLabel = t.union([t.undefined, t.null, validators_1.String]);
-const SliceVersion = t.union([t.undefined, t.null, validators_1.String]);
-const ImportSliceItemShape = t.type({
-    id: SliceId,
-    slice_type: validators_1.NonEmptyString,
-    name: validators_1.String,
-    variation: validators_1.NonEmptyString,
-    primary: t.union([t.undefined, t.null, t.record(validators_1.NonEmptyString, t.unknown)]),
-    items: t.union([
-        t.undefined,
-        t.null,
-        t.array(t.record(validators_1.NonEmptyString, t.unknown)),
-    ]),
-    slice_label: SliceLabel,
-    version: SliceVersion,
-});
-const baseFields = (sharedSlices) => t.type({
-    id: SliceId,
-    slice_type: SliceTypeWithSliceData(sharedSlices),
-    slice_label: SliceLabel,
-    version: SliceVersion,
-});
-const variationData = (slice) => t.type({ variation: SliceVariationWithVariationData(slice) });
-const Items = (sliceName, model) => {
-    const ItemContentCodec = (0, ImportSliceItemContent_1.ImportSliceItemContent)(sliceName, "items", model);
-    return new t.Type("Items", (u) => t.array(ItemContentCodec).is(u), (u, c) => (0, function_1.pipe)((0, io_ts_types_1.withMessage)(t.array(t.unknown), () => exports.ImportSliceItemErrors.InvalidItemsArray(sliceName)).validate(u, c), E.chain((arr) => t.array(ItemContentCodec).validate(arr, c))), t.identity);
-};
-const ImportSliceItem = (sharedSlices) => new t.Type("ImportSliceItem", (u) => ImportSliceItemShape.is(u), (u, c) => (0, function_1.pipe)(baseFields(sharedSlices).validate(u, c), E.chain((decoded) => (0, function_1.pipe)(variationData(decoded.slice_type.data).validate(u, c), E.map(({ variation }) => ({ ...decoded, variation })))), E.chain((decoded) => {
-    var _a;
-    return (0, function_1.pipe)(t
-        .partial({
-        primary: (0, ImportSliceItemContent_1.ImportSliceItemContent)(decoded.slice_type.slice_type, "primary", (_a = decoded.variation.data.primary) !== null && _a !== void 0 ? _a : {}),
-    })
-        .validate(u, c), E.map(({ primary }) => ({ ...decoded, primary })));
-}), E.chain((decoded) => {
-    var _a;
-    return (0, function_1.pipe)(t
-        .partial({
-        items: Items(decoded.slice_type.slice_type, (_a = decoded.variation.data.items) !== null && _a !== void 0 ? _a : {}),
-    })
-        .validate(u, c), E.map(({ items }) => ({ ...decoded, items })));
-}), E.map(({ id, slice_type, variation, primary, items, slice_label, version, }) => ({
-    id,
-    slice_type: slice_type.slice_type,
-    name: slice_type.data.name,
-    variation: variation.variation,
-    primary,
-    items,
-    slice_label,
-    version: version !== null && version !== void 0 ? version : variation.data.version,
-}))), t.identity);
-exports.ImportSliceItem = ImportSliceItem;

package/lib/import/validators/fields/ImportSlices/ImportSliceItemContent.d.ts

@@ -1,12 +0,0 @@
-import * as t from "io-ts";
-import { WidgetKey } from "../../../../common";
-import type { NestableWidget } from "../../../../customtypes";
-import { ImportNestable } from "../nestable";
-declare type SliceContentField = "primary" | "items";
-export declare const SliceItemContentErrors: {
-    readonly UnknownField: (sliceName: string, sliceContentField: SliceContentField, fieldName: string) => string;
-    readonly InvalidSliceItemContent: (sliceName: string, sliceContentField: SliceContentField) => string;
-};
-export declare type ImportSliceItemContent = Record<WidgetKey, ImportNestable>;
-export declare const ImportSliceItemContent: (sliceName: string, sliceContentField: "primary" | "items", sliceFieldModels: Record<WidgetKey, NestableWidget>) => t.Type<ImportSliceItemContent, ImportSliceItemContent, unknown>;
-export {};

package/lib/import/validators/fields/ImportSlices/ImportSliceItemContent.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportSliceItemContent = exports.SliceItemContentErrors = void 0;
-const tslib_1 = require("tslib");
-const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
-const function_1 = require("fp-ts/lib/function");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const io_ts_types_1 = require("io-ts-types");
-const common_1 = require("../../../../common");
-const io_ts_1 = require("../../../../utils/io-ts");
-const nestable_1 = require("../nestable");
-exports.SliceItemContentErrors = {
-    UnknownField: (sliceName, sliceContentField, fieldName) => `Unsupported field '${fieldName}'for ${sliceContentField} content in Slice '${sliceName}'`,
-    InvalidSliceItemContent: (sliceName, sliceContentField) => {
-        return `Invalid value for '${sliceContentField}' content in Slice '${sliceName}'. Must be a key-value record.`;
-    },
-};
-const SliceItemContentEntry = (sliceName, sliceContentField, sliceFieldModels) => new t.Type("SliceItemContentEntry", (u) => t.tuple([common_1.WidgetKey, t.unknown]).is(u) && nestable_1.ImportNestable.is(u[1]), (u, c) => {
-    return (0, function_1.pipe)(t.tuple([common_1.WidgetKey, t.unknown]).validate(u, c), E.chain(([key, content]) => {
-        const model = sliceFieldModels[key];
-        if (!model) {
-            return t.failure([key, content], [...c, { key, actual: content, type: t.unknown }], exports.SliceItemContentErrors.UnknownField(sliceName, sliceContentField, key));
-        }
-        const { codec, result } = nestable_1.ImportNestable.decode(model)(content);
-        return (0, function_1.pipe)(result, E.map((decodedContent) => [
-            key,
-            decodedContent,
-        ]), E.mapLeft((errors) => errors.map((error) => {
-            const context = [
-                ...c,
-                ...error.context.filter(({ key }) => !!key),
-                { key, actual: content, type: codec },
-            ];
-            const updatedError = { ...error, context };
-            return updatedError;
-        })));
-    }));
-}, t.identity);
-const RawContent = (sliceName, sliceContentField) => (0, io_ts_types_1.withMessage)(t.record(common_1.WidgetKey, t.unknown), () => exports.SliceItemContentErrors.InvalidSliceItemContent(sliceName, sliceContentField));
-const ImportSliceItemContent = (sliceName, sliceContentField, sliceFieldModels) => new t.Type("ImportSliceItemContent", (u) => t.record(common_1.WidgetKey, t.unknown).is(u), (u, c) => (0, function_1.pipe)(RawContent(sliceName, sliceContentField).validate(u, c), E.chain((rawContent) => (0, function_1.pipe)(Object.entries(rawContent).map((entry) => SliceItemContentEntry(sliceName, sliceContentField, sliceFieldModels).validate(entry, c)), io_ts_1.combineValidationResults, E.map((entries) => entries.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}))))), t.identity);
-exports.ImportSliceItemContent = ImportSliceItemContent;

package/lib/import/validators/fields/Slices/SharedSlice/SharedSlice.d.ts

@@ -1,14 +0,0 @@
-import * as t from "io-ts";
-import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes";
-import { SharedSliceContent, SharedSliceId } from "./fields";
-export declare type SharedSlice = {
-    id: SharedSliceId | null | undefined;
-    slice_type: string;
-    name: string;
-    variation: string;
-    primary: SharedSliceContent | null | undefined;
-    items: SharedSliceContent[] | null | undefined;
-    slice_label: string | null | undefined;
-    version: string | null | undefined;
-};
-export declare const SharedSlice: (sharedSlices: SharedSliceCustomType[]) => t.Type<SharedSlice, SharedSlice, unknown>;

package/lib/import/validators/fields/Slices/SharedSlice/SharedSlice.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedSlice = 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 fields_1 = require("./fields");
-const SharedSliceShape = t.type({
-    id: fields_1.OptionalSharedSliceId,
-    slice_type: validators_1.NonEmptyString,
-    name: validators_1.String,
-    variation: validators_1.NonEmptyString,
-    primary: t.union([t.undefined, t.null, t.record(validators_1.NonEmptyString, t.unknown)]),
-    items: t.union([
-        t.undefined,
-        t.null,
-        t.array(t.record(validators_1.NonEmptyString, t.unknown)),
-    ]),
-    slice_label: t.union([t.undefined, t.null, validators_1.String]),
-    version: t.union([t.undefined, t.null, validators_1.String]),
-});
-const SharedSlice = (sharedSlices) => new t.Type("SharedSlice", (u) => SharedSliceShape.is(u), (u, c) => (0, function_1.pipe)(
-// We validate the base fields that we can validate directly based on the provided 'sharedSlices'
-t
-    .type({
-    id: fields_1.OptionalSharedSliceId,
-    slice_type: (0, fields_1.SharedSliceType)(sharedSlices),
-    slice_label: t.union([t.undefined, t.null, validators_1.String]),
-    version: t.union([t.undefined, t.null, validators_1.String]),
-})
-    .validate(u, c), E.chain((decoded) => (0, function_1.pipe)(
-// We validate the 'variation' field, for which we need the SharedSlice custom type retrieved in the first step
-t
-    .type({
-    variation: (0, fields_1.SharedSliceVariation)(decoded.slice_type.data),
-})
-    .validate(u, c), E.map(({ variation }) => ({ ...decoded, variation })))), E.chain((decoded) => {
-    var _a, _b;
-    return (0, function_1.pipe)(
-    // We validate the 'primary' and 'items' content fields, for which we need the Variation custom type retrieved in the previous step
-    t
-        .partial({
-        primary: (0, fields_1.SharedSliceContent)(decoded.slice_type.slice_type, "primary", (_a = decoded.variation.data.primary) !== null && _a !== void 0 ? _a : {}),
-        // We need to use this wrapper codec instead of using t.array(SharedSliceContent) directly in order to get proper custom error messages
-        items: (0, fields_1.SharedSliceItems)(decoded.slice_type.slice_type, (_b = decoded.variation.data.items) !== null && _b !== void 0 ? _b : {}),
-    })
-        .validate(u, c), E.map(({ primary, items }) => ({ ...decoded, primary, items })));
-}), E.map(({ id, slice_type, variation, primary, items, slice_label, version, }) => ({
-    id,
-    slice_type: slice_type.slice_type,
-    name: slice_type.data.name,
-    variation: variation.variation,
-    primary,
-    items,
-    slice_label,
-    version: version !== null && version !== void 0 ? version : variation.data.version,
-}))), t.identity);
-exports.SharedSlice = SharedSlice;

package/lib/import/validators/fields/Slices/SharedSlice/errors.d.ts

@@ -1,5 +0,0 @@
-export declare const SharedSliceErrors: {
-    readonly SliceTypeNotFound: (slice_type: string) => string;
-    readonly VariationNotFound: (variation: string, slice_type: string) => string;
-    readonly InvalidItemsArray: (slice_type: string) => string;
-};

package/lib/import/validators/fields/Slices/SharedSlice/errors.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedSliceErrors = void 0;
-exports.SharedSliceErrors = {
-    SliceTypeNotFound: (slice_type) => `Shared slice '${slice_type}' not found in document's custom type`,
-    VariationNotFound: (variation, slice_type) => `Variation '${variation}' not found for Slice '${slice_type}'`,
-    InvalidItemsArray: (slice_type) => `Invalid value for 'items' array in Shared Slice '${slice_type}'. Must be an array of key-value records.`,
-};

package/lib/import/validators/fields/Slices/SharedSlice/fields/OptionalSharedSliceId.d.ts

@@ -1,2 +0,0 @@
-import * as t from "io-ts";
-export declare const OptionalSharedSliceId: t.Type<string | null | undefined, string | null | undefined, unknown>;

package/lib/import/validators/fields/Slices/SharedSlice/fields/OptionalSharedSliceId.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OptionalSharedSliceId = void 0;
-const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const SharedSliceId_1 = require("./SharedSliceId");
-// Wrapping the 'SharedSliceId' codec in an optional codec here for the sake of error reporting.
-// When using t.union([t.undefined, t.null, SharedSliceId]) we get a nested error context
-// with the actual decoding error at position 2 in the context array.
-// To avoid mutating the error context we create this new wrapper codec so that  the error context will always have desired depth.
-exports.OptionalSharedSliceId = new t.Type("OptionalSharedSliceId", (u) => u === null || u === undefined || SharedSliceId_1.SharedSliceId.is(u), (u, c) => {
-    if (u === null || u === undefined)
-        return t.success(u);
-    return SharedSliceId_1.SharedSliceId.validate(u, c);
-}, t.identity);

package/lib/import/validators/fields/Slices/SharedSlice/fields/SharedSliceContent/SharedSliceContent.d.ts

@@ -1,17 +0,0 @@
-import * as t from "io-ts";
-import { WidgetKey } from "../../../../../../../common";
-import type { NestableWidget } from "../../../../../../../customtypes";
-import type { ImportNestable } from "../../../../nestable";
-/**
- * Represents the object in the 'primary' field or a single item in the 'items' array in the SharedSlice.
- */
-export declare type SharedSliceContent = Record<WidgetKey, ImportNestable>;
-/**
- * Builds the decoder for a single entry in the 'primary' field or a single item in the 'items' array in the SharedSlice.
- *
- * @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
- * @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
- * @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
- * @constructor
- */
-export declare const SharedSliceContent: (sliceName: string, sliceContentField: "primary" | "items", sliceFieldModels: Record<WidgetKey, NestableWidget>) => t.Type<SharedSliceContent, SharedSliceContent, unknown>;

package/lib/import/validators/fields/Slices/SharedSlice/fields/SharedSliceContent/SharedSliceContent.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedSliceContent = void 0;
-const tslib_1 = require("tslib");
-const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
-const function_1 = require("fp-ts/lib/function");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const io_ts_types_1 = require("io-ts-types");
-const common_1 = require("../../../../../../../common");
-const io_ts_1 = require("../../../../../../../utils/io-ts");
-const errors_1 = require("./errors");
-const SharedSliceContentEntry_1 = require("./SharedSliceContentEntry");
-/**
- * Builds the decoder for the raw content object in the 'primary' field or a single item in the 'items' array in the SharedSlice.
- *
- * @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
- * @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
- */
-const RawContent = (sliceName, sliceContentField) => (0, io_ts_types_1.withMessage)(t.record(common_1.WidgetKey, t.unknown), () => errors_1.SharedSliceContentErrors.InvalidSliceItemContent(sliceName, sliceContentField));
-/**
- * Builds the decoder for a single entry in the 'primary' field or a single item in the 'items' array in the SharedSlice.
- *
- * @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
- * @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
- * @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
- * @constructor
- */
-const SharedSliceContent = (sliceName, sliceContentField, sliceFieldModels) => new t.Type("SharedSliceContent", (u) => t.record(common_1.WidgetKey, t.unknown).is(u), (u, c) => (0, function_1.pipe)(
-// We first decode the raw content object in the shape of Record<WidgetKey, unknown>
-RawContent(sliceName, sliceContentField).validate(u, c), E.chain((rawContent) => (0, function_1.pipe)(
-// We split the object into entries because there is no easy other way to decode each value with a different codec
-Object.entries(rawContent).map((entry) => (0, SharedSliceContentEntry_1.SharedSliceContentEntry)(sliceName, sliceContentField, sliceFieldModels).validate(entry, c)), 
-// We get a validation result for each entry in the content object (t.Validation<SharedSliceContentEntry>[]),
-// however we want to get a single validation result for the whole array of entries (t.Validation<SharedSliceContentEntry[]>).
-io_ts_1.combineValidationResults, 
-// We build the object back from entries if all decoded successfully
-E.map((entries) => entries.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}))))), t.identity);
-exports.SharedSliceContent = SharedSliceContent;

package/lib/import/validators/fields/Slices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.d.ts

@@ -1,43 +0,0 @@
-import * as t from "io-ts";
-import { WidgetKey } from "../../../../../../../common";
-import type { NestableWidget } from "../../../../../../../customtypes";
-import { ImportNestable } from "../../../../nestable";
-export declare type SharedSliceContentEntry = [WidgetKey, ImportNestable];
-/**
- * Represents a single entry in the 'primary' field or a single entry in an item in the 'items' array in the SharedSlice. It is used to build the SharedSliceContent type from entries of the import object.
- *
- * For example, given the following slice:
- * 	{
- *  	"slice_type": "my_slice",
- *  	"variation": "default",
- *      "primary": {
- *      	"slice_text": "abc", // This is one entry
- *          "slice_text2": "def: // This is another entry
- *       },
- *       "items": [
- *       	   {
- *             		"slice_number1": 0, // This is one entry
- *             		"slice_number2": 1	// And this is yet another entry
- *             }
- *       ]
- *  }
- *
- *  The 'primary' object is converted to following entries to be decoded:
- *  [
- *      ["slice_text", "abc"],
- *      ["slice_text2", "def"]
- *  ]
- *  and the first item in the 'items' array is converted to following entries to be decoded:
- *  [
- *    ["slice_number1", 0],
- *    ["slice_number2", 1]
- *  ]
- *
- *  We decode them as separate entries because each of the values might require a different codec as per what is specified in the SharedSlice custom type.
- *  In this way we save on the decoding performance in comparison to a scenario where we would decode the whole content object as a record with a union type decoder for each value.
- *
- *  @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
- *  @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
- *  @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
- */
-export declare const SharedSliceContentEntry: (sliceName: string, sliceContentField: "primary" | "items", sliceFieldModels: Record<WidgetKey, NestableWidget>) => t.Type<SharedSliceContentEntry, SharedSliceContentEntry, unknown>;