z-schema 12.0.4 → 12.1.0

package/dist/z-schema.js

@@ -1,287 +0,0 @@
-import './z-schema-versions.js';
-import { getRegisteredFormats, registerFormat, unregisterFormat } from './format-validators.js';
-import { prepareRemoteSchema, SchemaCache } from './schema-cache.js';
-import { deepClone } from './utils/clone.js';
-import { jsonSymbol, schemaSymbol } from './utils/symbols.js';
-import { FACTORY_TOKEN, ZSchemaBase } from './z-schema-base.js';
-import { defaultOptions } from './z-schema-options.js';
-import { getSchemaReader, setSchemaReader } from './z-schema-reader.js';
-export class ZSchema extends ZSchemaBase {
-    /** @internal Use ZSchema.create() instead. */
-    constructor(options, token) {
-        super(options, token);
-    }
-    // ----- static methods start -----
-    // class scoped format functions
-    /**
-     * Register a global format validator available to all instances.
-     * @param name - The format name (e.g. `'email'`, `'date'`).
-     * @param validatorFunction - A sync or async function `(value: unknown) => boolean | Promise<boolean>`.
-     */
-    static registerFormat(name, validatorFunction) {
-        return registerFormat(name, validatorFunction);
-    }
-    /**
-     * Remove a globally registered format validator.
-     * @param name - The format name to unregister.
-     */
-    static unregisterFormat(name) {
-        return unregisterFormat(name);
-    }
-    /** Returns the names of all globally registered format validators. */
-    static getRegisteredFormats() {
-        return getRegisteredFormats();
-    }
-    /** Returns a deep clone of the default options. */
-    static getDefaultOptions() {
-        return deepClone(defaultOptions);
-    }
-    /**
-     * Register a remote schema in the global cache so any instance can resolve `$ref` to it.
-     * @param uri - The URI the schema will be known by.
-     * @param schema - The schema object or JSON string.
-     * @param validationOptions - Optional options used for schema preparation.
-     */
-    static setRemoteReference(uri, schema, validationOptions) {
-        const _schema = prepareRemoteSchema(schema, uri, validationOptions);
-        SchemaCache.cacheSchemaByUri(uri, _schema);
-    }
-    /** Returns the current global schema reader, or `undefined` if none is set. */
-    static getSchemaReader() {
-        return getSchemaReader();
-    }
-    /**
-     * Set a global schema reader function used to resolve remote `$ref` URIs.
-     * @param schemaReader - A function `(uri: string) => JsonSchema | undefined`, or `undefined` to clear.
-     */
-    static setSchemaReader(schemaReader) {
-        return setSchemaReader(schemaReader);
-    }
-    static schemaSymbol = schemaSymbol;
-    static jsonSymbol = jsonSymbol;
-    static create(options = {}) {
-        const isAsync = options.async;
-        const isSafe = options.safe;
-        delete options.async;
-        delete options.safe;
-        if (isAsync && isSafe) {
-            return new ZSchemaAsyncSafe(options, FACTORY_TOKEN);
-        }
-        if (isAsync) {
-            return new ZSchemaAsync(options, FACTORY_TOKEN);
-        }
-        if (isSafe) {
-            return new ZSchemaSafe(options, FACTORY_TOKEN);
-        }
-        return new ZSchema(options, FACTORY_TOKEN);
-    }
-    /**
-     * Validate JSON data against a schema.
-     * @param json - The data to validate.
-     * @param schema - A JSON Schema object or a schema id string (previously registered via `validateSchema`).
-     * @param options - Per-call options (`schemaPath`, `includeErrors`, `excludeErrors`).
-     * @returns `true` if valid.
-     * @throws {@link ValidateError} if validation fails, with a `details` array of structured errors.
-     */
-    validate(json, schema, options = {}) {
-        return this._validate(json, schema, options);
-    }
-    /**
-     * Validate JSON data against a schema, returning a result object instead of throwing.
-     * @param json - The data to validate.
-     * @param schema - A JSON Schema object or a schema id string.
-     * @param options - Per-call options.
-     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
-     */
-    validateSafe(json, schema, options) {
-        try {
-            this._validate(json, schema, options ?? {});
-            return { valid: true };
-        }
-        catch (err) {
-            return { valid: false, err: err };
-        }
-    }
-    /**
-     * Validate JSON data against a schema asynchronously (supports async format validators).
-     * @param json - The data to validate.
-     * @param schema - A JSON Schema object or a schema id string.
-     * @param options - Per-call options.
-     * @returns A promise that resolves to `true` if valid.
-     * @throws {@link ValidateError} if validation fails (the promise rejects).
-     */
-    validateAsync(json, schema, options) {
-        return new Promise((resolve, reject) => {
-            try {
-                this._validate(json, schema, options || {}, (err, valid) => err || valid !== true ? reject(err) : resolve(valid));
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    /**
-     * Validate JSON data against a schema asynchronously, returning a result object.
-     * The promise always resolves (never rejects).
-     * @param json - The data to validate.
-     * @param schema - A JSON Schema object or a schema id string.
-     * @param options - Per-call options.
-     * @returns A promise resolving to `{ valid: true }` or `{ valid: false, err: ValidateError }`.
-     */
-    validateAsyncSafe(json, schema, options) {
-        return new Promise((resolve) => {
-            try {
-                this._validate(json, schema, options || {}, (err, valid) => {
-                    resolve({ valid, err });
-                });
-            }
-            catch (err) {
-                resolve({ valid: false, err: err });
-            }
-        });
-    }
-    /**
-     * Validate one or more JSON Schemas, compiling and caching them for later use with `validate()`.
-     * @param schemaOrArr - A single schema or an array of schemas (for cross-referencing).
-     * @returns `true` if all schemas are valid.
-     * @throws {@link ValidateError} if any schema is invalid.
-     */
-    validateSchema(schemaOrArr) {
-        return this._validateSchema(schemaOrArr);
-    }
-    /**
-     * Validate one or more JSON Schemas, returning a result object instead of throwing.
-     * @param schemaOrArr - A single schema or an array of schemas.
-     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
-     */
-    validateSchemaSafe(schemaOrArr) {
-        try {
-            this._validateSchema(schemaOrArr);
-            return { valid: true };
-        }
-        catch (err) {
-            return { valid: false, err: err };
-        }
-    }
-}
-/**
- * Synchronous safe validator — `validate()` returns `{ valid, err? }` instead of throwing.
- * Created via `ZSchema.create({ safe: true })`.
- */
-export class ZSchemaSafe extends ZSchemaBase {
-    /** @internal Use ZSchema.create() instead. */
-    constructor(options, token) {
-        super(options, token);
-    }
-    /**
-     * Validate JSON data against a schema.
-     * @param json - The data to validate.
-     * @param schema - A JSON Schema object or a schema id string.
-     * @param options - Per-call options.
-     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
-     */
-    validate(json, schema, options = {}) {
-        try {
-            this._validate(json, schema, options);
-            return { valid: true };
-        }
-        catch (err) {
-            return { valid: false, err: err };
-        }
-    }
-    /**
-     * Validate one or more JSON Schemas.
-     * @param schemaOrArr - A single schema or an array of schemas.
-     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
-     */
-    validateSchema(schemaOrArr) {
-        try {
-            this._validateSchema(schemaOrArr);
-            return { valid: true };
-        }
-        catch (err) {
-            return { valid: false, err: err };
-        }
-    }
-}
-/**
- * Asynchronous throw validator — `validate()` returns `Promise<true>` or rejects.
- * Created via `ZSchema.create({ async: true })`.
- */
-export class ZSchemaAsync extends ZSchemaBase {
-    /** @internal Use ZSchema.create() instead. */
-    constructor(options, token) {
-        super(options, token);
-    }
-    /**
-     * Validate JSON data against a schema asynchronously.
-     * @param json - The data to validate.
-     * @param schema - A JSON Schema object or a schema id string.
-     * @param options - Per-call options.
-     * @returns A promise that resolves to `true` if valid.
-     * @throws {@link ValidateError} if validation fails (the promise rejects).
-     */
-    validate(json, schema, options = {}) {
-        return new Promise((resolve, reject) => {
-            try {
-                this._validate(json, schema, options, (err, valid) => (err || valid !== true ? reject(err) : resolve(valid)));
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    /**
-     * Validate one or more JSON Schemas (synchronous, throws on error).
-     * @param schemaOrArr - A single schema or an array of schemas.
-     * @returns `true` if all schemas are valid.
-     * @throws {@link ValidateError} if any schema is invalid.
-     */
-    validateSchema(schemaOrArr) {
-        return this._validateSchema(schemaOrArr);
-    }
-}
-/**
- * Asynchronous safe validator — `validate()` returns `Promise<{ valid, err? }>` (never rejects).
- * Created via `ZSchema.create({ async: true, safe: true })`.
- */
-export class ZSchemaAsyncSafe extends ZSchemaBase {
-    /** @internal Use ZSchema.create() instead. */
-    constructor(options, token) {
-        super(options, token);
-    }
-    /**
-     * Validate JSON data against a schema asynchronously.
-     * The promise always resolves (never rejects).
-     * @param json - The data to validate.
-     * @param schema - A JSON Schema object or a schema id string.
-     * @param options - Per-call options.
-     * @returns A promise resolving to `{ valid: true }` or `{ valid: false, err: ValidateError }`.
-     */
-    validate(json, schema, options = {}) {
-        return new Promise((resolve) => {
-            try {
-                this._validate(json, schema, options, (err, valid) => {
-                    resolve({ valid, err });
-                });
-            }
-            catch (err) {
-                resolve({ valid: false, err: err });
-            }
-        });
-    }
-    /**
-     * Validate one or more JSON Schemas.
-     * @param schemaOrArr - A single schema or an array of schemas.
-     * @returns `{ valid: true }` on success, or `{ valid: false, err: ValidateError }` on failure.
-     */
-    validateSchema(schemaOrArr) {
-        try {
-            this._validateSchema(schemaOrArr);
-            return { valid: true };
-        }
-        catch (err) {
-            return { valid: false, err: err };
-        }
-    }
-}