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

package/lib/common/UUID.d.ts

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+interface UUIDBrand {
+    readonly UUID: unique symbol;
+}
+export declare const UUID: t.BrandC<t.StringC, UUIDBrand>;
+export declare type UUID = t.TypeOf<typeof UUID>;
+export {};

package/lib/common/UUID.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UUID = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const uuid_1 = require("uuid");
+exports.UUID = (0, io_ts_types_1.withMessage)(t.brand(t.string, (s) => (0, uuid_1.validate)(s), "UUID"), () => "The value must be a valid UUID");

package/lib/content/fields/slices/Slice/RepeatableContent.js

@@ -14,5 +14,4 @@ const RepeatableWidgetsBlock = t.strict({
     __TYPE__: t.literal(GroupContent_1.GroupItemContentType),
     value: t.array(RepeatableWidget),
 });
-t.array(RepeatableWidget);
 exports.RepeatableWidgets = t.array(RepeatableWidgetsBlock);

package/lib/import/converters/Document.d.ts

@@ -1,5 +1,4 @@
-import type { Asset } from "../../common";
-import type { Embed } from "../../common/Embed";
+import type { Asset, Embed } from "../../common";
 import type { Document } from "../../content";
 import type { ImportDocument } from "../validators";
 export declare function convertImportToContent(document: ImportDocument, assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>): Document;

package/lib/import/converters/Document.js

@@ -13,6 +13,8 @@ function convertWidget(field, assets, embeds) {
     switch (field.type) {
         case "UID":
             return (0, fields_1.uidConverter)(field.value);
+        case "Slices":
+            return (0, fields_1.importSlicesConverter)(field.value, assets, embeds);
         default:
             return (0, fields_1.convertNestableWidget)(field, assets, embeds);
     }

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

@@ -0,0 +1,4 @@
+import type { Asset, Embed } from "../../../../common";
+import type { SliceItemContent } from "../../../../content";
+import type { SharedSlice as ImportSharedSlice } from "../../../validators/fields/ImportSlices/SharedSlice";
+export declare const sharedSliceConverter: (slice: ImportSharedSlice, assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>) => SliceItemContent;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedSliceConverter = void 0;
+const uuid_1 = require("uuid");
+const SharedSliceContent_1 = require("./SharedSliceContent");
+// TODO should we put it together with SharedSliceId validator?
+const buildSharedSliceId = (slice_type) => `${slice_type}$${(0, uuid_1.v4)()}`;
+const sharedSliceConverter = (slice, assets, embeds) => {
+    var _a, _b;
+    // Right now we only support SharedSlices, if we support more types of slices in the future we'll need to select a correct converter here
+    const widget = (0, SharedSliceContent_1.importSharedSliceContentConverter)(slice, assets, embeds);
+    return {
+        key: (_a = slice.id) !== null && _a !== void 0 ? _a : buildSharedSliceId(slice.slice_type),
+        name: slice.slice_type,
+        maybeLabel: (_b = slice.slice_label) !== null && _b !== void 0 ? _b : undefined,
+        widget,
+    };
+};
+exports.sharedSliceConverter = sharedSliceConverter;

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

@@ -0,0 +1,10 @@
+import type { Asset, Embed } from "../../../../common";
+import type { SharedSliceContent } from "../../../../content";
+import type { SharedSlice as ImportSharedSlice } from "../../../validators/fields/ImportSlices/SharedSlice";
+/**
+ * Builds SharedSliceContent model from ImportSharedSlice
+ * @param field ImportSharedSlice to be converted - a single slice from the slices array in the import document
+ * @param assets assets that are required for a conversion of a nestable widget
+ * @param embeds embeds that are required for a conversion of a nestable widget
+ */
+export declare const importSharedSliceContentConverter: (field: ImportSharedSlice, assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>) => SharedSliceContent;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importSharedSliceContentConverter = 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");
+/**
+ * Converts the ImportSharedSliceContent which is a record of widget keys and ImportNestable values to a record of widget keys and NestableContent values.
+ *
+ * @param content a single ImportSharedSliceContent
+ * @param assets assets that are required for a conversion of a nestable widget
+ * @param embeds embeds that are required for a conversion of a nestable widget
+ */
+const sharedSliceContentConverter = (content, assets, embeds) => (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, embeds), O.fromNullable)));
+/**
+ * Converts a list of items to a list of repeatable widgets.
+ * Each ImportSharedSliceContent element is a record of fields, but in the content model it is represented as a list of tuples (key, value)
+ *
+ * For example, given the following slice content:
+ *  {
+ *  	"slice_text": (ImportNestable),
+ *  	"slice_number": (ImportNestable),
+ *  }
+ *
+ *  has to be converted to:
+ *
+ *  {
+ *      __TYPE__: "GroupItemContentType",
+ *      value: [
+ *      	["slice_text", (NestableContent)],
+ *      	["slice_number", (NestableContent)],
+ *      ]
+ *  }
+ *
+ *  @param items list of items to be converted
+ *  @param assets assets that are required for a conversion of a nestable widget
+ */
+const itemsConverter = (items, assets, embeds) => items.map((item) => (0, function_1.pipe)(sharedSliceContentConverter(item, assets, embeds), (record) => Object.entries(record), (entries) => ({ __TYPE__: content_1.GroupItemContentType, value: entries })));
+/**
+ * Builds SharedSliceContent model from ImportSharedSlice
+ * @param field ImportSharedSlice to be converted - a single slice from the slices array in the import document
+ * @param assets assets that are required for a conversion of a nestable widget
+ * @param embeds embeds that are required for a conversion of a nestable widget
+ */
+const importSharedSliceContentConverter = (field, assets, embeds) => ({
+    __TYPE__: content_1.SharedSliceContentType,
+    primary: field.primary
+        ? sharedSliceContentConverter(field.primary, assets, embeds)
+        : {},
+    items: field.items ? itemsConverter(field.items, assets, embeds) : [],
+    variation: field.variation,
+});
+exports.importSharedSliceContentConverter = importSharedSliceContentConverter;

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,24 @@
+"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/converters/fields/Slices/Slices.d.ts

@@ -0,0 +1,4 @@
+import type { Asset, Embed } from "../../../../common";
+import type { SlicesContent } from "../../../../content";
+import type { ImportSlices } from "../../../validators/fields/ImportSlices";
+export declare const importSlicesConverter: (field: ImportSlices["value"], assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>) => SlicesContent | undefined;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importSlicesConverter = void 0;
+const SharedSlice_1 = require("./SharedSlice");
+const importSlicesConverter = (field, assets, embeds) => {
+    if (field === null)
+        return;
+    return {
+        value: field.map((slice) => {
+            // Right now we only support SharedSlices, if we support more types of slices in the future we'll need to select a correct converter here
+            return (0, SharedSlice_1.sharedSliceConverter)(slice, assets, embeds);
+        }),
+        __TYPE__: "SliceContentType",
+    };
+};
+exports.importSlicesConverter = importSlicesConverter;

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

@@ -0,0 +1 @@
+export * from "./Slices";

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

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

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

@@ -1,2 +1,3 @@
 export * from "./nestable";
+export * from "./Slices";
 export * from "./UID";

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

@@ -2,4 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./nestable"), exports);
+(0, tslib_1.__exportStar)(require("./Slices"), exports);
 (0, tslib_1.__exportStar)(require("./UID"), exports);

package/lib/import/converters/fields/nestable/Nestable.d.ts

@@ -1,5 +1,5 @@
 import type { Asset } from "../../../../common";
 import type { Embed } from "../../../../common/Embed";
-import type { WidgetContent } from "../../../../content";
+import type { NestableContent } from "../../../../content";
 import type { ImportNestable } from "../../../validators";
-export declare function convertNestableWidget(field: ImportNestable, assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>): WidgetContent | undefined;
+export declare function convertNestableWidget(field: ImportNestable, assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>): NestableContent | undefined;

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

@@ -1,7 +1,8 @@
 import type { StaticWidget } from "../../../customtypes";
+import { ImportSlices } from "./ImportSlices";
 import { ImportNestable } from "./nestable";
 import { ImportUID } from "./UID";
-export declare type ImportField = ImportUID | ImportNestable;
+export declare type ImportField = ImportUID | ImportSlices | ImportNestable;
 export declare const ImportField: {
     is(u: unknown): u is ImportNestable;
     decode: (field: StaticWidget) => (content: unknown) => {
@@ -121,5 +122,14 @@ export declare const ImportField: {
             type: "UID";
             value: string | null;
         }>;
+    } | {
+        codec: import("io-ts").Type<{
+            type: "Slices";
+            value: import("./ImportSlices/SharedSlice").SharedSlice[] | null;
+        }, import("./ImportSlices/SharedSlice").SharedSlice[] | undefined, unknown>;
+        result: import("io-ts").Validation<{
+            type: "Slices";
+            value: import("./ImportSlices/SharedSlice").SharedSlice[] | null;
+        }>;
     };
 };

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportField = void 0;
+const ImportSlices_1 = require("./ImportSlices");
 const nestable_1 = require("./nestable");
 const UID_1 = require("./UID");
 exports.ImportField = {
@@ -12,8 +13,12 @@ exports.ImportField = {
             switch (field.type) {
                 case "UID":
                     return { codec: UID_1.ImportUID, result: UID_1.ImportUID.decode(content) };
-                case "Choice":
                 case "Slices":
+                    return {
+                        codec: (0, ImportSlices_1.ImportSlices)(field),
+                        result: (0, ImportSlices_1.ImportSlices)(field).decode(content),
+                    };
+                case "Choice":
                 case "Group":
                     throw new Error(`Unsupported type of field ${field.type}`);
                 default:

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,43 @@
+"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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,87 @@
+"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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,41 @@
+"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/ImportSlices/ImportSlices.d.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+import type { StaticSlices } from "../../../../customtypes";
+import { SharedSlice } from "./SharedSlice";
+export declare const ImportSlices: (staticSlices: StaticSlices) => t.Type<{
+    type: "Slices";
+    value: SharedSlice[] | null;
+}, SharedSlice[] | undefined, unknown>;
+export declare type ImportSlices = t.TypeOf<ReturnType<typeof ImportSlices>>;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportSlices = 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 ImportContent_1 = require("../ImportContent");
+const SharedSlice_1 = require("./SharedSlice");
+const utils_1 = require("./utils");
+const ImportSlices = (staticSlices) => {
+    const supportedSlices = (0, utils_1.extractSupportedSlices)(staticSlices);
+    // For now we only support the SharedSlice, however if we want to support more in the future
+    // we would have to change the codec here to something like this: t.array(t.union([ImportSharedSlice(sharedSlices), NewSliceCodec(newSliceCustomTypes)])).
+    const SlicesArrayCodec = t.array((0, SharedSlice_1.SharedSlice)(supportedSlices));
+    return (0, ImportContent_1.ImportContent)("Slices", (0, validators_1.EmptyObjectOrElse)(new t.Type("ImportSlices", (u) => SlicesArrayCodec.is(u), (u, c) => {
+        return (0, function_1.pipe)(SlicesArrayCodec.validate(u, c), E.chain((slices) => {
+            // This part might not make sense for all Slice types in the future, but for now we only support the SharedSlice
+            // In case we support more in the future, we would have to filter only the relevant type for this check
+            const sharedSliceDuplicates = (0, utils_1.findImportSharedSliceDuplicateIds)(slices);
+            if (sharedSliceDuplicates.length > 0) {
+                return t.failure(slices, [], `Duplicate slice IDs detected: ${sharedSliceDuplicates.join(", ")}`);
+            }
+            return t.success(slices);
+        }));
+    }, t.identity)));
+};
+exports.ImportSlices = ImportSlices;

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

@@ -0,0 +1,14 @@
+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/ImportSlices/SharedSlice/SharedSlice.js

@@ -0,0 +1,60 @@
+"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: validators_1.AnyArray.pipe(t.array((0, fields_1.SharedSliceContent)(decoded.slice_type.slice_type, "items", (_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/ImportSlices/SharedSlice/errors.d.ts

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