@prismicio/types-internal 2.2.0 → 2.2.1-alpha.0

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

@@ -134,8 +134,9 @@ function traverseCompositeSliceContent({ path, sliceKey, sliceName, model, conte
 }
 exports.traverseCompositeSliceContent = traverseCompositeSliceContent;
 function migrateCompositeSlice(model, content) {
+    const [, sliceUUID] = content.key.split("$");
     return {
-        key: content.key,
+        key: `${model.sliceName}$${sliceUUID}`,
         name: model.sliceName,
         maybeLabel: content.maybeLabel,
         widget: {

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

@@ -87,9 +87,11 @@ function traverseSimpleSliceContent({ path, sliceKey, sliceName, model, content,
 exports.traverseSimpleSliceContent = traverseSimpleSliceContent;
 function migrateSimpleSlice(model, content) {
     var _a;
+    const [, sliceUUID] = content.key.split("$");
+    const key = `${model.sliceName}$${sliceUUID}`;
     if (content.widget.__TYPE__ === "GroupContentType") {
         return {
-            key: content.key,
+            key,
             name: model.sliceName,
             maybeLabel: content.maybeLabel,
             widget: {
@@ -111,7 +113,7 @@ function migrateSimpleSlice(model, content) {
         };
     }
     return {
-        key: content.key,
+        key,
         name: model.sliceName,
         maybeLabel: content.maybeLabel,
         widget: {

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

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

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

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

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

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

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

@@ -1,4 +1,21 @@
 import * as t from "io-ts";
+import type { Thumbnail } from "../../../../../customtypes";
+export declare const ImportImageViewShape: t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+}>, t.PartialC<{
+    dimensions: t.PartialC<{
+        width: t.NumberC;
+        height: t.NumberC;
+    }>;
+    edit: t.PartialC<{
+        x: t.NumberC;
+        y: t.NumberC;
+        zoom: t.NumberC;
+        background: t.StringC;
+    }>;
+    copyright: t.UnionC<[t.StringC, t.NullC]>;
+    alt: t.UnionC<[t.StringC, t.NullC]>;
+}>]>;
 export declare const ImportImageView: t.IntersectionC<[t.TypeC<{
     id: t.StringC;
 }>, t.PartialC<{
@@ -16,7 +33,57 @@ export declare const ImportImageView: t.IntersectionC<[t.TypeC<{
     alt: t.UnionC<[t.StringC, t.NullC]>;
 }>]>;
 export declare type ImportImageView = t.TypeOf<typeof ImportImageView>;
-export declare const ImportThumbnails: t.RecordC<t.StringC, t.IntersectionC<[t.TypeC<{
+declare const ImportThumbnails: (thumbnails: readonly Thumbnail[]) => t.Type<Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, unknown>;
+export declare type ImportThumbnails = t.TypeOf<ReturnType<typeof ImportThumbnails>>;
+export declare const ImportImageWithThumbnails: (def?: ({
+    type: "Image";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        constraint?: {
+            width?: number | null;
+            height?: number | null;
+        };
+        thumbnails?: readonly ({
+            name: string;
+        } & {
+            width?: number | null;
+            height?: number | null;
+        })[];
+    };
+}) | undefined) => t.IntersectionC<[t.IntersectionC<[t.TypeC<{
     id: t.StringC;
 }>, t.PartialC<{
     dimensions: t.PartialC<{
@@ -31,5 +98,35 @@ export declare const ImportThumbnails: t.RecordC<t.StringC, t.IntersectionC<[t.T
     }>;
     copyright: t.UnionC<[t.StringC, t.NullC]>;
     alt: t.UnionC<[t.StringC, t.NullC]>;
-}>]>>;
-export declare type ImportThumbnails = t.TypeOf<typeof ImportThumbnails>;
+}>]>, t.Type<Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, Record<string, {
+    id: string;
+} & {
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+    edit?: {
+        x?: number;
+        y?: number;
+        zoom?: number;
+        background?: string;
+    };
+    copyright?: string | null;
+    alt?: string | null;
+}>, unknown>]>;
+export {};

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportThumbnails = exports.ImportImageView = void 0;
+exports.ImportImageWithThumbnails = exports.ImportImageView = exports.ImportImageViewShape = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const BasicTypes_1 = require("../../../../../validators/BasicTypes");
 const function_1 = require("../../../../../validators/function");
-exports.ImportImageView = (0, function_1.withCustomError)(t.intersection([
+exports.ImportImageViewShape = t.intersection([
     t.type({
         // Image Id
         id: BasicTypes_1.String,
@@ -27,5 +27,17 @@ exports.ImportImageView = (0, function_1.withCustomError)(t.intersection([
         copyright: BasicTypes_1.StringOrNull,
         alt: BasicTypes_1.StringOrNull,
     }),
-]), () => "The value must be an object");
-exports.ImportThumbnails = t.record(t.string, exports.ImportImageView);
+]);
+exports.ImportImageView = (0, function_1.withCustomError)(exports.ImportImageViewShape, () => "The value must be an object");
+const ImportThumbnails = (thumbnails) => t.partial(thumbnails.reduce((acc, thumbnail) => ({
+    ...acc,
+    [thumbnail.name]: exports.ImportImageView,
+}), {}));
+const ImportImageWithThumbnails = (def) => {
+    var _a, _b;
+    return (0, function_1.withCustomError)(t.intersection([
+        exports.ImportImageViewShape,
+        ImportThumbnails((_b = (_a = def === null || def === void 0 ? void 0 : def.config) === null || _a === void 0 ? void 0 : _a.thumbnails) !== null && _b !== void 0 ? _b : []),
+    ]), () => "The value must be an object");
+};
+exports.ImportImageWithThumbnails = ImportImageWithThumbnails;

package/package.json

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

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

@@ -211,8 +211,9 @@ export function migrateCompositeSlice(
 	model: VariationFields,
 	content: CompositeSliceItemContent,
 ): SharedSliceItemContent {
+	const [, sliceUUID] = content.key.split("$")
 	return {
-		key: content.key,
+		key: `${model.sliceName}$${sliceUUID}`,
 		name: model.sliceName,
 		maybeLabel: content.maybeLabel,
 		widget: {

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

@@ -135,9 +135,12 @@ export function migrateSimpleSlice(
 	model: VariationFields,
 	content: SimpleSliceItemContent,
 ): SharedSliceItemContent {
+	const [, sliceUUID] = content.key.split("$")
+	const key = `${model.sliceName}$${sliceUUID}`
+
 	if (content.widget.__TYPE__ === "GroupContentType") {
 		return {
-			key: content.key,
+			key,
 			name: model.sliceName,
 			maybeLabel: content.maybeLabel,
 			widget: {
@@ -161,7 +164,7 @@ export function migrateSimpleSlice(
 		}
 	}
 	return {
-		key: content.key,
+		key,
 		name: model.sliceName,
 		maybeLabel: content.maybeLabel,
 		widget: {

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

@@ -2,24 +2,21 @@ import * as t from "io-ts"
 
 import type { Image as ImageDefinition } from "../../../../../customtypes"
 import { EmptyObject } from "../../../../../validators"
-import { withCustomError } from "../../../../../validators/function"
 
 export const defaultImportImage = (field?: ImageDefinition) => {
 	// If there is not thumbnails we expect an empty object
 	if (!field?.config?.thumbnails || !field.config.thumbnails.length)
 		return EmptyObject
 
-	// If there are thumbnails, we expect an object with thumbnails as empty objects
-	return withCustomError(
-		t.strict(
-			field.config.thumbnails.reduce(
-				(acc, thumbnail) => ({
-					...acc,
-					[thumbnail.name]: EmptyObject,
-				}),
-				{},
-			),
+	// If there are thumbnails, we can expect an object with thumbnails as empty objects,
+	// however we don't accept any other properties for the empty state
+	return t.strict(
+		field.config.thumbnails.reduce(
+			(acc, thumbnail) => ({
+				...acc,
+				[thumbnail.name]: EmptyObject,
+			}),
+			{},
 		),
-		() => "The value must be an object",
 	)
 }

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

@@ -1,4 +1,4 @@
-import { chain, map } from "fp-ts/Either"
+import { map } from "fp-ts/Either"
 import { pipe } from "fp-ts/function"
 import type { Validation } from "io-ts"
 import * as t from "io-ts"
@@ -13,7 +13,7 @@ import {
 	mergeThumbnailsWithCtConstraints,
 } from "./merge"
 import type { ImageFieldWithThumbnails } from "./model"
-import { ImportImageView, ImportThumbnails } from "./validators"
+import { ImportImageWithThumbnails } from "./validators"
 
 /* For code clarity, the output of this validator will be simplified
  *
@@ -21,53 +21,46 @@ import { ImportImageView, ImportThumbnails } from "./validators"
  *  Output -> type ImageWithThumbnails 👇
  */
 
-export const ImageFieldCodec = (field?: ImageDefinition) =>
-	new t.Type<ImageFieldWithThumbnails>(
+const ImageFieldCodec = (field?: ImageDefinition) => {
+	const ImageCodec = ImportImageWithThumbnails(field)
+	return new t.Type<ImageFieldWithThumbnails>(
 		"ImageField",
-		(u: unknown): u is ImageFieldWithThumbnails =>
-			ImportImageView.is(u) &&
-			"thumbnails" in u &&
-			ImportThumbnails.is(u["thumbnails"]),
-		(u: unknown, ctx): Validation<ImageFieldWithThumbnails> => {
-			return pipe(
-				// Validating the higher level image
-				ImportImageView.validate(u, ctx),
-				chain((imageApiV2) => {
+		(u: unknown): u is ImageFieldWithThumbnails => ImageCodec.is(u),
+		(u: unknown, ctx): Validation<ImageFieldWithThumbnails> =>
+			pipe(
+				ImageCodec.validate(u, ctx),
+				map((imageApiV2) => {
 					const { id, dimensions, edit, copyright, alt, ...thumbnails } =
 						imageApiV2
 
-					return pipe(
-						// Validating the thumbnails
-						ImportThumbnails.validate(thumbnails, ctx),
-						map((thumbnails) => ({
-							...mergeImageViewWithCtConstraints(
-								imageApiV2,
-								imageApiV2,
-								field?.config?.constraint,
-							),
-							thumbnails: mergeThumbnailsWithCtConstraints(
-								thumbnails,
-								imageApiV2,
-								field,
-							),
-						})),
-					)
+					return {
+						...mergeImageViewWithCtConstraints(
+							imageApiV2,
+							imageApiV2,
+							field?.config?.constraint,
+						),
+						thumbnails: mergeThumbnailsWithCtConstraints(
+							thumbnails,
+							imageApiV2,
+							field,
+						),
+					}
 				}),
-			)
-		},
+			),
 		t.identity,
 	)
-
-const ImageCodec = (field?: ImageDefinition) =>
-	withCustomError(
-		DefaultOrElse<Record<never, never>, ImageFieldWithThumbnails>(
-			defaultImportImage(field),
-		)(ImageFieldCodec(field)),
-		() => "An image field must be an object",
-	)
+}
 
 export const ImportImage = (field?: ImageDefinition) =>
-	ImportContent("Image", ImageCodec(field))
+	ImportContent(
+		"Image",
+		withCustomError(
+			DefaultOrElse<Record<never, never>, ImageFieldWithThumbnails>(
+				defaultImportImage(field),
+			)(ImageFieldCodec(field)),
+			() => "An image field must be an object",
+		),
+	)
 export type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>
 
 export * from "./model"

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

@@ -1,5 +1,9 @@
 import * as t from "io-ts"
 
+import type {
+	Image as ImageDefinition,
+	Thumbnail,
+} from "../../../../../customtypes"
 import {
 	Number,
 	String,
@@ -7,39 +11,60 @@ import {
 } from "../../../../../validators/BasicTypes"
 import { withCustomError } from "../../../../../validators/function"
 
+export const ImportImageViewShape = t.intersection([
+	t.type({
+		// Image Id
+		id: String,
+	}),
+	t.partial({
+		// Dimensions here will be used if they are not defined in the custom type
+		dimensions: withCustomError(
+			t.partial({
+				width: Number,
+				height: Number,
+			}),
+			() => "The value must be an object",
+		),
+		// Crop information
+		edit: withCustomError(
+			t.partial({
+				x: Number,
+				y: Number,
+				zoom: Number,
+				background: String,
+			}),
+			() => "The value must be an object",
+		),
+		// Copyrights and alt are set in the Asset by default but they can be overrided
+		copyright: StringOrNull,
+		alt: StringOrNull,
+	}),
+])
+
 export const ImportImageView = withCustomError(
-	t.intersection([
-		t.type({
-			// Image Id
-			id: String,
-		}),
-		t.partial({
-			// Dimensions here will be used if they are not defined in the custom type
-			dimensions: withCustomError(
-				t.partial({
-					width: Number,
-					height: Number,
-				}),
-				() => "The value must be an object",
-			),
-			// Crop information
-			edit: withCustomError(
-				t.partial({
-					x: Number,
-					y: Number,
-					zoom: Number,
-					background: String,
-				}),
-				() => "The value must be an object",
-			),
-			// Copyrights and alt are set in the Asset by default but they can be overrided
-			copyright: StringOrNull,
-			alt: StringOrNull,
-		}),
-	]),
+	ImportImageViewShape,
 	() => "The value must be an object",
 )
 export type ImportImageView = t.TypeOf<typeof ImportImageView>
 
-export const ImportThumbnails = t.record(t.string, ImportImageView)
-export type ImportThumbnails = t.TypeOf<typeof ImportThumbnails>
+const ImportThumbnails = (thumbnails: readonly Thumbnail[]) =>
+	t.partial(
+		thumbnails.reduce<Record<string, typeof ImportImageView>>(
+			(acc, thumbnail) => ({
+				...acc,
+				[thumbnail.name]: ImportImageView,
+			}),
+			{},
+		),
+	) as t.Type<Record<string, ImportImageView>>
+
+export type ImportThumbnails = t.TypeOf<ReturnType<typeof ImportThumbnails>>
+
+export const ImportImageWithThumbnails = (def?: ImageDefinition) =>
+	withCustomError(
+		t.intersection([
+			ImportImageViewShape,
+			ImportThumbnails(def?.config?.thumbnails ?? []),
+		]),
+		() => "The value must be an object",
+	)

package/lib/import/validators/fields/ImportSlices/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/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContent.js

@@ -1,30 +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 common_1 = require("../../../../../../../common");
-const io_ts_1 = require("../../../../../../../utils/io-ts");
-const function_2 = require("../../../../../../../validators/function");
-const SharedSliceContentEntry_1 = require("./SharedSliceContentEntry");
-/**
- * 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>
-(0, function_2.withCustomError)(t.UnknownRecord, () => "The value must be an object").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/ImportSlices/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>;

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedSliceContentEntry = 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 common_1 = require("../../../../../../../common");
-const nestable_1 = require("../../../../nestable");
-const errors_1 = require("./errors");
-/**
- * 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
- */
-const SharedSliceContentEntry = (sliceName, sliceContentField, sliceFieldModels) => new t.Type("SharedSliceContentEntry", (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 }], errors_1.SharedSliceContentErrors.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,
-                { key, actual: content, type: codec },
-                ...error.context.slice(1), // We ignore the first context element with "" key coming from ImportNestable decoder
-            ];
-            const updatedError = { ...error, context };
-            return updatedError;
-        })));
-    }));
-}, t.identity);
-exports.SharedSliceContentEntry = SharedSliceContentEntry;

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

@@ -1,4 +0,0 @@
-import type { SharedSliceContentField } from "./types";
-export declare const SharedSliceContentErrors: {
-    readonly UnknownField: (sliceName: string, contentField: SharedSliceContentField, fieldName: string) => string;
-};

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/errors.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedSliceContentErrors = void 0;
-exports.SharedSliceContentErrors = {
-    UnknownField: (sliceName, contentField, fieldName) => `Unsupported field '${fieldName}'for '${contentField}' content in Shared Slice '${sliceName}'`,
-};

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

@@ -1,2 +0,0 @@
-export * from "./errors";
-export * from "./SharedSliceContent";

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/index.js

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

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

@@ -1 +0,0 @@
-export declare type SharedSliceContentField = "primary" | "items";

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/types.js

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

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

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

package/lib/utils/io-ts.js

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