@esmj/schema 0.7.2 → 0.7.4

package/dist/index.d.mts

@@ -19,7 +19,7 @@ interface ParseOptions {
     abortEarly?: boolean;
 }
 interface SchemaInterface<Input, Output> {
-    _getName(): string;
+    _getName(): undefined | string;
     _getType(): string;
     _getDescription(): string;
     _parse(value: Input | Partial<Input>, options?: ParseOptions): InternalParseOutput<Output>;
@@ -51,6 +51,8 @@ interface BooleanSchemaInterface extends SchemaInterface<boolean, boolean> {
 }
 interface DateSchemaInterface extends SchemaInterface<Date, Date> {
 }
+interface FunctionSchemaInterface extends SchemaInterface<Function, Function> {
+}
 interface ArraySchemaInterface<T extends SchemaType> extends SchemaInterface<Array<ReturnType<T['parse']>>, Array<ReturnType<T['parse']>>> {
 }
 interface ObjectSchemaInterface<T extends Record<string, SchemaType>> extends SchemaInterface<{
@@ -59,7 +61,7 @@ interface ObjectSchemaInterface<T extends Record<string, SchemaType>> extends Sc
     [Property in keyof T]: ReturnType<T[Property]['parse']>;
 }> {
 }
-type SchemaType = LiteralSchemaInterface<string> | LiteralSchemaInterface<number> | LiteralSchemaInterface<boolean> | StringSchemaInterface | SchemaInterface<unknown, unknown> | SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | ObjectSchemaInterface<Record<string, SchemaType>> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | NumberSchemaInterface | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | BooleanSchemaInterface | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | DateSchemaInterface | SchemaInterface<Date, Date> | SchemaInterface<Date, Date | undefined> | SchemaInterface<Date, Date | null> | SchemaInterface<Date, Date | undefined | null> | EnumSchemaInterface<string> | UnionSchemaInterface<Array<SchemaInterface<unknown, unknown>>> | ArraySchemaInterface<StringSchemaInterface | ObjectSchemaInterface<Record<string, SchemaType>> | NumberSchemaInterface | BooleanSchemaInterface | DateSchemaInterface | EnumSchemaInterface<string>> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
+type SchemaType = LiteralSchemaInterface<string> | LiteralSchemaInterface<number> | LiteralSchemaInterface<boolean> | StringSchemaInterface | SchemaInterface<unknown, unknown> | SchemaInterface<string, string> | SchemaInterface<string, string | undefined> | SchemaInterface<string, string | null> | SchemaInterface<string, string | undefined | null> | ObjectSchemaInterface<Record<string, SchemaType>> | SchemaInterface<object, object> | SchemaInterface<object, object | undefined> | SchemaInterface<object, object | null> | SchemaInterface<object, object | undefined | null> | NumberSchemaInterface | SchemaInterface<number, number> | SchemaInterface<number, number | undefined> | SchemaInterface<number, number | null> | SchemaInterface<number, number | undefined | null> | BooleanSchemaInterface | SchemaInterface<boolean, boolean> | SchemaInterface<boolean, boolean | undefined> | SchemaInterface<boolean, boolean | null> | SchemaInterface<boolean, boolean | undefined | null> | DateSchemaInterface | SchemaInterface<Date, Date> | SchemaInterface<Date, Date | undefined> | SchemaInterface<Date, Date | null> | SchemaInterface<Date, Date | undefined | null> | FunctionSchemaInterface | EnumSchemaInterface<string> | UnionSchemaInterface<Array<SchemaInterface<unknown, unknown>>> | ArraySchemaInterface<StringSchemaInterface | ObjectSchemaInterface<Record<string, SchemaType>> | NumberSchemaInterface | BooleanSchemaInterface | DateSchemaInterface | EnumSchemaInterface<string>> | SchemaInterface<Array<unknown>, Array<unknown>> | SchemaInterface<Array<unknown>, Array<unknown> | undefined> | SchemaInterface<Array<unknown>, Array<unknown> | null> | SchemaInterface<Array<unknown>, Array<unknown> | undefined | null>;
 type ErrorMessage = string | ((value: unknown) => string);
 type ExtenderType = (inter: SchemaType, validation: Function, options?: {
     message: ErrorMessage;
@@ -71,268 +73,57 @@ interface CreateSchemaInterfaceOptions {
     message?: ErrorMessage;
 }
 type SchemaInterfaceOptions = Omit<CreateSchemaInterfaceOptions, 'type'>;
-declare const s: {
-    /**
-     * Creates an object schema with validated fields.
-     *
-     * @param definition - Object containing field schemas
-     * @param options - Optional configuration (name, message)
-     * @returns Object schema interface
-     *
-     * @example
-     * ```typescript
-     * const userSchema = s.object({
-     *   name: s.string(),
-     *   age: s.number()
-     * });
-     * ```
-     */
-    object<T extends Record<string, SchemaType>>(definition: { [Property in keyof T]: T[Property]; }, options?: SchemaInterfaceOptions): ObjectSchemaInterface<T>;
-    /**
-     * Creates a string schema.
-     *
-     * @param options - Optional configuration (name, message)
-     * @returns String schema interface
-     *
-     * @example
-     * ```typescript
-     * const nameSchema = s.string();
-     * const result = nameSchema.parse('John'); // 'John'
-     * ```
-     */
+declare function object<T extends Record<string, SchemaType>>(definition: {
+    [Property in keyof T]: T[Property];
+}, options?: SchemaInterfaceOptions): ObjectSchemaInterface<T>;
+declare function string(options?: SchemaInterfaceOptions): StringSchemaInterface;
+declare function number(options?: SchemaInterfaceOptions): NumberSchemaInterface;
+declare function boolean(options?: SchemaInterfaceOptions): BooleanSchemaInterface;
+declare function date(options?: SchemaInterfaceOptions): DateSchemaInterface;
+declare function functionSchema(options?: SchemaInterfaceOptions): FunctionSchemaInterface;
+declare function enumSchema(definition: Readonly<Array<string>>, options?: SchemaInterfaceOptions): EnumSchemaInterface<(typeof definition)[number]>;
+declare function array<T extends SchemaType>(definition: T, options?: SchemaInterfaceOptions): ArraySchemaInterface<T>;
+declare function any(): SchemaInterface<unknown, unknown>;
+declare function preprocess<T extends SchemaType>(callback: Function, schema: T): T;
+declare function union<T extends Array<SchemaType>>(definitions: T, options?: SchemaInterfaceOptions): UnionSchemaInterface<T>;
+declare function literal<T extends string | number | boolean>(value: T, options?: SchemaInterfaceOptions): LiteralSchemaInterface<T>;
+declare const coerce: {
     string(options?: SchemaInterfaceOptions): StringSchemaInterface;
-    /**
-     * Creates a number schema.
-     *
-     * @param options - Optional configuration (name, message)
-     * @returns Number schema interface
-     *
-     * @example
-     * ```typescript
-     * const ageSchema = s.number();
-     * const result = ageSchema.parse(25); // 25
-     * ```
-     */
     number(options?: SchemaInterfaceOptions): NumberSchemaInterface;
-    /**
-     * Creates a boolean schema.
-     *
-     * @param options - Optional configuration (name, message)
-     * @returns Boolean schema interface
-     *
-     * @example
-     * ```typescript
-     * const isActiveSchema = s.boolean();
-     * const result = isActiveSchema.parse(true); // true
-     * ```
-     */
     boolean(options?: SchemaInterfaceOptions): BooleanSchemaInterface;
-    /**
-     * Creates a date schema.
-     *
-     * @param options - Optional configuration (name, message)
-     * @returns Date schema interface
-     *
-     * @example
-     * ```typescript
-     * const birthdateSchema = s.date();
-     * const result = birthdateSchema.parse(new Date()); // Date object
-     * ```
-     */
     date(options?: SchemaInterfaceOptions): DateSchemaInterface;
-    /**
-     * Creates an enum schema with predefined values.
-     *
-     * @param definition - Array of allowed string values
-     * @param options - Optional configuration (name, message)
-     * @returns Enum schema interface
-     *
-     * @example
-     * ```typescript
-     * const roleSchema = s.enum(['admin', 'user', 'guest']);
-     * const result = roleSchema.parse('admin'); // 'admin'
-     * ```
-     */
-    enum(definition: Readonly<Array<string>>, options?: SchemaInterfaceOptions): EnumSchemaInterface<(typeof definition)[number]>;
-    /**
-     * Creates an array schema with element validation.
-     *
-     * @param definition - Schema for array elements
-     * @param options - Optional configuration (name, message)
-     * @returns Array schema interface
-     *
-     * @example
-     * ```typescript
-     * const tagsSchema = s.array(s.string());
-     * const result = tagsSchema.parse(['tag1', 'tag2']); // ['tag1', 'tag2']
-     * ```
-     */
-    array<T extends SchemaType>(definition: T, options?: SchemaInterfaceOptions): ArraySchemaInterface<T>;
-    /**
-     * Creates a schema that accepts any value without validation.
-     *
-     * @returns Schema interface that accepts any value
-     *
-     * @example
-     * ```typescript
-     * const anySchema = s.any();
-     * const result = anySchema.parse({ anything: true }); // { anything: true }
-     * ```
-     */
-    any(): any;
-    /**
-     * Preprocesses a value before passing it to a schema for validation.
-     *
-     * @param callback - Function to transform the value before validation
-     * @param schema - Schema to validate the transformed value
-     * @returns Modified schema with preprocessing
-     *
-     * @example
-     * ```typescript
-     * const schema = s.preprocess(
-     *   (val) => String(val).trim(),
-     *   s.string().min(3)
-     * );
-     * const result = schema.parse('  hello  '); // 'hello'
-     * ```
-     */
-    preprocess<T extends SchemaType>(callback: Function, schema: T): T;
-    /**
-     * Creates a union schema that validates against multiple schemas.
-     * The value must match at least one of the provided schemas.
-     *
-     * @param definitions - Array of schemas to validate against
-     * @param options - Optional configuration (name, message)
-     * @returns Union schema interface
-     *
-     * @example
-     * ```typescript
-     * const idSchema = s.union([s.string(), s.number()]);
-     * const result1 = idSchema.parse('abc'); // 'abc'
-     * const result2 = idSchema.parse(123); // 123
-     * ```
-     */
-    union<T extends Array<SchemaType>>(definitions: T, options?: SchemaInterfaceOptions): UnionSchemaInterface<T>;
-    /**
-     * Creates a literal schema that only accepts a specific value.
-     *
-     * @param value - The exact value to match
-     * @param options - Optional configuration
-     * @returns Literal schema interface
-     *
-     * @example
-     * ```typescript
-     * const adminSchema = s.literal('admin');
-     * adminSchema.parse('admin'); // 'admin'
-     * adminSchema.parse('user'); // throws error
-     * ```
-     */
-    literal<T extends string | number | boolean>(value: T, options?: SchemaInterfaceOptions): LiteralSchemaInterface<T>;
-    /**
-     * Coerce schemas that apply a native JS constructor before validation.
-     * Unlike `s.preprocess`, coerce provides a consistent API for common type
-     * conversions with clear error messages when coercion produces an invalid result.
-     *
-     * @example
-     * ```typescript
-     * s.coerce.number().parse('42');       // 42
-     * s.coerce.string().parse(123);        // '123'
-     * s.coerce.boolean().parse(0);         // false
-     * s.coerce.date().parse('2024-01-01'); // Date object
-     * ```
-     */
+};
+declare const cast: {
+    boolean(options?: SchemaInterfaceOptions): BooleanSchemaInterface;
+    number(options?: SchemaInterfaceOptions): NumberSchemaInterface;
+    string(options?: SchemaInterfaceOptions): StringSchemaInterface;
+    date(options?: SchemaInterfaceOptions): DateSchemaInterface;
+    json<T extends SchemaType>(schema: T, options?: SchemaInterfaceOptions): T;
+};
+declare const s: {
+    object: typeof object;
+    string: typeof string;
+    number: typeof number;
+    boolean: typeof boolean;
+    date: typeof date;
+    function: typeof functionSchema;
+    enum: typeof enumSchema;
+    array: typeof array;
+    any: typeof any;
+    preprocess: typeof preprocess;
+    union: typeof union;
+    literal: typeof literal;
     coerce: {
-        /**
-         * Creates a string schema that coerces input using `String(value)`.
-         * Always succeeds — `String()` never produces an invalid string.
-         */
         string(options?: SchemaInterfaceOptions): StringSchemaInterface;
-        /**
-         * Creates a number schema that coerces input using `Number(value)`.
-         * Fails when the result is `NaN` (e.g. `'bad'`, `undefined`, plain objects).
-         */
         number(options?: SchemaInterfaceOptions): NumberSchemaInterface;
-        /**
-         * Creates a boolean schema that coerces input using `Boolean(value)`.
-         * Always succeeds — `Boolean()` always produces `true` or `false`.
-         * Note: `Boolean('false')` is `true` because `'false'` is a non-empty string.
-         */
         boolean(options?: SchemaInterfaceOptions): BooleanSchemaInterface;
-        /**
-         * Creates a date schema that coerces input using `new Date(value)`.
-         * Fails when the result is an invalid Date (e.g. `'garbage'`).
-         */
         date(options?: SchemaInterfaceOptions): DateSchemaInterface;
     };
-    /**
-     * Smart cast schemas that apply semantic conversion before validation.
-     * Unlike `s.coerce` (which uses raw JS constructors), `s.cast` understands
-     * common programmer-friendly string representations and rejects ambiguous
-     * inputs such as `null`, `undefined`, and empty strings.
-     *
-     * Differences from `s.coerce`:
-     * - `cast.boolean('false')` → `false` (coerce gives `true` — non-empty string)
-     * - `cast.boolean('yes'/'no'/'on'/'off')` → `true`/`false` (coerce doesn't understand these)
-     * - `cast.number(null)` → throws (coerce gives `0`)
-     * - `cast.number('')` → throws (coerce gives `0`)
-     * - `cast.string(null)` → throws (coerce gives `'null'`)
-     * - `cast.date(null)` → throws (coerce gives epoch Date)
-     *
-     * @example
-     * ```typescript
-     * s.cast.boolean().parse('false');  // false — unlike coerce!
-     * s.cast.boolean().parse('yes');    // true
-     * s.cast.boolean().parse('on');     // true
-     * s.cast.number().parse(' 42 ');   // 42 — trims whitespace
-     * s.cast.number().parse(null);      // throws
-     * s.cast.string().parse(123);       // '123'
-     * s.cast.string().parse(null);      // throws — unlike coerce!
-     * s.cast.date().parse('2024-01-01'); // Date object
-     * s.cast.date().parse(null);         // throws — unlike coerce!
-     * ```
-     */
     cast: {
-        /**
-         * Creates a boolean schema with semantic string casting.
-         * Recognises (case-insensitive): `'true'/'false'`, `'yes'/'no'`, `'on'/'off'`, `'1'/'0'`.
-         * Numbers `1` and `0` are accepted; any other number throws.
-         * `null`, `undefined`, and unrecognised strings throw.
-         */
         boolean(options?: SchemaInterfaceOptions): BooleanSchemaInterface;
-        /**
-         * Creates a number schema with smart string parsing.
-         * Trims whitespace from strings before converting. Accepts booleans (`true`→1, `false`→0).
-         * Rejects `null`, `undefined`, empty/whitespace-only strings, and non-numeric strings.
-         */
         number(options?: SchemaInterfaceOptions): NumberSchemaInterface;
-        /**
-         * Creates a string schema that accepts strings, finite numbers, and booleans.
-         * Rejects `null`, `undefined`, objects, arrays, `NaN`, and `Infinity`.
-         */
         string(options?: SchemaInterfaceOptions): StringSchemaInterface;
-        /**
-         * Creates a date schema with controlled casting.
-         * Accepts ISO date strings (non-empty), finite integer timestamps, and existing Date objects.
-         * Rejects `null`, `undefined`, booleans, empty strings, and non-finite numbers.
-         */
         date(options?: SchemaInterfaceOptions): DateSchemaInterface;
-        /**
-         * Parses a JSON string and validates the result against the provided schema.
-         * If the input is not a string, it is passed directly to the inner schema.
-         * Produces a proper validation failure (never throws) when the JSON is malformed.
-         *
-         * @param schema - Schema to validate the parsed value against
-         * @param options - Optional configuration (name, message)
-         * @returns The same schema type, with JSON string preprocessing applied
-         *
-         * @example
-         * ```typescript
-         * const schema = s.cast.json(s.object({ name: s.string() }));
-         * schema.parse('{"name":"Alice"}'); // { name: 'Alice' }
-         * schema.parse({ name: 'Alice' });  // { name: 'Alice' } — pass-through
-         * schema.safeParse('not json');     // { success: false, error: ... }
-         * ```
-         */
         json<T extends SchemaType>(schema: T, options?: SchemaInterfaceOptions): T;
     };
 };
@@ -395,4 +186,4 @@ declare function extend(callback: ExtenderType): void;
  */
 type Infer<T> = T extends SchemaType ? ReturnType<T['parse']> : unknown;
 
-export { type ArraySchemaInterface, type BooleanSchemaInterface, type DateSchemaInterface, type EnumSchemaInterface, type ErrorStructure, type ExtenderType, type Infer, type Invalid, type LiteralSchemaInterface, type NumberSchemaInterface, type ObjectSchemaInterface, type SchemaInterface, type SchemaInterfaceOptions, type SchemaType, type StringSchemaInterface, type UnionSchemaInterface, type Valid, extend, hookOriginal, s, s as schema };
+export { type ArraySchemaInterface, type BooleanSchemaInterface, type DateSchemaInterface, type EnumSchemaInterface, type ErrorStructure, type ExtenderType, type FunctionSchemaInterface, type Infer, type Invalid, type LiteralSchemaInterface, type NumberSchemaInterface, type ObjectSchemaInterface, type SchemaInterface, type SchemaInterfaceOptions, type SchemaType, type StringSchemaInterface, type UnionSchemaInterface, type Valid, any, array, boolean, cast, coerce, date, enumSchema, extend, functionSchema, hookOriginal, literal, number, object, preprocess, s, s as schema, string, union };