@prismicio/types-internal 3.17.0 → 4.0.0-canary.3fe5f1e

package/src/utils/Objects.ts

@@ -1,53 +0,0 @@
-import { isRight } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-
-export function zipObjects<A, B = A>(
-	objLeft?: Partial<Record<string, A>> | undefined,
-	objRight?: Partial<Record<string, B>> | undefined,
-): Partial<Record<string, { left?: A | undefined; right?: B | undefined }>> {
-	const allKeys = [
-		...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {}))),
-	]
-
-	return allKeys.reduce<
-		Record<string, { left?: A | undefined; right?: B | undefined }>
-	>((acc, key) => {
-		const left = objLeft?.[key]
-		const right = objRight?.[key]
-		return {
-			...acc,
-			[key]: { left, right },
-		}
-	}, {})
-}
-
-export function isNotEmpty<A extends object>(obj: A): boolean {
-	return Boolean(Object.keys(obj).length)
-}
-
-export function withOptionals<T extends object>(
-	object: T,
-	optionals: Array<[keyof T, T[keyof T] | null | undefined]>,
-): T {
-	return {
-		...object,
-		...optionals.reduce((acc, [key, value]) => {
-			return value ? { ...acc, [key]: value } : acc
-		}, {}),
-	}
-}
-
-const recordCodec = t.record(t.string, t.unknown)
-export function isObject(value: unknown): value is Record<string, unknown> {
-	return isRight(recordCodec.decode(value))
-}
-
-export function mapValues<T, O>(
-	record: Record<string, T>,
-	fn: (value: T, key: string) => O,
-): Record<string, O> {
-	return Object.entries<T>(record).reduce<Record<string, O>>(
-		(acc, [key, value]) => ({ ...acc, [key]: fn(value, key) }),
-		{},
-	)
-}

package/src/utils/index.ts

@@ -1,4 +0,0 @@
-export * as HexaColorCode from "../common/HexaColorCode"
-export * as Arrays from "./Arrays"
-export * as Fields from "./Fields"
-export * as Objects from "./Objects"

package/src/validators/BasicTypes.ts

@@ -1,55 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { withCustomError } from "./function"
-
-export const String = withCustomError(
-	t.string,
-	() => "The value must be a string",
-)
-export const StringOrNull = withCustomError(
-	t.union([t.string, t.null]),
-	() => "The value must be a string or null",
-)
-export const Number = withCustomError(
-	t.number,
-	() => "The value must be a number",
-)
-export const NumberOrNull = withCustomError(
-	t.union([t.number, t.null]),
-	() => "The value must be a number or null",
-)
-export const Boolean = withCustomError(
-	t.boolean,
-	() => "The value must be a boolean",
-)
-
-export const EmptyObject = t.UnknownRecord.pipe(
-	new t.Type(
-		"emptyObject",
-		(u: unknown): u is Record<never, never> => t.UnknownRecord.is(u),
-		(u: Record<string, unknown>, c: t.Context) => {
-			if (Object.keys(u).length > 0)
-				return t.failure(u, c, "The object is not empty.")
-			return t.success({})
-		},
-		t.identity,
-	),
-)
-
-export const EmptyArray = new t.Type<never[], never[], unknown>(
-	"emptyArray",
-	(u: unknown): u is [] => t.UnknownArray.is(u) && u.length === 0,
-	(u: unknown, c: t.Context) => {
-		return pipe(
-			t.UnknownArray.decode(u),
-			either.chain((parsedArray) => {
-				if (parsedArray.length > 0)
-					return t.failure(u, c, "The array is not empty.")
-				return t.success(new Array<never>())
-			}),
-		)
-	},
-	() => [],
-)

package/src/validators/DateFromString.ts

@@ -1,19 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import { String } from "."
-
-export default new t.Type<Date, string, unknown>(
-	"dateFromString",
-	(u): u is Date => u instanceof Date,
-	(u, c) =>
-		pipe(
-			String.validate(u, c),
-			chain((s) => {
-				const d = new Date(s)
-				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
-			}),
-		),
-	(date) => date.toISOString(),
-)

package/src/validators/DateFromStringOrNumber.ts

@@ -1,17 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export default new t.Type<Date, Date, unknown>(
-	"dateFromStringOrNumber",
-	(u): u is Date => u instanceof Date,
-	(u, c) =>
-		pipe(
-			t.union([t.number, t.string]).validate(u, c),
-			chain((s) => {
-				const d = new Date(s)
-				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
-			}),
-		),
-	(date) => date,
-)

package/src/validators/DateFromTsMs.ts

@@ -1,17 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export default new t.Type<Date, number, unknown>(
-	"dateFromTsMs",
-	(u): u is Date => u instanceof Date,
-	(u, c) =>
-		pipe(
-			t.number.validate(u, c),
-			chain((s) => {
-				const d = new Date(s)
-				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
-			}),
-		),
-	(date) => date.getTime(),
-)

package/src/validators/DefaultOrElse.ts

@@ -1,24 +0,0 @@
-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>(
-			`DefaultOrElse<${inputValidator.name}, ${codec.name}>`,
-			(u: unknown): u is A | null => null === u || codec.is(u),
-			(u: unknown, c) => {
-				if (isRight(inputValidator.validate(u, c))) return t.success(null)
-				return codec.validate(u, c)
-			},
-			(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/IntFromNumber.ts

@@ -1,22 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export type IntFromNumberC = t.Type<t.Int, number, unknown>
-
-/** A codec that succeeds if a number can be parsed to an integer */
-export default new t.Type<t.Int, number, unknown>(
-	"IntFromNumber",
-	t.Int.is,
-	(u, c) =>
-		pipe(
-			t.number.validate(u, c),
-			chain((n) => {
-				if (t.Int.is(n)) return t.success(n)
-				else {
-					return t.success(Math.round(n) as t.Int)
-				}
-			}),
-		),
-	t.Int.encode,
-)

package/src/validators/IntFromPixels.ts

@@ -1,32 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export type IntFromPixelsC = t.Type<t.Int, string, unknown>
-
-const PixelsRegex = /^([0-9]+)px$/
-/**
- * A codec that succeeds if a string representing pixels (eg: "200px") can be
- * parsed to an integer
- */
-export default new t.Type<t.Int, string, unknown>(
-	"IntFromPixels",
-	t.Int.is,
-	(u, c) =>
-		pipe(
-			t.string.validate(u, c),
-			chain((strPixels) => {
-				try {
-					const matched = strPixels.match(PixelsRegex)
-					if (!matched) return t.failure(u, c)
-
-					/* eslint-disable  @typescript-eslint/no-non-null-assertion */
-					const parsed = parseInt(matched[1]!) as t.Int
-					return t.success(parsed)
-				} catch {
-					return t.failure(u, c)
-				}
-			}),
-		),
-	String,
-)

package/src/validators/NonEmptyString.ts

@@ -1,8 +0,0 @@
-import * as t from "io-ts"
-
-import { refineType, withCustomError } from "./function"
-
-export default withCustomError(
-	refineType(t.string, "nonEmptyString", (s) => s.trim().length > 0),
-	() => "The value must be a non-empty string",
-)

package/src/validators/NonEmptyStringOrNull.ts

@@ -1,22 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import { success, Type } from "io-ts"
-
-import StringOrNull from "./StringOrNull"
-
-export default new Type<string | null, string | null, unknown>(
-	"nonEmptyStringOrNull",
-	(u): u is string => typeof u === "string" || u === null,
-	(u, c) =>
-		pipe(
-			StringOrNull.validate(u, c),
-			chain((s) => {
-				if (typeof s === "string" && s.length > 0) {
-					return success(s)
-				} else {
-					return success(null)
-				}
-			}),
-		),
-	(s) => s,
-)

package/src/validators/NumberOrNull.ts

@@ -1,5 +0,0 @@
-import * as t from "io-ts"
-
-import { nullable } from "./function"
-
-export default nullable(t.number)

package/src/validators/NumberRange.ts

@@ -1,51 +0,0 @@
-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/StringFromBoolean.ts

@@ -1,19 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export type StringFromBooleanC = t.Type<string, string, unknown>
-
-/** A codec that validates a Boolean and convert it as a string */
-export default new t.Type<string, string, unknown>(
-	"StringFromInt",
-	t.string.is,
-	(u, c) =>
-		pipe(
-			t.boolean.validate(u, c),
-			chain((i) => {
-				return t.success(i.toString())
-			}),
-		),
-	(i) => i,
-)

package/src/validators/StringFromNumber.ts

@@ -1,19 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export type StringFromNumberC = t.Type<string, string, unknown>
-
-/** A codec that validates a number and convert it as a string */
-export default new t.Type<string, string, unknown>(
-	"StringFromInt",
-	t.string.is,
-	(u, c) =>
-		pipe(
-			t.number.validate(u, c),
-			chain((i) => {
-				return t.success(i.toString())
-			}),
-		),
-	(i) => i,
-)

package/src/validators/StringOrNull.ts

@@ -1,5 +0,0 @@
-import * as t from "io-ts"
-
-import { nullable } from "./function"
-
-export default nullable(t.string)

package/src/validators/TrimmedString.ts

@@ -1,33 +0,0 @@
-import { chain } from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-export type TrimmedStringC = t.Type<string, string, unknown>
-
-function trimScalaStyle(s: string): string {
-	let startAt = 0
-	/* eslint-disable  @typescript-eslint/no-non-null-assertion */
-	while (startAt < s.length && s[startAt]! <= " ") {
-		startAt++
-	}
-	let endAt = s.length
-	/* eslint-disable  @typescript-eslint/no-non-null-assertion */
-	while (startAt < endAt && s[endAt - 1]! <= " ") {
-		endAt--
-	}
-	return s.substring(startAt, endAt)
-}
-
-/** A codec that validates a Boolean and convert it as a string */
-export default new t.Type<string, string, unknown>(
-	"TrimmedString",
-	t.string.is,
-	(u, c) =>
-		pipe(
-			t.string.validate(u, c),
-			chain((s) => {
-				return t.success(trimScalaStyle(s))
-			}),
-		),
-	(i) => i,
-)

package/src/validators/function.ts

@@ -1,115 +0,0 @@
-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>) {
-	return t.union([c, t.null, t.undefined])
-}
-
-export function refineType<A, O, I>(
-	type: t.Type<A, O, I>,
-	newName: string,
-	pred: (a: A) => boolean,
-): t.Type<A, O, I> {
-	return new t.Type<A, O, I>(
-		newName,
-		type.is,
-		(u, c) =>
-			pipe(
-				type.validate(u, c),
-				either.chain((v) => (pred(v) ? t.success(v) : t.failure(u, c))),
-			),
-		type.encode,
-	)
-}
-
-export function filterDouble(value: string): number | null {
-	if (value === "") {
-		return null
-	}
-	const result = Number(value)
-	return Number.isNaN(result) ? null : result
-}
-
-export function formatDateTime(date: Date): string {
-	return date.toISOString().replace(/\.\d{3}Z$/, "+0000")
-}
-
-export function formatDate(date: Date): string {
-	return date.toISOString().replace(/T.*/, "")
-}
-
-export function grouped<A>(array: A[], n: number): A[][] {
-	return array.reduce((acc, curr, idx) => {
-		if (idx % n === 0) {
-			acc.push([curr])
-		} else {
-			/* eslint-disable  @typescript-eslint/no-non-null-assertion */
-			acc[Math.floor(idx / n)]!.push(curr)
-		}
-		return acc
-	}, new Array<A[]>())
-}
-
-export function objectToMap<T>(object: { [key: string]: T }): Map<string, T> {
-	return new Map(Object.entries(object))
-}
-
-export function isEmpty(obj: object) {
-	for (const _x in obj) {
-		return false
-	}
-	return true
-}
-
-export function addType<A, O extends object, I, T extends string>(
-	codec: t.Type<A, O, I>,
-	t: T,
-): 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(
- * 		withCustomError(
- * 			t.type({age: withCustomError(t.number, () => 'Invalid child')}),
- * 			() => "Invalid parent"
- * 		)
- * ).toSubsetEqualLeft([{message: "Invalid child"}])
- * expect(
- * 		withCustomError(
- * 			t.type({age: t.number}),
- * 			() => "Invalid parent"
- * 		)
- * ).toSubsetEqualLeft([{message: "Invalid parent"}])
- */
-export function withCustomError<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

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