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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceId = exports.SharedSliceIdValidationError = 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.SharedSliceIdValidationError = {
+    Base: baseErrorText,
+    IncorrectUUID: (uuid) => `Incorrect UUID: '${uuid}' - ${baseErrorText}`,
+    IncorrectSliceType: (sliceType) => `Incorrect slice_type: '${sliceType}' - ${baseErrorText}`,
+};
+exports.SharedSliceId = new t.Type("SharedSliceId", (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.SharedSliceIdValidationError.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];
+        return {
+            ...error,
+            context: [
+                ...error.context.slice(0, -1), // We don't want the tuple decoder error context
+            ],
+            message: (tupleErrorContext === null || tupleErrorContext === void 0 ? void 0 : tupleErrorContext.key) === "0"
+                ? exports.SharedSliceIdValidationError.IncorrectSliceType(sliceName)
+                : exports.SharedSliceIdValidationError.IncorrectUUID(uuid),
+        };
+    })));
+}), E.map(([sliceName, uuid]) => `${sliceName}$${uuid}`)), (sliceId) => sliceId);

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { SharedSlice as SharedSliceCustomType } from "../../../../../../customtypes";
+export declare type SharedSliceType = {
+    slice_type: string;
+    data: SharedSliceCustomType;
+};
+/**
+ * Builds the decoder for the 'slice_type' field in the SharedSlice. Alongside the decoded 'slice_type' it also returns the SharedSlice data matching the slice_type.
+ * @param slices all the SharedSlices from the custom type
+ */
+export declare const SharedSliceType: (slices: SharedSliceCustomType[]) => t.Type<SharedSliceType, string, unknown>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceType = 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 customtypes_1 = require("../../../../../../customtypes");
+const validators_1 = require("../../../../../../validators");
+const utils_1 = require("../utils");
+/**
+ * slice_type - the validated slice_type
+ * slice - SharedSlice custom type data matching the slice_type. We return it alongside the validated slice_type, because it is needed to decode the 'variation' field in the SharedSlice (see SharedSliceVariation.ts)
+ */
+const SharedSliceTypeShape = t.type({
+    slice_type: validators_1.NonEmptyString,
+    slice: customtypes_1.SharedSlice,
+});
+/**
+ * Builds the decoder for the 'slice_type' field in the SharedSlice. Alongside the decoded 'slice_type' it also returns the SharedSlice data matching the slice_type.
+ * @param slices all the SharedSlices from the custom type
+ */
+const SharedSliceType = (slices) => new t.Type("slice_type", (u) => SharedSliceTypeShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((slice_type) => (0, function_1.pipe)((0, utils_1.findSlice)(slices)(slice_type), E.fold((err) => t.failure(u, c, err), (data) => t.success({ slice_type, data }))))), ({ slice_type }) => slice_type);
+exports.SharedSliceType = SharedSliceType;

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { SharedSlice, Variation } from "../../../../../../customtypes";
+export declare type SharedSliceVariation = {
+    variation: string;
+    data: Variation;
+};
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+export declare const SharedSliceVariation: (slice: SharedSlice) => t.Type<SharedSliceVariation, string, unknown>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceVariation = 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 customtypes_1 = require("../../../../../../customtypes");
+const validators_1 = require("../../../../../../validators");
+const utils_1 = require("../utils");
+/**
+ * variation - the validated variation of the slice
+ * data - Variation data matching the variation. We return it alongside the validated variation, because it is needed to decode the 'primary' and 'items' fields in the SharedSlice.
+ */
+const SharedSliceVariationShape = t.type({
+    variation: validators_1.NonEmptyString,
+    data: customtypes_1.Variation,
+});
+/**
+ * Builds the decoder for the 'variation' field in the SharedSlice. Alongside the decoded 'variation' it also returns the Variation data matching the variation custom type.
+ * @param slice SharedSlice from the custom type
+ */
+const SharedSliceVariation = (slice) => new t.Type("variation", (u) => SharedSliceVariationShape.is(u), (u, c) => (0, function_1.pipe)(validators_1.NonEmptyString.validate(u, c), E.chain((variation) => (0, function_1.pipe)((0, utils_1.findSliceVariation)(slice)(variation), E.fold((err) => t.failure(u, c, err), (data) => t.success({ variation, data }))))), ({ variation }) => variation);
+exports.SharedSliceVariation = SharedSliceVariation;

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

@@ -0,0 +1,5 @@
+export * from "./OptionalSharedSliceId";
+export * from "./SharedSliceContent";
+export * from "./SharedSliceId";
+export * from "./SharedSliceType";
+export * from "./SharedSliceVariation";

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

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

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

@@ -0,0 +1,3 @@
+export * from "./errors";
+export * from "./fields";
+export * from "./SharedSlice";

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

@@ -0,0 +1,6 @@
+"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("./fields"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSlice"), exports);

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

@@ -0,0 +1,339 @@
+import * as E from "fp-ts/Either";
+import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes";
+import type { Variation } from "../../../../../customtypes";
+export declare const findSlice: (slices: SharedSliceCustomType[]) => (sliceId: string) => E.Either<string, {
+    id: string;
+    type: "SharedSlice";
+    name: string;
+    variations: readonly ({
+        id: string;
+        name: string;
+        description: string;
+        imageUrl: string;
+        docURL: string;
+        version: string;
+    } & {
+        display?: string;
+        primary?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                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;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+        items?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                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;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+    })[];
+} & {
+    description?: string;
+}>;
+export declare const findSliceVariation: (slice: SharedSliceCustomType) => (variation: string) => E.Either<string, Variation>;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSliceVariation = exports.findSlice = 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 errors_1 = require("./errors");
+const findSlice = (slices) => (sliceId) => (0, function_1.pipe)(slices.find((slice) => slice.id === sliceId), E.fromNullable(errors_1.SharedSliceErrors.SliceTypeNotFound(sliceId)));
+exports.findSlice = findSlice;
+const findSliceVariation = (slice) => (variation) => (0, function_1.pipe)(slice.variations.find((v) => v.id === variation), E.fromNullable(errors_1.SharedSliceErrors.VariationNotFound(variation, slice.id)));
+exports.findSliceVariation = findSliceVariation;

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

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

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

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

package/lib/import/validators/fields/ImportSlices/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/ImportSlices/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/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.12",
 	"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)