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

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Slices = 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 Slices = (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.Slices = Slices;

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

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

package/lib/import/validators/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/validators/fields/Slices/utils.d.ts

@@ -0,0 +1,4 @@
+import { SharedSlice as SharedSliceCustomType, StaticSlices } from "../../../../customtypes";
+import type { SharedSlice, SharedSliceId } from "./SharedSlice";
+export declare const extractSupportedSlices: (staticSlices: StaticSlices) => SharedSliceCustomType[];
+export declare const findImportSharedSliceDuplicateIds: (slices: SharedSlice[]) => SharedSliceId[];

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findImportSharedSliceDuplicateIds = exports.extractSupportedSlices = void 0;
+const tslib_1 = require("tslib");
+const A = (0, tslib_1.__importStar)(require("fp-ts/Array"));
+const function_1 = require("fp-ts/function");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const customtypes_1 = require("../../../../customtypes");
+// Extracts all supported slices from the static slices object
+// For now we only support the SharedSlice, if we want to support other slices in the future, we have to add them here
+const extractSupportedSlices = (staticSlices) => {
+    var _a, _b;
+    return (0, function_1.pipe)(Object.values((_b = (_a = staticSlices.config) === null || _a === void 0 ? void 0 : _a.choices) !== null && _b !== void 0 ? _b : {}).map((slice) => (0, function_1.pipe)(customtypes_1.SharedSlice.decode(slice), O.fromEither)), A.compact);
+};
+exports.extractSupportedSlices = extractSupportedSlices;
+const findImportSharedSliceDuplicateIds = (slices) => {
+    const duplicatesMap = slices.reduce((acc, { id }) => {
+        var _a;
+        if (id) {
+            const currentNumOfDuplicates = (_a = acc[id]) !== null && _a !== void 0 ? _a : 0;
+            return {
+                ...acc,
+                [id]: acc[id] === undefined ? 0 : currentNumOfDuplicates + 1,
+            };
+        }
+        return acc;
+    }, {});
+    return Object.entries(duplicatesMap).flatMap(([id, numOfDuplicates]) => {
+        if (numOfDuplicates > 0) {
+            return [id];
+        }
+        return [];
+    });
+};
+exports.findImportSharedSliceDuplicateIds = findImportSharedSliceDuplicateIds;

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

@@ -0,0 +1,4 @@
+import * as t from "io-ts";
+import { UUID } from "io-ts-types";
+export declare type SliceId = `${string}$${UUID}`;
+export declare const SliceId: t.Type<string, string, unknown>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliceId = 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");
+exports.SliceId = t.string.pipe(new t.Type("SliceId", (u) => typeof u === "string", (u, c) => {
+    const [sliceType, uuid] = u.split("$");
+    return (0, function_1.pipe)(t.string.validate(sliceType, c), E.chain((sliceType) => (0, function_1.pipe)(io_ts_types_1.UUID.validate(uuid, c), E.map((decodedUUID) => `${sliceType}$${decodedUUID}`))));
+}, t.identity));

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

@@ -1,62 +1,45 @@
 import * as t from "io-ts";
-export declare type ImageField = {
+declare const ImageFieldCodec: t.Type<{
     id: string;
-    edit: {
+} & {
+    edit?: {
         x: number;
         y: number;
+        width: number;
+        height: number;
         zoom: number;
-        background?: string;
+        background: string;
     };
-    dimensions: {
-        width?: number;
-        height?: number;
+    credit?: string | null;
+    alt?: string | null;
+}, {
+    [x: string]: unknown;
+}, unknown>;
+declare const ThumbnailsCodec: t.RecordC<t.StringC, t.Type<{
+    id: string;
+} & {
+    edit?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zoom: number;
+        background: string;
     };
     credit?: string | null;
     alt?: string | null;
-};
+}, {
+    [x: string]: unknown;
+}, unknown>>;
+declare type Thumbnails = t.TypeOf<typeof ThumbnailsCodec>;
+export declare type ImageField = t.TypeOf<typeof ImageFieldCodec>;
 declare type ImageFieldWithThumbnails = ImageField & {
-    thumbnails: Record<string, ImageField>;
+    thumbnails: Thumbnails;
 };
-declare const ImageFieldWithThumbnails: (field?: ({
-    type: "Image";
-} & {
-    fieldset?: string | null | undefined;
-    config?: {
-        label?: string | null | undefined;
-        placeholder?: string;
-        constraint?: {
-            width?: number | null;
-            height?: number | null;
-        };
-        thumbnails?: readonly ({
-            name: string;
-        } & {
-            width?: number | null;
-            height?: number | null;
-        })[];
-    };
-}) | undefined) => t.Type<ImageFieldWithThumbnails, ImageFieldWithThumbnails, unknown>;
-export declare const ImportImage: (field?: ({
-    type: "Image";
-} & {
-    fieldset?: string | null | undefined;
-    config?: {
-        label?: string | null | undefined;
-        placeholder?: string;
-        constraint?: {
-            width?: number | null;
-            height?: number | null;
-        };
-        thumbnails?: readonly ({
-            name: string;
-        } & {
-            width?: number | null;
-            height?: number | null;
-        })[];
-    };
-}) | undefined) => t.Type<{
+declare const ImageFieldWithThumbnails: t.Type<ImageFieldWithThumbnails, ImageFieldWithThumbnails, unknown>;
+export declare const ImportImage: t.Type<{
     type: "Image";
     value: ImageFieldWithThumbnails | null;
 }, ImageFieldWithThumbnails | undefined, unknown>;
-export declare type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>;
+export declare type ImportImage = t.TypeOf<typeof ImportImage>;
 export {};

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

@@ -5,72 +5,41 @@ const tslib_1 = require("tslib");
 const Either_1 = require("fp-ts/Either");
 const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const Objects_1 = require("../../../../utils/Objects");
 const validators_1 = require("../../../../validators");
 const BasicTypes_1 = require("../../../../validators/BasicTypes");
 const ImportContent_1 = require("../ImportContent");
-const ImageFieldValidator = BasicTypes_1.AnyObject.pipe(t.intersection([
+const ImageFieldCodec = validators_1.AnyObject.pipe(t.intersection([
     t.type({
         id: BasicTypes_1.String,
     }),
     t.partial({
-        dimensions: BasicTypes_1.AnyObject.pipe(t.partial({
-            width: BasicTypes_1.Number,
-            height: BasicTypes_1.Number,
-        })),
-        edit: BasicTypes_1.AnyObject.pipe(t.partial({
-            x: BasicTypes_1.Number,
-            y: BasicTypes_1.Number,
-            zoom: BasicTypes_1.Number,
+        edit: validators_1.AnyObject.pipe(t.strict({
+            x: validators_1.Number,
+            y: validators_1.Number,
+            width: validators_1.Number,
+            height: validators_1.Number,
+            zoom: validators_1.Number,
             background: BasicTypes_1.String,
         })),
         credit: BasicTypes_1.StringOrNull,
         alt: BasicTypes_1.StringOrNull,
     }),
 ]));
-const ThumbnailsValidator = t.record(t.string, ImageFieldValidator);
-const encodeImageField = (image, mainImage, 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 = mainImage.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 = mainImage.dimensions) === null || _j === void 0 ? void 0 : _j.height;
-    const alt = image === null || image === void 0 ? void 0 : image.alt;
-    const credit = image === null || image === void 0 ? void 0 : image.credit;
-    return {
-        id: (_k = image === null || image === void 0 ? void 0 : image.id) !== null && _k !== void 0 ? _k : mainImage === null || mainImage === void 0 ? void 0 : mainImage.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 } : {}),
-        ...(credit !== undefined ? { credit } : {}),
-    };
-};
-const encodeThumbnails = (mainImage, thumbnails, 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]: encodeImageField(thumbnails[thumbnail.name], mainImage, thumbnail),
-    }), {})) !== null && _c !== void 0 ? _c : {};
-};
-const ImageFieldWithThumbnails = (field) => new t.Type("ImageFieldWithThumbnails", (u) => ImageFieldValidator.is(u) &&
+const ThumbnailsCodec = t.record(t.string, ImageFieldCodec);
+const ImageFieldWithThumbnails = new t.Type("ImageFieldWithThumbnails", (u) => ImageFieldCodec.is(u) &&
     "thumbnails" in u &&
-    ThumbnailsValidator.is(u["thumbnails"]), (u, ctx) => {
-    return (0, function_1.pipe)(ImageFieldValidator.validate(u, ctx), (0, Either_1.chain)((mainImage) => {
-        const { id, dimensions, edit, credit, alt, ...maybeThumbnails } = mainImage;
-        return (0, function_1.pipe)(ThumbnailsValidator.validate(maybeThumbnails, ctx), (0, Either_1.map)((thumbnails) => {
-            var _a;
-            return ({
-                ...encodeImageField(mainImage, mainImage, (_a = field === null || field === void 0 ? void 0 : field.config) === null || _a === void 0 ? void 0 : _a.constraint),
-                thumbnails: encodeThumbnails(mainImage, thumbnails, field),
-            });
-        }));
+    ThumbnailsCodec.is(u["thumbnails"]), (u, ctx) => {
+    return (0, function_1.pipe)(ImageFieldCodec.validate(u, ctx), (0, Either_1.chain)((proto) => {
+        const { id, edit, credit, alt, ...maybeThumbnails } = proto;
+        return (0, function_1.pipe)(ThumbnailsCodec.validate(maybeThumbnails, ctx), (0, Either_1.map)((thumbnails) => (0, Objects_1.withOptionals)({
+            id,
+            thumbnails,
+        }, [
+            ["edit", edit],
+            ["credit", credit],
+            ["alt", alt],
+        ])));
     }));
 }, t.identity);
-const ImportImage = (field) => (0, ImportContent_1.ImportContent)("Image", (0, validators_1.NullOrElse)(ImageFieldWithThumbnails(field)));
-exports.ImportImage = ImportImage;
+exports.ImportImage = (0, ImportContent_1.ImportContent)("Image", (0, validators_1.NullOrElse)(ImageFieldWithThumbnails));

package/lib/utils/io-ts.d.ts

@@ -0,0 +1,2 @@
+import type { Validation } from "io-ts";
+export declare const combineValidationResults: <T>(validationResults: readonly Validation<T>[]) => Validation<readonly T[]>;

package/lib/utils/io-ts.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineValidationResults = 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 RA = (0, tslib_1.__importStar)(require("fp-ts/ReadonlyArray"));
+/*
+ * Semigroup simply defines how to concatenate two values of the same type.
+ * In this instance, Errors from io-ts are arrays already, so we just need to concatenate them.
+ */
+const validationErrorsSemigroup = {
+    concat: (a, b) => [...a, ...b],
+};
+/*
+ * This is a helper function to combine multiple io-ts validations into one.
+ *  t.array(...) works in the same way - it collects all the errors when decoding an array of values.
+ * 	However, it requires you to pass in a single io-ts validator as a parameter, which is not always convenient.
+ * 	Sometimes we have arrays of validation results received from function calls that don't have a validator instance.
+ */
+const combineValidationResults = (validationResults) => (0, function_1.pipe)(validationResults, RA.traverse(E.getApplicativeValidation(validationErrorsSemigroup))((validation) => validation));
+exports.combineValidationResults = combineValidationResults;

package/lib/validators/BasicTypes.d.ts

@@ -9,3 +9,4 @@ export declare const EmptyObject: t.Type<Record<never, never>, {
 }, unknown>;
 export declare const EmptyArray: t.Type<never[], never[], unknown>;
 export declare const AnyObject: t.RecordC<t.StringC, t.UnknownC>;
+export declare const AnyArray: t.ArrayC<t.UnknownC>;

package/lib/validators/BasicTypes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnyObject = exports.EmptyArray = exports.EmptyObject = exports.Boolean = exports.NumberOrNull = exports.Number = exports.StringOrNull = exports.String = void 0;
+exports.AnyArray = exports.AnyObject = exports.EmptyArray = exports.EmptyObject = exports.Boolean = exports.NumberOrNull = exports.Number = exports.StringOrNull = exports.String = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const function_1 = require("fp-ts/lib/function");
@@ -24,3 +24,4 @@ exports.EmptyArray = new t.Type("emptyArray", (u) => t.UnknownArray.is(u) && u.l
     }));
 }, () => []);
 exports.AnyObject = (0, io_ts_types_1.withMessage)(t.record(t.string, t.unknown), () => "The value must be an object");
+exports.AnyArray = (0, io_ts_types_1.withMessage)(t.array(t.unknown), () => "The value must be an array");

package/lib/validators/NonEmptyString.js

@@ -2,5 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
 const function_1 = require("./function");
-exports.default = (0, function_1.refineType)(t.string, "nonEmptyString", (s) => s.trim().length > 0);
+exports.default = (0, io_ts_types_1.withMessage)((0, function_1.refineType)(t.string, "nonEmptyString", (s) => s.trim().length > 0), () => "The value must be a non-empty string");

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-alpha.10",
+	"version": "2.2.0-alpha.11",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",
@@ -67,7 +67,9 @@
 	"peerDependencies": {
 		"fp-ts": "^2.11.8",
 		"io-ts": "^2.2.16",
-		"io-ts-types": "^0.5.16"
+		"io-ts-types": "^0.5.16",
+		"uuid": "^9.0.0",
+		"@types/uuid": "^9.0.2"
 	},
 	"engines": {
 		"node": ">=12.7.0"

package/src/common/UUID.ts

@@ -0,0 +1,18 @@
+import * as t from "io-ts"
+import { withMessage } from "io-ts-types"
+import { validate as validateUUID } from "uuid"
+
+interface UUIDBrand {
+	readonly UUID: unique symbol
+}
+
+export const UUID = withMessage(
+	t.brand(
+		t.string,
+		(s): s is t.Branded<string, UUIDBrand> => validateUUID(s),
+		"UUID",
+	),
+	() => "The value must be a valid UUID",
+)
+
+export type UUID = t.TypeOf<typeof UUID>

package/src/content/fields/slices/Slice/RepeatableContent.ts

@@ -13,6 +13,5 @@ const RepeatableWidgetsBlock = t.strict({
 	__TYPE__: t.literal(GroupItemContentType),
 	value: t.array(RepeatableWidget),
 })
-t.array(RepeatableWidget)
 
 export const RepeatableWidgets = t.array(RepeatableWidgetsBlock)

package/src/import/converters/Document.ts

@@ -1,9 +1,12 @@
-import type { Asset } from "../../common"
-import type { Embed } from "../../common/Embed"
+import type { Asset, Embed } from "../../common"
 import type { Document, WidgetContent } from "../../content"
 import type { ImportDocument } from "../validators"
 import type { ImportField } from "../validators/fields/ImportField"
-import { convertNestableWidget, uidConverter } from "./fields"
+import {
+	convertNestableWidget,
+	importSlicesConverter,
+	uidConverter,
+} from "./fields"
 
 export function convertImportToContent(
 	document: ImportDocument,
@@ -27,6 +30,8 @@ function convertWidget(
 	switch (field.type) {
 		case "UID":
 			return uidConverter(field.value)
+		case "Slices":
+			return importSlicesConverter(field.value, assets, embeds)
 		default:
 			return convertNestableWidget(field, assets, embeds)
 	}

package/src/import/converters/fields/Slices/SharedSlice.ts

@@ -0,0 +1,24 @@
+import { v4 as uuid } from "uuid"
+
+import type { Asset, Embed } from "../../../../common"
+import type { SliceItemContent } from "../../../../content"
+import type { SharedSlice as ImportSharedSlice } from "../../../validators/fields/ImportSlices/SharedSlice"
+import { importSharedSliceContentConverter } from "./SharedSliceContent"
+
+// TODO should we put it together with SharedSliceId validator?
+const buildSharedSliceId = (slice_type: string) => `${slice_type}$${uuid()}`
+
+export const sharedSliceConverter = (
+	slice: ImportSharedSlice,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SliceItemContent => {
+	// 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 = importSharedSliceContentConverter(slice, assets, embeds)
+	return {
+		key: slice.id ?? buildSharedSliceId(slice.slice_type),
+		name: slice.slice_type,
+		maybeLabel: slice.slice_label ?? undefined,
+		widget,
+	}
+}

package/src/import/converters/fields/Slices/SharedSliceContent.ts

@@ -0,0 +1,94 @@
+import { pipe } from "fp-ts/function"
+import * as O from "fp-ts/Option"
+import * as R from "fp-ts/Record"
+
+import type { Asset, Embed } from "../../../../common"
+import type { NestableContent, SharedSliceContent } from "../../../../content"
+import {
+	GroupItemContentType,
+	SharedSliceContentType,
+} from "../../../../content"
+import type {
+	SharedSlice as ImportSharedSlice,
+	SharedSliceContent as ImportSharedSliceContent,
+} from "../../../validators/fields/ImportSlices/SharedSlice"
+import { convertNestableWidget } from "../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: ImportSharedSliceContent,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): Record<string, NestableContent> =>
+	pipe(
+		content,
+		// convertNestableWidget can theoretically return undefined, so we need to filter out those values
+		R.filterMap((contentValue) =>
+			pipe(
+				contentValue,
+				(content) => 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: ImportSharedSliceContent[],
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SharedSliceContent["items"] =>
+	items.map((item) =>
+		pipe(
+			sharedSliceContentConverter(item, assets, embeds),
+			(record) => Object.entries(record),
+			(entries) => ({ __TYPE__: 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
+ */
+export const importSharedSliceContentConverter = (
+	field: ImportSharedSlice,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SharedSliceContent => ({
+	__TYPE__: SharedSliceContentType,
+	primary: field.primary
+		? sharedSliceContentConverter(field.primary, assets, embeds)
+		: {},
+	items: field.items ? itemsConverter(field.items, assets, embeds) : [],
+	variation: field.variation,
+})

package/src/import/converters/fields/Slices/Slices.ts

@@ -0,0 +1,20 @@
+import type { Asset, Embed } from "../../../../common"
+import type { SliceItemContent, SlicesContent } from "../../../../content"
+import type { ImportSlices } from "../../../validators/fields/ImportSlices"
+import { sharedSliceConverter } from "./SharedSlice"
+
+export const importSlicesConverter = (
+	field: ImportSlices["value"],
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): SlicesContent | undefined => {
+	if (field === null) return
+
+	return {
+		value: field.map((slice): SliceItemContent => {
+			// 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 sharedSliceConverter(slice, assets, embeds)
+		}),
+		__TYPE__: "SliceContentType",
+	}
+}

package/src/import/converters/fields/Slices/index.ts

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

package/src/import/converters/fields/index.ts

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

package/src/import/converters/fields/nestable/Nestable.ts

@@ -1,6 +1,6 @@
 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"
 import {
 	booleanConverter,
@@ -20,7 +20,7 @@ export function convertNestableWidget(
 	field: ImportNestable,
 	assets: Record<Asset["id"], Asset | undefined>,
 	embeds: Record<string, Embed | undefined>,
-): WidgetContent | undefined {
+): NestableContent | undefined {
 	switch (field.type) {
 		case "Boolean":
 			return booleanConverter(field.value)

package/src/import/validators/fields/ImportField.ts

@@ -1,8 +1,9 @@
 import type { StaticWidget } from "../../../customtypes"
+import { ImportSlices } from "./ImportSlices"
 import { ImportNestable } from "./nestable"
 import { ImportUID } from "./UID"
 
-export type ImportField = ImportUID | ImportNestable
+export type ImportField = ImportUID | ImportSlices | ImportNestable
 
 export const ImportField = {
 	is(u: unknown): u is ImportNestable {
@@ -13,8 +14,12 @@ export const ImportField = {
 			switch (field.type) {
 				case "UID":
 					return { codec: ImportUID, result: ImportUID.decode(content) }
-				case "Choice":
 				case "Slices":
+					return {
+						codec: ImportSlices(field),
+						result: ImportSlices(field).decode(content),
+					}
+				case "Choice":
 				case "Group":
 					throw new Error(`Unsupported type of field ${field.type}`)
 				default: