{"version":3,"file":"h.cjs","names":["StringSchemaType","NumberSchemaType","BooleanSchemaType","BigIntSchemaType","NullSchemaType","UndefinedSchemaType","VoidSchemaType","AnySchemaType","UnknownSchemaType","NeverSchemaType","LiteralSchema","ObjectSchemaType","RecordSchema","toStandard","TupleSchema","MapSchema","SetSchema","IntersectionSchema","DiscriminatedUnionSchema","LazySchema","DefaultSchema","TransformSchema","RefineSchema","PipeSchema","UnionSchema"],"sources":["../src/h.ts"],"sourcesContent":["import {\n  type ArraySchema,\n  type InstanceOfSchema,\n  LiteralSchema,\n  NullSchemaType,\n  type OptionalSchema,\n  UnionSchema,\n} from \"./core/base\";\nimport type {\n  AnySchema,\n  InferObject,\n  InferSchema,\n  Schema,\n  SchemaDefinition,\n  SchemaType,\n} from \"./core/types\";\nimport { AnySchemaType, NeverSchemaType, UnknownSchemaType } from \"./schemas/any\";\nimport { BigIntSchemaType } from \"./schemas/bigint\";\nimport { BooleanSchemaType } from \"./schemas/boolean\";\nimport { DefaultSchema } from \"./schemas/default\";\nimport { DiscriminatedUnionSchema } from \"./schemas/discriminated-union\";\nimport { IntersectionSchema } from \"./schemas/intersection\";\nimport { LazySchema } from \"./schemas/lazy\";\nimport { MapSchema } from \"./schemas/map\";\nimport { NumberSchemaType } from \"./schemas/number\";\nimport { ObjectSchemaType } from \"./schemas/object\";\nimport { RecordSchema } from \"./schemas/record\";\nimport { type RefineCheck, RefineSchema } from \"./schemas/refine\";\nimport { SetSchema } from \"./schemas/set\";\nimport { StringSchemaType } from \"./schemas/string\";\nimport { PipeSchema, TransformSchema } from \"./schemas/transform\";\nimport { TupleSchema } from \"./schemas/tuple\";\nimport { UndefinedSchemaType, VoidSchemaType } from \"./schemas/undefined\";\nimport { getJsonSchema, toStandard } from \"./to-standard\";\n\n/**\n * The `h` builder: factory functions for constructing validation schemas.\n *\n * @example\n * const user = h.object({ id: h.uuid(), name: h.string().minLength(1) });\n */\nexport const h = {\n  /** Create a string schema. */\n  string: (): StringSchemaType => new StringSchemaType(),\n  /** Create a number schema. */\n  number: (): NumberSchemaType => new NumberSchemaType(),\n  /** Create a boolean schema. */\n  boolean: (): BooleanSchemaType => new BooleanSchemaType(),\n  /** Create a bigint schema. */\n  bigint: (): BigIntSchemaType => new BigIntSchemaType(),\n  /** Create a null schema. */\n  null: (): NullSchemaType => new NullSchemaType(),\n  /** Alias of {@link h.null}. */\n  nullable: (): NullSchemaType => new NullSchemaType(),\n  /** Create an undefined schema. */\n  undefined: (): UndefinedSchemaType => new UndefinedSchemaType(),\n  /** Create a void schema. */\n  void: (): VoidSchemaType => new VoidSchemaType(),\n  /** Create an `any` schema. */\n  any: (): AnySchemaType => new AnySchemaType(),\n  /** Create an `unknown` schema. */\n  unknown: (): UnknownSchemaType => new UnknownSchemaType(),\n  /** Create a `never` schema (always fails). */\n  never: (): NeverSchemaType => new NeverSchemaType(),\n\n  /**\n   * Literal value schema.\n   * @param value Literal value to match.\n   */\n  literal: <T extends string | number | boolean>(value: T): LiteralSchema<unknown, T> =>\n    new LiteralSchema<unknown, T>(value),\n\n  /**\n   * Object schema.\n   * @param schemaDef Field definitions.\n   */\n  object: <S extends SchemaDefinition>(schemaDef?: S): ObjectSchemaType<InferObject<S>> => {\n    return new ObjectSchemaType(schemaDef || {}) as ObjectSchemaType<InferObject<S>>;\n  },\n\n  /**\n   * Record schema (object with dynamic keys).\n   * @param keyOrValue Key schema (when 2 args) or value schema (when 1 arg).\n   * @param maybeValue Value schema if a key schema was provided.\n   */\n  record: ((...args: any[]) => {\n    if (args.length === 1) {\n      return new RecordSchema<string, any>(undefined, toStandard<any>(args[0]));\n    }\n    return new RecordSchema<any, any>(toStandard<any>(args[0]), toStandard<any>(args[1]));\n  }) as {\n    <V extends AnySchema>(value: V): RecordSchema<string, SchemaType<V>>;\n    <K extends AnySchema, V extends AnySchema>(\n      key: K,\n      value: V,\n    ): RecordSchema<SchemaType<K> & (string | number), SchemaType<V>>;\n  },\n\n  /**\n   * Tuple schema (fixed-length, positional).\n   * @param schemas Item schemas.\n   */\n  tuple: <S extends AnySchema[]>(\n    ...schemas: S\n  ): TupleSchema<unknown, { [K in keyof S]: SchemaType<S[K]> }> => {\n    const items = schemas.map((s) => toStandard<any>(s).schema);\n    return new TupleSchema<unknown, { [K in keyof S]: SchemaType<S[K]> }>(items);\n  },\n\n  /**\n   * Map schema.\n   * @param key Key schema.\n   * @param value Value schema.\n   */\n  map: <K extends AnySchema, V extends AnySchema>(\n    key: K,\n    value: V,\n  ): MapSchema<SchemaType<K>, SchemaType<V>> =>\n    new MapSchema<SchemaType<K>, SchemaType<V>>(toStandard<any>(key), toStandard<any>(value)),\n\n  /**\n   * Set schema.\n   * @param value Value schema.\n   */\n  set: <V extends AnySchema>(value: V): SetSchema<SchemaType<V>> =>\n    new SetSchema<SchemaType<V>>(toStandard<any>(value)),\n\n  /**\n   * Intersection schema (combines all schemas).\n   * @param schemas Schemas to intersect.\n   */\n  intersection: <S extends AnySchema[]>(\n    ...schemas: S\n  ): IntersectionSchema<unknown, InferSchema<S[number]>> => {\n    const stds = schemas.map((s) => toStandard<any>(s).schema);\n    return new IntersectionSchema<unknown, InferSchema<S[number]>>(...stds);\n  },\n\n  /**\n   * Discriminated union: faster than `options` for tagged unions.\n   * @param discriminator Field name acting as the tag.\n   * @param options Object schemas, each with the discriminator as a literal.\n   */\n  discriminatedUnion: <D extends string>(\n    discriminator: D,\n    options: ObjectSchemaType<any>[],\n  ): DiscriminatedUnionSchema<D, any> =>\n    new DiscriminatedUnionSchema<D, any>(discriminator, options),\n\n  /**\n   * Lazy schema for recursive types.\n   * @param getter Function returning the inner schema.\n   */\n  lazy: <S extends AnySchema>(getter: () => S): LazySchema<unknown, InferSchema<S>> =>\n    new LazySchema<unknown, InferSchema<S>>(() => toStandard<InferSchema<S>>(getter())),\n\n  /**\n   * Default value when the input is undefined or null.\n   * @param schema Inner schema.\n   * @param defaultValue Value or factory.\n   */\n  default: <S extends AnySchema>(\n    schema: S,\n    defaultValue: InferSchema<S> | (() => InferSchema<S>),\n  ): DefaultSchema<unknown, InferSchema<S>> =>\n    new DefaultSchema<unknown, InferSchema<S>>(\n      toStandard<InferSchema<S>>(schema),\n      defaultValue as any,\n    ),\n\n  /**\n   * Apply a transformation to the validated value.\n   * @param schema Inner schema.\n   * @param fn Transform function.\n   */\n  transform: <S extends AnySchema, Out>(\n    schema: S,\n    fn: (value: InferSchema<S>) => Out,\n  ): TransformSchema<unknown, InferSchema<S>, Out> =>\n    new TransformSchema<unknown, InferSchema<S>, Out>(toStandard<InferSchema<S>>(schema), fn),\n\n  /**\n   * Apply a custom validation predicate.\n   * @param schema Inner schema.\n   * @param check Predicate returning true / false / message / issues.\n   * @param message Default message when predicate returns false.\n   */\n  refine: <S extends AnySchema>(\n    schema: S,\n    check: RefineCheck<InferSchema<S>>,\n    message?: string,\n  ): RefineSchema<unknown, InferSchema<S>> =>\n    new RefineSchema<unknown, InferSchema<S>>(toStandard<InferSchema<S>>(schema), check, message),\n\n  /**\n   * Pipe one schema's output into another schema's input.\n   * @param a First schema.\n   * @param b Second schema receiving `a`'s output.\n   */\n  pipe: <A extends AnySchema, B extends AnySchema>(\n    a: A,\n    b: B,\n  ): PipeSchema<unknown, InferSchema<A>, InferSchema<B>> =>\n    new PipeSchema<unknown, InferSchema<A>, InferSchema<B>>(\n      toStandard<InferSchema<A>>(a),\n      toStandard<InferSchema<B>>(b) as unknown as Schema<InferSchema<A>, InferSchema<B>>,\n    ),\n\n  /**\n   * Array schema.\n   * @param schema Item schema.\n   */\n  array: <S extends AnySchema>(schema: S): ArraySchema<unknown, SchemaType<S>[]> => {\n    const base = toStandard<SchemaType<S>>(schema);\n    return base.array() as ArraySchema<unknown, SchemaType<S>[]>;\n  },\n\n  /**\n   * Enum schema from a list of literal values.\n   * @param values Allowed literals.\n   */\n  enum: <T extends string | number | boolean, Values extends readonly [T, ...T[]]>(\n    values: Values,\n  ): UnionSchema<unknown, Values[number]> => {\n    if (!values || values.length === 0) {\n      throw new Error(\"h.enum() requires a non-empty array of values.\");\n    }\n    const literalSchemas = values.map((val) => h.literal(val));\n    return h.options(...literalSchemas) as UnionSchema<unknown, Values[number]>;\n  },\n\n  /**\n   * Optional schema (allows undefined).\n   * @param schema Inner schema.\n   */\n  optional: <S extends AnySchema>(\n    schema: S,\n  ): OptionalSchema<unknown, InferSchema<S> | undefined> => {\n    return toStandard<InferSchema<S>>(schema).optional() as OptionalSchema<\n      unknown,\n      InferSchema<S> | undefined\n    >;\n  },\n\n  /**\n   * Union schema (succeeds if any branch succeeds).\n   * @param schemas Branch schemas.\n   */\n  options: <S extends AnySchema[]>(...schemas: S): UnionSchema<unknown, InferSchema<S[number]>> => {\n    const stdSchemas = schemas.map((s) => toStandard<InferSchema<S[number]>>(s).schema);\n    return new UnionSchema<unknown, InferSchema<S[number]>>(...stdSchemas);\n  },\n\n  /**\n   * Alias of {@link h.options}.\n   */\n  union: <S extends AnySchema[]>(...schemas: S): UnionSchema<unknown, InferSchema<S[number]>> =>\n    h.options(...schemas),\n\n  /**\n   * Restrict to instances of a constructor.\n   * @param constructor Class constructor.\n   */\n  instanceOf: <C extends new (...args: any[]) => any>(\n    constructor: C,\n  ): InstanceOfSchema<unknown, InstanceType<C>> => {\n    const baseSchema = h.object({});\n    return baseSchema.instanceOf(constructor);\n  },\n\n  /** Date string schema. */\n  date: (): StringSchemaType => h.string().date(),\n  /** UUID string schema. */\n  uuid: (): StringSchemaType => h.string().uuid(),\n  /** Regex string schema. */\n  regex: (regex: RegExp): StringSchemaType => h.string().regex(regex),\n  /** Email string schema. */\n  email: (): StringSchemaType => h.string().email(),\n  /** Phone string schema. */\n  phone: (): StringSchemaType => h.string().phone(),\n  /** Domain string schema. */\n  domain: (requireHttpOrHttps = true): StringSchemaType => h.string().domain(requireHttpOrHttps),\n\n  /**\n   * Coerce-then-validate factories. Equivalent to `h.X().coerce()`.\n   */\n  coerce: {\n    /** Coerce input to string. */\n    string: (): StringSchemaType => new StringSchemaType().coerce(),\n    /** Coerce input to number. */\n    number: (): NumberSchemaType => new NumberSchemaType().coerce(),\n    /** Coerce input to boolean. */\n    boolean: (): BooleanSchemaType => new BooleanSchemaType().coerce(),\n    /** Coerce input to bigint. */\n    bigint: (): BigIntSchemaType => new BigIntSchemaType().coerce(),\n  },\n\n  /** Re-export of {@link toStandard}. */\n  toStandard,\n\n  /**\n   * Get JSON Schema from a validation schema.\n   * @param schema Schema to convert.\n   * @param options Conversion options.\n   */\n  getJsonSchema,\n};\n"],"mappings":"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"}