| 1 | {"version":3,"file":"index.cjs","sources":["../src/error.ts","../src/utils.ts","../src/struct.ts","../src/structs/utilities.ts","../src/structs/types.ts","../src/structs/coercions.ts","../src/structs/refinements.ts"],"sourcesContent":["/**\n * A `StructFailure` represents a single specific failure in validation.\n */\n\nexport type Failure = {\n value: any\n key: any\n type: string\n refinement: string | undefined\n message: string\n branch: Array<any>\n path: Array<any>\n}\n\n/**\n * `StructError` objects are thrown (or returned) when validation fails.\n *\n * Validation logic is design to exit early for maximum performance. The error\n * represents the first error encountered during validation. For more detail,\n * the `error.failures` property is a generator function that can be run to\n * continue validation and receive all the failures in the data.\n */\n\nexport class StructError extends TypeError {\n value: any\n key!: any\n type!: string\n refinement!: string | undefined\n path!: Array<any>\n branch!: Array<any>\n failures: () => Array<Failure>;\n [x: string]: any\n\n constructor(failure: Failure, failures: () => Generator<Failure>) {\n let cached: Array<Failure> | undefined\n const { message, ...rest } = failure\n const { path } = failure\n const msg =\n path.length === 0 ? message : `At path: ${path.join('.')} -- ${message}`\n super(msg)\n Object.assign(this, rest)\n this.name = this.constructor.name\n this.failures = () => {\n return (cached ??= [failure, ...failures()])\n }\n }\n}\n","import { Struct, Infer, Result, Context, Describe } from './struct'\nimport { Failure } from './error'\n\n/**\n * Check if a value is an iterator.\n */\n\nfunction isIterable<T>(x: unknown): x is Iterable<T> {\n return isObject(x) && typeof x[Symbol.iterator] === 'function'\n}\n\n/**\n * Check if a value is a plain object.\n */\n\nexport function isObject(x: unknown): x is object {\n return typeof x === 'object' && x != null\n}\n\n/**\n * Check if a value is a plain object.\n */\n\nexport function isPlainObject(x: unknown): x is { [key: string]: any } {\n if (Object.prototype.toString.call(x) !== '[object Object]') {\n return false\n }\n\n const prototype = Object.getPrototypeOf(x)\n return prototype === null || prototype === Object.prototype\n}\n\n/**\n * Return a value as a printable string.\n */\n\nexport function print(value: any): string {\n return typeof value === 'string' ? JSON.stringify(value) : `${value}`\n}\n\n/**\n * Shifts (removes and returns) the first value from the `input` iterator.\n * Like `Array.prototype.shift()` but for an `Iterator`.\n */\n\nexport function shiftIterator<T>(input: Iterator<T>): T | undefined {\n const { done, value } = input.next()\n return done ? undefined : value\n}\n\n/**\n * Convert a single validation result to a failure.\n */\n\nexport function toFailure<T, S>(\n result: string | boolean | Partial<Failure>,\n context: Context,\n struct: Struct<T, S>,\n value: any\n): Failure | undefined {\n if (result === true) {\n return\n } else if (result === false) {\n result = {}\n } else if (typeof result === 'string') {\n result = { message: result }\n }\n\n const { path, branch } = context\n const { type } = struct\n const {\n refinement,\n message = `Expected a value of type \\`${type}\\`${\n refinement ? ` with refinement \\`${refinement}\\`` : ''\n }, but received: \\`${print(value)}\\``,\n } = result\n\n return {\n value,\n type,\n refinement,\n key: path[path.length - 1],\n path,\n branch,\n ...result,\n message,\n }\n}\n\n/**\n * Convert a validation result to an iterable of failures.\n */\n\nexport function* toFailures<T, S>(\n result: Result,\n context: Context,\n struct: Struct<T, S>,\n value: any\n): IterableIterator<Failure> {\n if (!isIterable(result)) {\n result = [result]\n }\n\n for (const r of result) {\n const failure = toFailure(r, context, struct, value)\n\n if (failure) {\n yield failure\n }\n }\n}\n\n/**\n * Check a value against a struct, traversing deeply into nested values, and\n * returning an iterator of failures or success.\n */\n\nexport function* run<T, S>(\n value: unknown,\n struct: Struct<T, S>,\n options: {\n path?: any[]\n branch?: any[]\n coerce?: boolean\n mask?: boolean\n } = {}\n): IterableIterator<[Failure, undefined] | [undefined, T]> {\n const { path = [], branch = [value], coerce = false, mask = false } = options\n const ctx: Context = { path, branch }\n\n if (coerce) {\n value = struct.coercer(value, ctx)\n\n if (\n mask &&\n struct.type !== 'type' &&\n isObject(struct.schema) &&\n isObject(value) &&\n !Array.isArray(value)\n ) {\n for (const key in value) {\n if (struct.schema[key] === undefined) {\n delete value[key]\n }\n }\n }\n }\n\n let valid = true\n\n for (const failure of struct.validator(value, ctx)) {\n valid = false\n yield [failure, undefined]\n }\n\n for (let [k, v, s] of struct.entries(value, ctx)) {\n const ts = run(v, s as Struct, {\n path: k === undefined ? path : [...path, k],\n branch: k === undefined ? branch : [...branch, v],\n coerce,\n mask,\n })\n\n for (const t of ts) {\n if (t[0]) {\n valid = false\n yield [t[0], undefined]\n } else if (coerce) {\n v = t[1]\n\n if (k === undefined) {\n value = v\n } else if (value instanceof Map) {\n value.set(k, v)\n } else if (value instanceof Set) {\n value.add(v)\n } else if (isObject(value)) {\n value[k] = v\n }\n }\n }\n }\n\n if (valid) {\n for (const failure of struct.refiner(value as T, ctx)) {\n valid = false\n yield [failure, undefined]\n }\n }\n\n if (valid) {\n yield [undefined, value as T]\n }\n}\n\n/**\n * Convert a union of type to an intersection.\n */\n\nexport type UnionToIntersection<U> = (\n U extends any ? (arg: U) => any : never\n) extends (arg: infer I) => void\n ? I\n : never\n\n/**\n * Assign properties from one type to another, overwriting existing.\n */\n\nexport type Assign<T, U> = Simplify<U & Omit<T, keyof U>>\n\n/**\n * A schema for enum structs.\n */\n\nexport type EnumSchema<T extends string | number | undefined> = {\n [K in NonNullable<T>]: K\n}\n\n/**\n * Check if a type is a match for another whilst treating overlapping\n * unions as a match.\n */\n\nexport type IsMatch<T, G> = T extends G ? (G extends T ? T : never) : never\n\n/**\n * Check if a type is an exact match.\n */\n\nexport type IsExactMatch<T, U> = (<G>() => G extends T ? 1 : 2) extends <\n G\n>() => G extends U ? 1 : 2\n ? T\n : never\n\n/**\n * Check if a type is a record type.\n */\n\nexport type IsRecord<T> = T extends object\n ? string extends keyof T\n ? T\n : never\n : never\n/**\n * Check if a type is a tuple.\n */\n\nexport type IsTuple<T> = T extends [any]\n ? T\n : T extends [any, any]\n ? T\n : T extends [any, any, any]\n ? T\n : T extends [any, any, any, any]\n ? T\n : T extends [any, any, any, any, any]\n ? T\n : never\n\n/**\n * Check if a type is a union.\n */\n\nexport type IsUnion<T, U extends T = T> = (\n T extends any ? (U extends T ? false : true) : false\n) extends false\n ? never\n : T\n\n/**\n * A schema for object structs.\n */\n\nexport type ObjectSchema = Record<string, Struct<any, any>>\n\n/**\n * Infer a type from an object struct schema.\n */\n\nexport type ObjectType<S extends ObjectSchema> = Simplify<\n Optionalize<{ [K in keyof S]: Infer<S[K]> }>\n>\n\n/**\n * Omit properties from a type that extend from a specific type.\n */\n\nexport type OmitBy<T, V> = Omit<\n T,\n { [K in keyof T]: V extends Extract<T[K], V> ? K : never }[keyof T]\n>\n\n/**\n * Normalize properties of a type that allow `undefined` to make them optional.\n */\n\nexport type Optionalize<S extends object> = OmitBy<S, undefined> &\n Partial<PickBy<S, undefined>>\n\n/**\n * Transform an object schema type to represent a partial.\n */\n\nexport type PartialObjectSchema<S extends ObjectSchema> = {\n [K in keyof S]: Struct<Infer<S[K]> | undefined>\n}\n\n/**\n * Pick properties from a type that extend from a specific type.\n */\n\nexport type PickBy<T, V> = Pick<\n T,\n { [K in keyof T]: V extends Extract<T[K], V> ? K : never }[keyof T]\n>\n\n/**\n * Simplifies a type definition to its most basic representation.\n */\n\nexport type Simplify<T> = T extends any[] | Date\n ? T\n : { [K in keyof T]: T[K] } & {}\n\nexport type If<B extends Boolean, Then, Else> = B extends true ? Then : Else\n\n/**\n * A schema for any type of struct.\n */\n\nexport type StructSchema<T> = [T] extends [string | undefined]\n ? [T] extends [IsMatch<T, string | undefined>]\n ? null\n : [T] extends [IsUnion<T>]\n ? EnumSchema<T>\n : T\n : [T] extends [number | undefined]\n ? [T] extends [IsMatch<T, number | undefined>]\n ? null\n : [T] extends [IsUnion<T>]\n ? EnumSchema<T>\n : T\n : [T] extends [boolean]\n ? [T] extends [IsExactMatch<T, boolean>]\n ? null\n : T\n : T extends\n | bigint\n | symbol\n | undefined\n | null\n | Function\n | Date\n | Error\n | RegExp\n | Map<any, any>\n | WeakMap<any, any>\n | Set<any>\n | WeakSet<any>\n | Promise<any>\n ? null\n : T extends Array<infer E>\n ? T extends IsTuple<T>\n ? null\n : Struct<E>\n : T extends object\n ? T extends IsRecord<T>\n ? null\n : { [K in keyof T]: Describe<T[K]> }\n : null\n\n/**\n * A schema for tuple structs.\n */\n\nexport type TupleSchema<T> = { [K in keyof T]: Struct<T[K]> }\n\n/**\n * Shorthand type for matching any `Struct`.\n */\n\nexport type AnyStruct = Struct<any, any>\n\n/**\n * Infer a tuple of types from a tuple of `Struct`s.\n *\n * This is used to recursively retrieve the type from `union` `intersection` and\n * `tuple` structs.\n */\n\nexport type InferStructTuple<\n Tuple extends AnyStruct[],\n Length extends number = Tuple['length']\n> = Length extends Length\n ? number extends Length\n ? Tuple\n : _InferTuple<Tuple, Length, []>\n : never\ntype _InferTuple<\n Tuple extends AnyStruct[],\n Length extends number,\n Accumulated extends unknown[],\n Index extends number = Accumulated['length']\n> = Index extends Length\n ? Accumulated\n : _InferTuple<Tuple, Length, [...Accumulated, Infer<Tuple[Index]>]>\n","import { toFailures, shiftIterator, StructSchema, run } from './utils'\nimport { StructError, Failure } from './error'\n\n/**\n * `Struct` objects encapsulate the validation logic for a specific type of\n * values. Once constructed, you use the `assert`, `is` or `validate` helpers to\n * validate unknown input data against the struct.\n */\n\nexport class Struct<T = unknown, S = unknown> {\n readonly TYPE!: T\n type: string\n schema: S\n coercer: (value: unknown, context: Context) => unknown\n validator: (value: unknown, context: Context) => Iterable<Failure>\n refiner: (value: T, context: Context) => Iterable<Failure>\n entries: (\n value: unknown,\n context: Context\n ) => Iterable<[string | number, unknown, Struct<any> | Struct<never>]>\n\n constructor(props: {\n type: string\n schema: S\n coercer?: Coercer\n validator?: Validator\n refiner?: Refiner<T>\n entries?: Struct<T, S>['entries']\n }) {\n const {\n type,\n schema,\n validator,\n refiner,\n coercer = (value: unknown) => value,\n entries = function* () {},\n } = props\n\n this.type = type\n this.schema = schema\n this.entries = entries\n this.coercer = coercer\n\n if (validator) {\n this.validator = (value, context) => {\n const result = validator(value, context)\n return toFailures(result, context, this, value)\n }\n } else {\n this.validator = () => []\n }\n\n if (refiner) {\n this.refiner = (value, context) => {\n const result = refiner(value, context)\n return toFailures(result, context, this, value)\n }\n } else {\n this.refiner = () => []\n }\n }\n\n /**\n * Assert that a value passes the struct's validation, throwing if it doesn't.\n */\n\n assert(value: unknown): asserts value is T {\n return assert(value, this)\n }\n\n /**\n * Create a value with the struct's coercion logic, then validate it.\n */\n\n create(value: unknown): T {\n return create(value, this)\n }\n\n /**\n * Check if a value passes the struct's validation.\n */\n\n is(value: unknown): value is T {\n return is(value, this)\n }\n\n /**\n * Mask a value, coercing and validating it, but returning only the subset of\n * properties defined by the struct's schema.\n */\n\n mask(value: unknown): T {\n return mask(value, this)\n }\n\n /**\n * Validate a value with the struct's validation logic, returning a tuple\n * representing the result.\n *\n * You may optionally pass `true` for the `withCoercion` argument to coerce\n * the value before attempting to validate it. If you do, the result will\n * contain the coerced result when successful.\n */\n\n validate(\n value: unknown,\n options: {\n coerce?: boolean\n } = {}\n ): [StructError, undefined] | [undefined, T] {\n return validate(value, this, options)\n }\n}\n\n/**\n * Assert that a value passes a struct, throwing if it doesn't.\n */\n\nexport function assert<T, S>(\n value: unknown,\n struct: Struct<T, S>\n): asserts value is T {\n const result = validate(value, struct)\n\n if (result[0]) {\n throw result[0]\n }\n}\n\n/**\n * Create a value with the coercion logic of struct and validate it.\n */\n\nexport function create<T, S>(value: unknown, struct: Struct<T, S>): T {\n const result = validate(value, struct, { coerce: true })\n\n if (result[0]) {\n throw result[0]\n } else {\n return result[1]\n }\n}\n\n/**\n * Mask a value, returning only the subset of properties defined by a struct.\n */\n\nexport function mask<T, S>(value: unknown, struct: Struct<T, S>): T {\n const result = validate(value, struct, { coerce: true, mask: true })\n\n if (result[0]) {\n throw result[0]\n } else {\n return result[1]\n }\n}\n\n/**\n * Check if a value passes a struct.\n */\n\nexport function is<T, S>(value: unknown, struct: Struct<T, S>): value is T {\n const result = validate(value, struct)\n return !result[0]\n}\n\n/**\n * Validate a value against a struct, returning an error if invalid, or the\n * value (with potential coercion) if valid.\n */\n\nexport function validate<T, S>(\n value: unknown,\n struct: Struct<T, S>,\n options: {\n coerce?: boolean\n mask?: boolean\n } = {}\n): [StructError, undefined] | [undefined, T] {\n const tuples = run(value, struct, options)\n const tuple = shiftIterator(tuples)!\n\n if (tuple[0]) {\n const error = new StructError(tuple[0], function* () {\n for (const t of tuples) {\n if (t[0]) {\n yield t[0]\n }\n }\n })\n\n return [error, undefined]\n } else {\n const v = tuple[1]\n return [undefined, v]\n }\n}\n\n/**\n * A `Context` contains information about the current location of the\n * validation inside the initial input value.\n */\n\nexport type Context = {\n branch: Array<any>\n path: Array<any>\n}\n\n/**\n * A type utility to extract the type from a `Struct` class.\n */\n\nexport type Infer<T extends Struct<any, any>> = T['TYPE']\n\n/**\n * A type utility to describe that a struct represents a TypeScript type.\n */\n\nexport type Describe<T> = Struct<T, StructSchema<T>>\n\n/**\n * A `Result` is returned from validation functions.\n */\n\nexport type Result =\n | boolean\n | string\n | Partial<Failure>\n | Iterable<boolean | string | Partial<Failure>>\n\n/**\n * A `Coercer` takes an unknown value and optionally coerces it.\n */\n\nexport type Coercer<T = unknown> = (value: T, context: Context) => unknown\n\n/**\n * A `Validator` takes an unknown value and validates it.\n */\n\nexport type Validator = (value: unknown, context: Context) => Result\n\n/**\n * A `Refiner` takes a value of a known type and validates it against a further\n * constraint.\n */\n\nexport type Refiner<T> = (value: T, context: Context) => Result\n","import { Struct, Context, Validator } from '../struct'\nimport { object, optional, type } from './types'\nimport { ObjectSchema, Assign, ObjectType, PartialObjectSchema } from '../utils'\n\n/**\n * Create a new struct that combines the properties properties from multiple\n * object or type structs. Its return type will match the first parameter's type.\n *\n * Like JavaScript's `Object.assign` utility.\n */\n\nexport function assign<A extends ObjectSchema, B extends ObjectSchema>(\n A: Struct<ObjectType<A>, A>,\n B: Struct<ObjectType<B>, B>\n): Struct<ObjectType<Assign<A, B>>, Assign<A, B>>\nexport function assign<\n A extends ObjectSchema,\n B extends ObjectSchema,\n C extends ObjectSchema\n>(\n A: Struct<ObjectType<A>, A>,\n B: Struct<ObjectType<B>, B>,\n C: Struct<ObjectType<C>, C>\n): Struct<ObjectType<Assign<Assign<A, B>, C>>, Assign<Assign<A, B>, C>>\nexport function assign<\n A extends ObjectSchema,\n B extends ObjectSchema,\n C extends ObjectSchema,\n D extends ObjectSchema\n>(\n A: Struct<ObjectType<A>, A>,\n B: Struct<ObjectType<B>, B>,\n C: Struct<ObjectType<C>, C>,\n D: Struct<ObjectType<D>, D>\n): Struct<\n ObjectType<Assign<Assign<Assign<A, B>, C>, D>>,\n Assign<Assign<Assign<A, B>, C>, D>\n>\nexport function assign<\n A extends ObjectSchema,\n B extends ObjectSchema,\n C extends ObjectSchema,\n D extends ObjectSchema,\n E extends ObjectSchema\n>(\n A: Struct<ObjectType<A>, A>,\n B: Struct<ObjectType<B>, B>,\n C: Struct<ObjectType<C>, C>,\n D: Struct<ObjectType<D>, D>,\n E: Struct<ObjectType<E>, E>\n): Struct<\n ObjectType<Assign<Assign<Assign<Assign<A, B>, C>, D>, E>>,\n Assign<Assign<Assign<Assign<A, B>, C>, D>, E>\n>\nexport function assign(...Structs: Struct<any>[]): any {\n const isType = Structs[0].type === 'type'\n const schemas = Structs.map((s) => s.schema)\n const schema = Object.assign({}, ...schemas)\n return isType ? type(schema) : object(schema)\n}\n\n/**\n * Define a new struct type with a custom validation function.\n */\n\nexport function define<T>(name: string, validator: Validator): Struct<T, null> {\n return new Struct({ type: name, schema: null, validator })\n}\n\n/**\n * Create a new struct based on an existing struct, but the value is allowed to\n * be `undefined`. `log` will be called if the value is not `undefined`.\n */\n\nexport function deprecated<T>(\n struct: Struct<T>,\n log: (value: unknown, ctx: Context) => void\n): Struct<T> {\n return new Struct({\n ...struct,\n refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx),\n validator(value, ctx) {\n if (value === undefined) {\n return true\n } else {\n log(value, ctx)\n return struct.validator(value, ctx)\n }\n },\n })\n}\n\n/**\n * Create a struct with dynamic validation logic.\n *\n * The callback will receive the value currently being validated, and must\n * return a struct object to validate it with. This can be useful to model\n * validation logic that changes based on its input.\n */\n\nexport function dynamic<T>(\n fn: (value: unknown, ctx: Context) => Struct<T, any>\n): Struct<T, null> {\n return new Struct({\n type: 'dynamic',\n schema: null,\n *entries(value, ctx) {\n const struct = fn(value, ctx)\n yield* struct.entries(value, ctx)\n },\n validator(value, ctx) {\n const struct = fn(value, ctx)\n return struct.validator(value, ctx)\n },\n coercer(value, ctx) {\n const struct = fn(value, ctx)\n return struct.coercer(value, ctx)\n },\n })\n}\n\n/**\n * Create a struct with lazily evaluated validation logic.\n *\n * The first time validation is run with the struct, the callback will be called\n * and must return a struct object to use. This is useful for cases where you\n * want to have self-referential structs for nested data structures to avoid a\n * circular definition problem.\n */\n\nexport function lazy<T>(fn: () => Struct<T, any>): Struct<T, null> {\n let struct: Struct<T, any> | undefined\n return new Struct({\n type: 'lazy',\n schema: null,\n *entries(value, ctx) {\n struct ??= fn()\n yield* struct.entries(value, ctx)\n },\n validator(value, ctx) {\n struct ??= fn()\n return struct.validator(value, ctx)\n },\n coercer(value, ctx) {\n struct ??= fn()\n return struct.coercer(value, ctx)\n },\n })\n}\n\n/**\n * Create a new struct based on an existing object struct, but excluding\n * specific properties.\n *\n * Like TypeScript's `Omit` utility.\n */\n\nexport function omit<S extends ObjectSchema, K extends keyof S>(\n struct: Struct<ObjectType<S>, S>,\n keys: K[]\n): Struct<ObjectType<Omit<S, K>>, Omit<S, K>> {\n const { schema } = struct\n const subschema: any = { ...schema }\n\n for (const key of keys) {\n delete subschema[key]\n }\n\n return object(subschema as Omit<S, K>)\n}\n\n/**\n * Create a new struct based on an existing object struct, but with all of its\n * properties allowed to be `undefined`.\n *\n * Like TypeScript's `Partial` utility.\n */\n\nexport function partial<S extends ObjectSchema>(\n struct: Struct<ObjectType<S>, S> | S\n): Struct<ObjectType<PartialObjectSchema<S>>, PartialObjectSchema<S>> {\n const schema: any =\n struct instanceof Struct ? { ...struct.schema } : { ...struct }\n\n for (const key in schema) {\n schema[key] = optional(schema[key])\n }\n\n return object(schema) as any\n}\n\n/**\n * Create a new struct based on an existing object struct, but only including\n * specific properties.\n *\n * Like TypeScript's `Pick` utility.\n */\n\nexport function pick<S extends ObjectSchema, K extends keyof S>(\n struct: Struct<ObjectType<S>, S>,\n keys: K[]\n): Struct<ObjectType<Pick<S, K>>, Pick<S, K>> {\n const { schema } = struct\n const subschema: any = {}\n\n for (const key of keys) {\n subschema[key] = schema[key]\n }\n\n return object(subschema as Pick<S, K>)\n}\n\n/**\n * Define a new struct type with a custom validation function.\n *\n * @deprecated This function has been renamed to `define`.\n */\n\nexport function struct<T>(name: string, validator: Validator): Struct<T, null> {\n console.warn(\n 'superstruct@0.11 - The `struct` helper has been renamed to `define`.'\n )\n\n return define(name, validator)\n}\n","import { Infer, Struct } from '../struct'\nimport { define } from './utilities'\nimport {\n ObjectSchema,\n ObjectType,\n print,\n run,\n isObject,\n AnyStruct,\n InferStructTuple,\n UnionToIntersection,\n} from '../utils'\n\n/**\n * Ensure that any value passes validation.\n */\n\nexport function any(): Struct<any, null> {\n return define('any', () => true)\n}\n\n/**\n * Ensure that a value is an array and that its elements are of a specific type.\n *\n * Note: If you omit the element struct, the arrays elements will not be\n * iterated at all. This can be helpful for cases where performance is critical,\n * and it is preferred to using `array(any())`.\n */\n\nexport function array<T extends Struct<any>>(Element: T): Struct<Infer<T>[], T>\nexport function array(): Struct<unknown[], undefined>\nexport function array<T extends Struct<any>>(Element?: T): any {\n return new Struct({\n type: 'array',\n schema: Element,\n *entries(value) {\n if (Element && Array.isArray(value)) {\n for (const [i, v] of value.entries()) {\n yield [i, v, Element]\n }\n }\n },\n coercer(value) {\n return Array.isArray(value) ? value.slice() : value\n },\n validator(value) {\n return (\n Array.isArray(value) ||\n `Expected an array value, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that a value is a bigint.\n */\n\nexport function bigint(): Struct<bigint, null> {\n return define('bigint', (value) => {\n return typeof value === 'bigint'\n })\n}\n\n/**\n * Ensure that a value is a boolean.\n */\n\nexport function boolean(): Struct<boolean, null> {\n return define('boolean', (value) => {\n return typeof value === 'boolean'\n })\n}\n\n/**\n * Ensure that a value is a valid `Date`.\n *\n * Note: this also ensures that the value is *not* an invalid `Date` object,\n * which can occur when parsing a date fails but still returns a `Date`.\n */\n\nexport function date(): Struct<Date, null> {\n return define('date', (value) => {\n return (\n (value instanceof Date && !isNaN(value.getTime())) ||\n `Expected a valid \\`Date\\` object, but received: ${print(value)}`\n )\n })\n}\n\n/**\n * Ensure that a value is one of a set of potential values.\n *\n * Note: after creating the struct, you can access the definition of the\n * potential values as `struct.schema`.\n */\n\nexport function enums<T extends number>(\n values: readonly T[]\n): Struct<T, { [K in T[][number]]: K }>\nexport function enums<T extends string>(\n values: readonly T[]\n): Struct<T, { [K in T[][number]]: K }>\nexport function enums<T extends number | string>(values: readonly T[]): any {\n const schema: any = {}\n const description = values.map((v) => print(v)).join()\n\n for (const key of values) {\n schema[key] = key\n }\n\n return new Struct({\n type: 'enums',\n schema,\n validator(value) {\n return (\n values.includes(value as any) ||\n `Expected one of \\`${description}\\`, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that a value is a function.\n */\n\nexport function func(): Struct<Function, null> {\n return define('func', (value) => {\n return (\n typeof value === 'function' ||\n `Expected a function, but received: ${print(value)}`\n )\n })\n}\n\n/**\n * Ensure that a value is an instance of a specific class.\n */\n\nexport function instance<T extends { new (...args: any): any }>(\n Class: T\n): Struct<InstanceType<T>, null> {\n return define('instance', (value) => {\n return (\n value instanceof Class ||\n `Expected a \\`${Class.name}\\` instance, but received: ${print(value)}`\n )\n })\n}\n\n/**\n * Ensure that a value is an integer.\n */\n\nexport function integer(): Struct<number, null> {\n return define('integer', (value) => {\n return (\n (typeof value === 'number' && !isNaN(value) && Number.isInteger(value)) ||\n `Expected an integer, but received: ${print(value)}`\n )\n })\n}\n\n/**\n * Ensure that a value matches all of a set of types.\n */\n\nexport function intersection<A extends AnyStruct, B extends AnyStruct[]>(\n Structs: [A, ...B]\n): Struct<Infer<A> & UnionToIntersection<InferStructTuple<B>[number]>, null> {\n return new Struct({\n type: 'intersection',\n schema: null,\n *entries(value, ctx) {\n for (const S of Structs) {\n yield* S.entries(value, ctx)\n }\n },\n *validator(value, ctx) {\n for (const S of Structs) {\n yield* S.validator(value, ctx)\n }\n },\n *refiner(value, ctx) {\n for (const S of Structs) {\n yield* S.refiner(value, ctx)\n }\n },\n })\n}\n\n/**\n * Ensure that a value is an exact value, using `===` for comparison.\n */\n\nexport function literal<T extends boolean>(constant: T): Struct<T, T>\nexport function literal<T extends number>(constant: T): Struct<T, T>\nexport function literal<T extends string>(constant: T): Struct<T, T>\nexport function literal<T>(constant: T): Struct<T, null>\nexport function literal<T>(constant: T): any {\n const description = print(constant)\n const t = typeof constant\n return new Struct({\n type: 'literal',\n schema:\n t === 'string' || t === 'number' || t === 'boolean' ? constant : null,\n validator(value) {\n return (\n value === constant ||\n `Expected the literal \\`${description}\\`, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that a value is a `Map` object, and that its keys and values are of\n * specific types.\n */\n\nexport function map(): Struct<Map<unknown, unknown>, null>\nexport function map<K, V>(\n Key: Struct<K>,\n Value: Struct<V>\n): Struct<Map<K, V>, null>\nexport function map<K, V>(Key?: Struct<K>, Value?: Struct<V>): any {\n return new Struct({\n type: 'map',\n schema: null,\n *entries(value) {\n if (Key && Value && value instanceof Map) {\n for (const [k, v] of value.entries()) {\n yield [k as string, k, Key]\n yield [k as string, v, Value]\n }\n }\n },\n coercer(value) {\n return value instanceof Map ? new Map(value) : value\n },\n validator(value) {\n return (\n value instanceof Map ||\n `Expected a \\`Map\\` object, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that no value ever passes validation.\n */\n\nexport function never(): Struct<never, null> {\n return define('never', () => false)\n}\n\n/**\n * Augment an existing struct to allow `null` values.\n */\n\nexport function nullable<T, S>(struct: Struct<T, S>): Struct<T | null, S> {\n return new Struct({\n ...struct,\n validator: (value, ctx) => value === null || struct.validator(value, ctx),\n refiner: (value, ctx) => value === null || struct.refiner(value, ctx),\n })\n}\n\n/**\n * Ensure that a value is a number.\n */\n\nexport function number(): Struct<number, null> {\n return define('number', (value) => {\n return (\n (typeof value === 'number' && !isNaN(value)) ||\n `Expected a number, but received: ${print(value)}`\n )\n })\n}\n\n/**\n * Ensure that a value is an object, that is has a known set of properties,\n * and that its properties are of specific types.\n *\n * Note: Unrecognized properties will fail validation.\n */\n\nexport function object(): Struct<Record<string, unknown>, null>\nexport function object<S extends ObjectSchema>(\n schema: S\n): Struct<ObjectType<S>, S>\nexport function object<S extends ObjectSchema>(schema?: S): any {\n const knowns = schema ? Object.keys(schema) : []\n const Never = never()\n return new Struct({\n type: 'object',\n schema: schema ? schema : null,\n *entries(value) {\n if (schema && isObject(value)) {\n const unknowns = new Set(Object.keys(value))\n\n for (const key of knowns) {\n unknowns.delete(key)\n yield [key, value[key], schema[key]]\n }\n\n for (const key of unknowns) {\n yield [key, value[key], Never]\n }\n }\n },\n validator(value) {\n return (\n isObject(value) || `Expected an object, but received: ${print(value)}`\n )\n },\n coercer(value) {\n return isObject(value) ? { ...value } : value\n },\n })\n}\n\n/**\n * Augment a struct to allow `undefined` values.\n */\n\nexport function optional<T, S>(struct: Struct<T, S>): Struct<T | undefined, S> {\n return new Struct({\n ...struct,\n validator: (value, ctx) =>\n value === undefined || struct.validator(value, ctx),\n refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx),\n })\n}\n\n/**\n * Ensure that a value is an object with keys and values of specific types, but\n * without ensuring any specific shape of properties.\n *\n * Like TypeScript's `Record` utility.\n */\n\nexport function record<K extends string, V>(\n Key: Struct<K>,\n Value: Struct<V>\n): Struct<Record<K, V>, null> {\n return new Struct({\n type: 'record',\n schema: null,\n *entries(value) {\n if (isObject(value)) {\n for (const k in value) {\n const v = value[k]\n yield [k, k, Key]\n yield [k, v, Value]\n }\n }\n },\n validator(value) {\n return (\n isObject(value) || `Expected an object, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that a value is a `RegExp`.\n *\n * Note: this does not test the value against the regular expression! For that\n * you need to use the `pattern()` refinement.\n */\n\nexport function regexp(): Struct<RegExp, null> {\n return define('regexp', (value) => {\n return value instanceof RegExp\n })\n}\n\n/**\n * Ensure that a value is a `Set` object, and that its elements are of a\n * specific type.\n */\n\nexport function set(): Struct<Set<unknown>, null>\nexport function set<T>(Element: Struct<T>): Struct<Set<T>, null>\nexport function set<T>(Element?: Struct<T>): any {\n return new Struct({\n type: 'set',\n schema: null,\n *entries(value) {\n if (Element && value instanceof Set) {\n for (const v of value) {\n yield [v as string, v, Element]\n }\n }\n },\n coercer(value) {\n return value instanceof Set ? new Set(value) : value\n },\n validator(value) {\n return (\n value instanceof Set ||\n `Expected a \\`Set\\` object, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that a value is a string.\n */\n\nexport function string(): Struct<string, null> {\n return define('string', (value) => {\n return (\n typeof value === 'string' ||\n `Expected a string, but received: ${print(value)}`\n )\n })\n}\n\n/**\n * Ensure that a value is a tuple of a specific length, and that each of its\n * elements is of a specific type.\n */\n\nexport function tuple<A extends AnyStruct, B extends AnyStruct[]>(\n Structs: [A, ...B]\n): Struct<[Infer<A>, ...InferStructTuple<B>], null> {\n const Never = never()\n\n return new Struct({\n type: 'tuple',\n schema: null,\n *entries(value) {\n if (Array.isArray(value)) {\n const length = Math.max(Structs.length, value.length)\n\n for (let i = 0; i < length; i++) {\n yield [i, value[i], Structs[i] || Never]\n }\n }\n },\n validator(value) {\n return (\n Array.isArray(value) ||\n `Expected an array, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that a value has a set of known properties of specific types.\n *\n * Note: Unrecognized properties are allowed and untouched. This is similar to\n * how TypeScript's structural typing works.\n */\n\nexport function type<S extends ObjectSchema>(\n schema: S\n): Struct<ObjectType<S>, S> {\n const keys = Object.keys(schema)\n return new Struct({\n type: 'type',\n schema,\n *entries(value) {\n if (isObject(value)) {\n for (const k of keys) {\n yield [k, value[k], schema[k]]\n }\n }\n },\n validator(value) {\n return (\n isObject(value) || `Expected an object, but received: ${print(value)}`\n )\n },\n })\n}\n\n/**\n * Ensure that a value matches one of a set of types.\n */\n\nexport function union<A extends AnyStruct, B extends AnyStruct[]>(\n Structs: [A, ...B]\n): Struct<Infer<A> | InferStructTuple<B>[number], null> {\n const description = Structs.map((s) => s.type).join(' | ')\n return new Struct({\n type: 'union',\n schema: null,\n coercer(value, ctx) {\n const firstMatch =\n Structs.find((s) => {\n const [e] = s.validate(value, { coerce: true })\n return !e\n }) || unknown()\n return firstMatch.coercer(value, ctx)\n },\n validator(value, ctx) {\n const failures = []\n\n for (const S of Structs) {\n const [...tuples] = run(value, S, ctx)\n const [first] = tuples\n\n if (!first[0]) {\n return []\n } else {\n for (const [failure] of tuples) {\n if (failure) {\n failures.push(failure)\n }\n }\n }\n }\n\n return [\n `Expected the value to satisfy a union of \\`${description}\\`, but received: ${print(\n value\n )}`,\n ...failures,\n ]\n },\n })\n}\n\n/**\n * Ensure that any value passes validation, without widening its type to `any`.\n */\n\nexport function unknown(): Struct<unknown, null> {\n return define('unknown', () => true)\n}\n","import { Struct, is, Coercer } from '../struct'\nimport { isPlainObject } from '../utils'\nimport { string, unknown } from './types'\n\n/**\n * Augment a `Struct` to add an additional coercion step to its input.\n *\n * This allows you to transform input data before validating it, to increase the\n * likelihood that it passes validation—for example for default values, parsing\n * different formats, etc.\n *\n * Note: You must use `create(value, Struct)` on the value to have the coercion\n * take effect! Using simply `assert()` or `is()` will not use coercion.\n */\n\nexport function coerce<T, S, C>(\n struct: Struct<T, S>,\n condition: Struct<C, any>,\n coercer: Coercer<C>\n): Struct<T, S> {\n return new Struct({\n ...struct,\n coercer: (value, ctx) => {\n return is(value, condition)\n ? struct.coercer(coercer(value, ctx), ctx)\n : struct.coercer(value, ctx)\n },\n })\n}\n\n/**\n * Augment a struct to replace `undefined` values with a default.\n *\n * Note: You must use `create(value, Struct)` on the value to have the coercion\n * take effect! Using simply `assert()` or `is()` will not use coercion.\n */\n\nexport function defaulted<T, S>(\n struct: Struct<T, S>,\n fallback: any,\n options: {\n strict?: boolean\n } = {}\n): Struct<T, S> {\n return coerce(struct, unknown(), (x) => {\n const f = typeof fallback === 'function' ? fallback() : fallback\n\n if (x === undefined) {\n return f\n }\n\n if (!options.strict && isPlainObject(x) && isPlainObject(f)) {\n const ret = { ...x }\n let changed = false\n\n for (const key in f) {\n if (ret[key] === undefined) {\n ret[key] = f[key]\n changed = true\n }\n }\n\n if (changed) {\n return ret\n }\n }\n\n return x\n })\n}\n\n/**\n * Augment a struct to trim string inputs.\n *\n * Note: You must use `create(value, Struct)` on the value to have the coercion\n * take effect! Using simply `assert()` or `is()` will not use coercion.\n */\n\nexport function trimmed<T, S>(struct: Struct<T, S>): Struct<T, S> {\n return coerce(struct, string(), (x) => x.trim())\n}\n","import { Struct, Refiner } from '../struct'\nimport { toFailures } from '../utils'\n\n/**\n * Ensure that a string, array, map, or set is empty.\n */\n\nexport function empty<\n T extends string | any[] | Map<any, any> | Set<any>,\n S extends any\n>(struct: Struct<T, S>): Struct<T, S> {\n return refine(struct, 'empty', (value) => {\n const size = getSize(value)\n return (\n size === 0 ||\n `Expected an empty ${struct.type} but received one with a size of \\`${size}\\``\n )\n })\n}\n\nfunction getSize(value: string | any[] | Map<any, any> | Set<any>): number {\n if (value instanceof Map || value instanceof Set) {\n return value.size\n } else {\n return value.length\n }\n}\n\n/**\n * Ensure that a number or date is below a threshold.\n */\n\nexport function max<T extends number | Date, S extends any>(\n struct: Struct<T, S>,\n threshold: T,\n options: {\n exclusive?: boolean\n } = {}\n): Struct<T, S> {\n const { exclusive } = options\n return refine(struct, 'max', (value) => {\n return exclusive\n ? value < threshold\n : value <= threshold ||\n `Expected a ${struct.type} less than ${\n exclusive ? '' : 'or equal to '\n }${threshold} but received \\`${value}\\``\n })\n}\n\n/**\n * Ensure that a number or date is above a threshold.\n */\n\nexport function min<T extends number | Date, S extends any>(\n struct: Struct<T, S>,\n threshold: T,\n options: {\n exclusive?: boolean\n } = {}\n): Struct<T, S> {\n const { exclusive } = options\n return refine(struct, 'min', (value) => {\n return exclusive\n ? value > threshold\n : value >= threshold ||\n `Expected a ${struct.type} greater than ${\n exclusive ? '' : 'or equal to '\n }${threshold} but received \\`${value}\\``\n })\n}\n\n/**\n * Ensure that a string, array, map or set is not empty.\n */\n\nexport function nonempty<\n T extends string | any[] | Map<any, any> | Set<any>,\n S extends any\n>(struct: Struct<T, S>): Struct<T, S> {\n return refine(struct, 'nonempty', (value) => {\n const size = getSize(value)\n return (\n size > 0 || `Expected a nonempty ${struct.type} but received an empty one`\n )\n })\n}\n\n/**\n * Ensure that a string matches a regular expression.\n */\n\nexport function pattern<T extends string, S extends any>(\n struct: Struct<T, S>,\n regexp: RegExp\n): Struct<T, S> {\n return refine(struct, 'pattern', (value) => {\n return (\n regexp.test(value) ||\n `Expected a ${struct.type} matching \\`/${regexp.source}/\\` but received \"${value}\"`\n )\n })\n}\n\n/**\n * Ensure that a string, array, number, date, map, or set has a size (or length, or time) between `min` and `max`.\n */\n\nexport function size<\n T extends string | number | Date | any[] | Map<any, any> | Set<any>,\n S extends any\n>(struct: Struct<T, S>, min: number, max: number = min): Struct<T, S> {\n const expected = `Expected a ${struct.type}`\n const of = min === max ? `of \\`${min}\\`` : `between \\`${min}\\` and \\`${max}\\``\n\n return refine(struct, 'size', (value) => {\n if (typeof value === 'number' || value instanceof Date) {\n return (\n (min <= value && value <= max) ||\n `${expected} ${of} but received \\`${value}\\``\n )\n } else if (value instanceof Map || value instanceof Set) {\n const { size } = value\n return (\n (min <= size && size <= max) ||\n `${expected} with a size ${of} but received one with a size of \\`${size}\\``\n )\n } else {\n const { length } = value as string | any[]\n return (\n (min <= length && length <= max) ||\n `${expected} with a length ${of} but received one with a length of \\`${length}\\``\n )\n }\n })\n}\n\n/**\n * Augment a `Struct` to add an additional refinement to the validation.\n *\n * The refiner function is guaranteed to receive a value of the struct's type,\n * because the struct's existing validation will already have passed. This\n * allows you to layer additional validation on top of existing structs.\n */\n\nexport function refine<T, S>(\n struct: Struct<T, S>,\n name: string,\n refiner: Refiner<T>\n): Struct<T, S> {\n return new Struct({\n ...struct,\n *refiner(value, ctx) {\n yield* struct.refiner(value, ctx)\n const result = refiner(value, ctx)\n const failures = toFailures(result, ctx, struct, value)\n\n for (const failure of failures) {\n yield { ...failure, refinement: name }\n }\n },\n })\n}\n"],"names":["StructError","TypeError","constructor","failure","failures","cached","message","rest","path","msg","length","join","value","key","type","refinement","branch","Object","assign","name","isIterable","x","isObject","Symbol","iterator","isPlainObject","prototype","toString","call","getPrototypeOf","print","JSON","stringify","shiftIterator","input","done","next","undefined","toFailure","result","context","struct","toFailures","r","run","options","coerce","mask","ctx","coercer","schema","Array","isArray","valid","validator","k","v","s","entries","ts","t","Map","set","Set","add","refiner","Struct","props","TYPE","assert","create","is","validate","tuples","tuple","error","Structs","isType","schemas","map","object","define","deprecated","log","dynamic","fn","lazy","omit","keys","subschema","partial","optional","pick","console","warn","any","array","Element","i","slice","bigint","boolean","date","Date","isNaN","getTime","enums","values","description","includes","func","instance","Class","integer","Number","isInteger","intersection","S","literal","constant","Key","Value","never","nullable","number","knowns","Never","unknowns","delete","record","regexp","RegExp","string","Math","max","union","firstMatch","find","e","unknown","first","push","condition","defaulted","fallback","f","strict","ret","changed","trimmed","trim","empty","refine","size","getSize","threshold","exclusive","min","nonempty","pattern","test","source","expected","of"],"mappings":"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"} |