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

package/src/validators/DefaultOrElse.ts

@@ -0,0 +1,24 @@
+import { isRight } from "fp-ts/lib/Either"
+import * as t from "io-ts"
+
+import { EmptyArray, EmptyObject } from "./BasicTypes"
+
+export const DefaultOrElse = <I, A, O = A>(inputValidator: t.Type<I>) => {
+	return (codec: t.Type<A, O>) =>
+		new t.Type<A | null, O | undefined>(
+			"NullOrT",
+			(u: unknown): u is A | null => null === u || codec.is(u),
+			(u: unknown) => {
+				if (isRight(inputValidator.decode(u))) return t.success(null)
+				return codec.decode(u)
+			},
+			(chunk) => (chunk ? codec.encode(chunk) : undefined),
+		)
+}
+
+export const NullOrElse = <A, O = A>(codec: t.Type<A, O>) =>
+	DefaultOrElse<null, A, O>(t.null)(codec)
+export const EmptyObjectOrElse = <A, O = A>(codec: t.Type<A, O>) =>
+	DefaultOrElse<Record<never, never>, A, O>(EmptyObject)(codec)
+export const EmptyArrayOrElse = <A, O = A>(codec: t.Type<A, O>) =>
+	DefaultOrElse<never[], A, O>(EmptyArray)(codec)

package/src/validators/NumberRange.ts

@@ -0,0 +1,51 @@
+import * as t from "io-ts"
+
+import { Number } from "./BasicTypes"
+
+/**
+ * Creates a custom runtime type for validating that a number falls within a specified range.
+ *
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @param fieldName - The name of the field being validated (used in error messages).
+ * @returns A runtime type representing the number range validation.
+ *
+ *  * @example
+ * // Creating a custom runtime type for age validation
+ * const AgeType = numberInRange(18, 99, 'Age');
+ *
+ * // Valid age
+ * const validAgeResult = AgeType.decode(25);
+ * if (t.isRight(validAgeResult)) {
+ *   console.log('Valid age:', validAgeResult.right); // Output: Valid age: 25
+ * } else {
+ *   console.error('Invalid age:', t.left(validAgeResult).map(t.reporter.report));
+ * }
+ *
+ * @example
+ * // Invalid age
+ * const invalidAgeResult = AgeType.decode(15);
+ * if (t.isRight(invalidAgeResult)) {
+ *   console.log('Valid age:', invalidAgeResult.right);
+ * } else {
+ *   console.error('Invalid age:', t.left(invalidAgeResult).map(t.reporter.report));
+ * }
+ */
+export default (min: number, max: number, fieldName: string) =>
+	Number.pipe(
+		new t.Type<number, number, number>(
+			"numberInRange",
+			(u: unknown): u is number => Number.is(u),
+			(u: number, context) => {
+				if (u > max || u < min) {
+					return t.failure(
+						u,
+						context,
+						`${fieldName} must be a number between ${min} and ${max}`,
+					)
+				}
+				return t.success(u)
+			},
+			t.identity,
+		),
+	)

package/src/validators/function.ts

@@ -1,6 +1,7 @@
 import { either } from "fp-ts"
 import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
+import { withValidate } from "io-ts-types"
 import { mapOutput } from "io-ts-types/mapOutput"
 
 export function nullable<A, O>(c: t.Type<A, O>) {
@@ -69,3 +70,46 @@ export function addType<A, O extends object, I, T extends string>(
 ): t.Type<A, O & { __TYPE__: T }, I> {
 	return mapOutput(codec, (o) => ({ ...o, __TYPE__: t } as const))
 }
+
+/**
+ * Returns a clone of the given codec that tries to find sub-error with message already set.
+ * If there is such error it just returns sub-errors array.
+ * If there is no such error it generates new error with given message.
+ *
+ * @example
+ * expect(
+ * 		withFallbackMessage(
+ * 			t.type({age: withMessage(t.number, () => 'Invalid child')}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid child"}])
+ * expect(
+ * 		withFallbackMessage(
+ * 			t.type({age: t.number}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid parent"}])
+ */
+export function withFallbackMessage<C extends t.Any>(
+	codec: C,
+	message: (i: t.InputOf<C>, c: t.Context) => string,
+): C {
+	return withValidate(codec, (i, c) => {
+		return either.mapLeft((errors: t.Errors) => {
+			if (errors.find((error) => error.message)) {
+				return errors
+			}
+
+			return [
+				{
+					value: i,
+					context: c,
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+					message: message(i, c),
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+					actual: i,
+				},
+			]
+		})(codec.validate(i, c))
+	})
+}

package/src/validators/index.ts

@@ -2,13 +2,14 @@ export * from "./BasicTypes"
 export { default as DateFromString } from "./DateFromString"
 export { default as DateFromStringOrNumber } from "./DateFromStringOrNumber"
 export { default as DateFromTsMs } from "./DateFromTsMs"
+export * from "./DefaultOrElse"
 export * as Function from "./function"
 export { default as IntFromNumber } from "./IntFromNumber"
 export { default as IntFromPixels } from "./IntFromPixels"
 export { default as NonEmptyString } from "./NonEmptyString"
 export { default as NonEmptyStringOrNull } from "./NonEmptyStringOrNull"
-export * from "./NullOrT"
 export { default as NumberOrNull } from "./NumberOrNull"
+export { default as NumberRange } from "./NumberRange"
 export { default as StringFromBoolean } from "./StringFromBoolean"
 export { default as StringFromNumber } from "./StringFromNumber"
 export { default as StringOrNull } from "./StringOrNull"

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

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

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

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

package/lib/validators/NullOrT.d.ts

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

package/lib/validators/NullOrT.js

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

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

@@ -1,7 +0,0 @@
-export const nullableConverter = <I, O>(
-	value: I | null,
-	converter: (value: I) => O,
-): O | undefined => {
-	if (value === null) return undefined
-	else return converter(value)
-}

package/src/validators/NullOrT.ts

@@ -1,18 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export const NullOrT = <T, O = T>(codec: t.Type<T>) => {
-	return (asO: (value: T | null) => O) =>
-		new t.Type<O>(
-			`NullOr${codec.name}`,
-			(u: unknown): u is O => t.null.is(u) || codec.is(u),
-			(u: unknown) => {
-				return pipe(
-					t.union([t.null, codec]).decode(u),
-					either.map((decoded) => asO(decoded)),
-				)
-			},
-			(f) => f,
-		)
-}