z-schema 12.0.4 → 12.1.0

package/dist/z-schema-base.js

@@ -1,286 +0,0 @@
-import { getValidateError } from './errors.js';
-import { getSupportedFormats } from './format-validators.js';
-import { isInternalKey } from './json-schema.js';
-import { VERSION_SCHEMA_URL_MAPPING } from './json-schema-versions.js';
-import { validate as validateJson } from './json-validation.js';
-import { Report } from './report.js';
-import { prepareRemoteSchema, SchemaCache } from './schema-cache.js';
-import { SchemaCompiler } from './schema-compiler.js';
-import { SchemaValidator } from './schema-validator.js';
-import { deepClone } from './utils/clone.js';
-import { get, sortedKeys } from './utils/json.js';
-import { copyProp } from './utils/properties.js';
-import { getRemotePath } from './utils/uri.js';
-import { isObject, whatIs } from './utils/what-is.js';
-import { defaultOptions, normalizeOptions } from './z-schema-options.js';
-/**
- * Module-private symbol used by `ZSchema.create()` to authorise construction.
- * Not exported — external code cannot instantiate ZSchema variants directly.
- */
-export const FACTORY_TOKEN = Symbol('ZSchema.factory');
-export class ZSchemaBase {
-    scache;
-    sc;
-    sv;
-    validateOptions = {};
-    options;
-    constructor(options, token) {
-        if (token !== FACTORY_TOKEN) {
-            throw new Error('do not use new ZSchema(), use ZSchema.create() instead');
-        }
-        this.scache = new SchemaCache(this);
-        this.sc = new SchemaCompiler(this);
-        this.sv = new SchemaValidator(this);
-        this.options = normalizeOptions(options);
-    }
-    /**
-     * Internal recursive JSON validation — delegates to the `validate` function
-     * in `json-validation.ts`. Exposed as a method so that per-keyword validator
-     * modules (array, combinators, object) can call back into the core validator
-     * via `this` without importing `json-validation.ts` directly (which would
-     * create a circular dependency).
-     */
-    _jsonValidate(report, schema, json) {
-        return validateJson.call(this, report, schema, json);
-    }
-    getDefaultSchemaId() {
-        return this.options.version && this.options.version !== 'none'
-            ? VERSION_SCHEMA_URL_MAPPING[this.options.version]
-            : VERSION_SCHEMA_URL_MAPPING[defaultOptions.version];
-    }
-    _validate(json, schema, options, callback) {
-        if (typeof options === 'function') {
-            callback = options;
-            options = {};
-        }
-        if (!options) {
-            options = {};
-        }
-        this.validateOptions = options;
-        if (typeof schema !== 'string' && typeof schema !== 'boolean' && !isObject(schema)) {
-            const e = new Error('Invalid .validate call - schema must be a string or object but ' + whatIs(schema) + ' was passed!');
-            if (callback) {
-                setTimeout(function () {
-                    callback(e, false);
-                }, 0);
-                return;
-            }
-            throw e;
-        }
-        let foundError = false;
-        const report = new Report(this.options, options);
-        report.json = json;
-        let _schema;
-        if (typeof schema === 'string') {
-            const schemaName = schema;
-            _schema = this.scache.getSchema(report, schemaName);
-            if (!_schema) {
-                const e = new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
-                if (callback) {
-                    setTimeout(function () {
-                        callback(e, false);
-                    }, 0);
-                    return;
-                }
-                throw e;
-            }
-        }
-        else {
-            _schema = this.scache.getSchema(report, schema);
-        }
-        let compiled = false;
-        if (!foundError) {
-            compiled = this.sc.compileSchema(report, _schema);
-        }
-        if (!compiled) {
-            foundError = true;
-        }
-        let validated = false;
-        if (!foundError) {
-            validated = this.sv.validateSchema(report, _schema);
-        }
-        if (!validated) {
-            foundError = true;
-        }
-        if (options.schemaPath) {
-            report.rootSchema = _schema;
-            _schema = get(_schema, options.schemaPath);
-            if (!_schema) {
-                const e = new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
-                if (callback) {
-                    setTimeout(function () {
-                        callback(e, false);
-                    }, 0);
-                    return;
-                }
-                throw e;
-            }
-        }
-        if (!foundError) {
-            validateJson.call(this, report, _schema, json);
-        }
-        if (callback) {
-            report.processAsyncTasks(this.options.asyncTimeout, callback);
-            return;
-        }
-        else if (report.asyncTasks.length > 0) {
-            throw new Error('This validation has async tasks and cannot be done in sync mode, please provide callback argument.');
-        }
-        if (!report.isValid()) {
-            throw getValidateError({
-                message: report.commonErrorMessage,
-                details: report.errors,
-            });
-        }
-        return true;
-    }
-    _validateSchema(schemaOrArr) {
-        if (Array.isArray(schemaOrArr) && schemaOrArr.length === 0) {
-            throw new Error('.compileSchema was called with an empty array');
-        }
-        const report = new Report(this.options);
-        if (Array.isArray(schemaOrArr)) {
-            const arr = this.scache.getSchema(report, schemaOrArr);
-            const compiled = this.sc.compileSchema(report, arr);
-            if (compiled) {
-                this.sv.validateSchema(report, arr);
-            }
-        }
-        else {
-            const schema = this.scache.getSchema(report, schemaOrArr);
-            const compiled = this.sc.compileSchema(report, schema);
-            if (compiled) {
-                this.sv.validateSchema(report, schema);
-            }
-        }
-        if (!report.isValid()) {
-            throw getValidateError({ message: report.commonErrorMessage, details: report.errors });
-        }
-        return true;
-    }
-    /**
-     * Register a format validator on this instance only (does not affect other instances or the global registry).
-     * @param name - The format name.
-     * @param validatorFunction - A sync or async function `(value: unknown) => boolean | Promise<boolean>`.
-     */
-    registerFormat(name, validatorFunction) {
-        if (!this.options.customFormats) {
-            this.options.customFormats = {};
-        }
-        this.options.customFormats[name] = validatorFunction;
-    }
-    /**
-     * Unregister an instance-scoped format validator.
-     * @param name - The format name to unregister.
-     */
-    unregisterFormat(name) {
-        if (!this.options.customFormats) {
-            this.options.customFormats = {};
-        }
-        this.options.customFormats[name] = null;
-    }
-    /** Returns the names of format validators registered on this instance. */
-    getRegisteredFormats() {
-        return sortedKeys(this.options.customFormats || {}).filter((key) => this.options.customFormats?.[key] != null);
-    }
-    /** Returns all supported format names (global + instance-registered). */
-    getSupportedFormats() {
-        return getSupportedFormats(this.options.customFormats);
-    }
-    /**
-     * Register a remote schema in this instance's cache so `$ref` can resolve 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.
-     */
-    setRemoteReference(uri, schema, validationOptions) {
-        const _schema = prepareRemoteSchema(schema, uri, validationOptions, this.options.maxRecursionDepth);
-        this.scache.cacheSchemaByUri(uri, _schema);
-    }
-    /**
-     * Extract unresolvable `$ref` URIs from a validation error.
-     * @param err - A `ValidateError` from a failed validation.
-     * @returns An array of unresolvable reference URIs.
-     */
-    getMissingReferences(err) {
-        if (!err)
-            return [];
-        const details = err.details || [];
-        const missingRefs = [];
-        function collect(details) {
-            for (const detail of details) {
-                if (detail.code === 'UNRESOLVABLE_REFERENCE' || detail.code === 'SCHEMA_NOT_REACHABLE') {
-                    missingRefs.push(detail.params[0]);
-                }
-                if (detail.inner) {
-                    collect(detail.inner);
-                }
-            }
-        }
-        collect(details);
-        return missingRefs;
-    }
-    /**
-     * Extract unresolvable **remote** `$ref` URIs from a validation error (local fragment-only refs are excluded).
-     * @param err - A `ValidateError` from a failed validation.
-     * @returns An array of remote reference base URIs.
-     */
-    getMissingRemoteReferences(err) {
-        const missingReferences = this.getMissingReferences(err);
-        const missingRemoteReferences = [];
-        for (const ref of missingReferences) {
-            const remoteReference = getRemotePath(ref);
-            if (remoteReference && !missingRemoteReferences.includes(remoteReference)) {
-                missingRemoteReferences.push(remoteReference);
-            }
-        }
-        return missingRemoteReferences;
-    }
-    /**
-     * Resolve a previously compiled schema by its `$id` / `id`, cleaning up internal bookkeeping properties
-     * and inlining resolved `$ref` targets.
-     * @param schemaId - The schema identifier to look up.
-     * @returns A clean, resolved copy of the schema, or `undefined` if not found.
-     */
-    getResolvedSchema(schemaId) {
-        const report = new Report(this.options);
-        const schema = this.scache.getSchemaByUri(report, schemaId);
-        if (!schema)
-            return undefined;
-        const clonedSchema = deepClone(schema, this.options.maxRecursionDepth);
-        const visited = new WeakSet();
-        // clean-up the schema and resolve references
-        const cleanup = function (schema) {
-            let key;
-            const typeOf = whatIs(schema);
-            if (typeOf !== 'object' && typeOf !== 'array') {
-                return;
-            }
-            if (visited.has(schema)) {
-                return;
-            }
-            visited.add(schema);
-            if (schema.$ref && schema.__$refResolved) {
-                const from = schema.__$refResolved;
-                const to = schema;
-                delete schema.$ref;
-                delete schema.__$refResolved;
-                for (key in from) {
-                    copyProp(from, to, key);
-                }
-            }
-            for (key in schema) {
-                if (Object.hasOwn(schema, key)) {
-                    if (isInternalKey(key)) {
-                        delete schema[key];
-                    }
-                    else {
-                        cleanup(schema[key]);
-                    }
-                }
-            }
-        };
-        cleanup(clonedSchema);
-        return clonedSchema;
-    }
-}

package/dist/z-schema-options.js

@@ -1,99 +0,0 @@
-import { CURRENT_DEFAULT_SCHEMA_VERSION } from './json-schema-versions.js';
-import { shallowClone } from './utils/clone.js';
-import { DEFAULT_MAX_RECURSION_DEPTH, MAX_ASYNC_TIMEOUT } from './utils/constants.js';
-export { DEFAULT_MAX_RECURSION_DEPTH, MAX_ASYNC_TIMEOUT };
-export const defaultOptions = {
-    // default version to validate against
-    version: CURRENT_DEFAULT_SCHEMA_VERSION,
-    // default timeout for all async tasks
-    asyncTimeout: 2000,
-    // force additionalProperties and additionalItems to be defined on "object" and "array" types
-    forceAdditional: false,
-    // assume additionalProperties and additionalItems are defined as "false" where appropriate
-    assumeAdditional: false,
-    // do case insensitive comparison for enums
-    enumCaseInsensitiveComparison: false,
-    // force items to be defined on "array" types
-    forceItems: false,
-    // force minItems to be defined on "array" types
-    forceMinItems: false,
-    // force maxItems to be defined on "array" types
-    forceMaxItems: false,
-    // force minLength to be defined on "string" types
-    forceMinLength: false,
-    // force maxLength to be defined on "string" types
-    forceMaxLength: false,
-    // force properties or patternProperties to be defined on "object" types
-    forceProperties: false,
-    // ignore references that cannot be resolved (remote schemas)
-    ignoreUnresolvableReferences: false,
-    // disallow usage of keywords that this validator can't handle
-    noExtraKeywords: false,
-    // disallow usage of schema's without "type" defined
-    noTypeless: false,
-    // disallow zero length strings in validated objects
-    noEmptyStrings: false,
-    // disallow zero length arrays in validated objects
-    noEmptyArrays: false,
-    // forces "uri" format to be in fully rfc3986 compliant
-    strictUris: false,
-    // turn on some of the above
-    strictMode: false,
-    // report error paths as an array of path segments to get to the offending node
-    reportPathAsArray: false,
-    // stop validation as soon as an error is found
-    breakOnFirstError: false,
-    // check if schema follows best practices and common sense
-    pedanticCheck: false,
-    // ignore unknown formats (do not report them as an error)
-    ignoreUnknownFormats: false,
-    // control format assertion behavior:
-    //   true  - respect vocabulary: for draft 2019-09/2020-12, check meta-schema $vocabulary
-    //           to determine if format is assertion or annotation-only
-    //   false - format is always annotation-only (never asserts)
-    //   null  - legacy behavior: always assert format validation
-    formatAssertions: null,
-    // function to be called on every schema
-    customValidator: null,
-    // maximum recursion depth for deeply nested schema/data traversal (prevents stack overflow)
-    maxRecursionDepth: DEFAULT_MAX_RECURSION_DEPTH,
-};
-export const normalizeOptions = (options) => {
-    let normalized;
-    // options
-    if (typeof options === 'object') {
-        let keys = Object.keys(options);
-        // check that the options are correctly configured
-        for (const key of keys) {
-            if (defaultOptions[key] === undefined) {
-                throw new Error('Unexpected option passed to constructor: ' + key);
-            }
-        }
-        // copy the default options into passed options
-        keys = Object.keys(defaultOptions);
-        for (const key of keys) {
-            if (options[key] === undefined) {
-                options[key] = shallowClone(defaultOptions[key]);
-            }
-        }
-        normalized = options;
-    }
-    else {
-        normalized = shallowClone(defaultOptions);
-    }
-    // Clamp asyncTimeout to prevent resource exhaustion (CWE-400)
-    if (normalized.asyncTimeout != null) {
-        normalized.asyncTimeout = Math.min(Math.max(normalized.asyncTimeout, 0), MAX_ASYNC_TIMEOUT);
-    }
-    if (normalized.strictMode === true) {
-        normalized.forceAdditional = true;
-        normalized.forceItems = true;
-        normalized.forceMaxLength = true;
-        normalized.forceProperties = true;
-        normalized.noExtraKeywords = true;
-        normalized.noTypeless = true;
-        normalized.noEmptyStrings = true;
-        normalized.noEmptyArrays = true;
-    }
-    return normalized;
-};

package/dist/z-schema-reader.js

@@ -1,7 +0,0 @@
-let _schemaReader;
-export function getSchemaReader() {
-    return _schemaReader;
-}
-export function setSchemaReader(schemaReader) {
-    _schemaReader = schemaReader;
-}

package/dist/z-schema-versions.js

@@ -1,110 +0,0 @@
-import { SchemaCache } from './schema-cache.js';
-import { normalizeOptions } from './z-schema-options.js';
-// draft-04
-import _Draft4Schema from './schemas/draft-04-schema.json' with { type: 'json' };
-// draft-06
-import _Draft6Schema from './schemas/draft-06-schema.json' with { type: 'json' };
-// draft-07
-import _Draft7Schema from './schemas/draft-07-schema.json' with { type: 'json' };
-// draft2019-09
-import _Draft201909MetaApplicator from './schemas/draft-2019-09-meta-applicator.json' with { type: 'json' };
-import _Draft201909MetaContent from './schemas/draft-2019-09-meta-content.json' with { type: 'json' };
-import _Draft201909MetaCore from './schemas/draft-2019-09-meta-core.json' with { type: 'json' };
-import _Draft201909MetaFormat from './schemas/draft-2019-09-meta-format.json' with { type: 'json' };
-import _Draft201909MetaMetaData from './schemas/draft-2019-09-meta-meta-data.json' with { type: 'json' };
-import _Draft201909MetaValidation from './schemas/draft-2019-09-meta-validation.json' with { type: 'json' };
-import _Draft201909Schema from './schemas/draft-2019-09-schema.json' with { type: 'json' };
-// draft2020-12
-import _Draft202012MetaApplicator from './schemas/draft-2020-12-meta-applicator.json' with { type: 'json' };
-import _Draft202012MetaContent from './schemas/draft-2020-12-meta-content.json' with { type: 'json' };
-import _Draft202012MetaCore from './schemas/draft-2020-12-meta-core.json' with { type: 'json' };
-import _Draft202012MetaFormatAnnotation from './schemas/draft-2020-12-meta-format-annotation.json' with { type: 'json' };
-import _Draft202012MetaFormatAssertion from './schemas/draft-2020-12-meta-format-assertion.json' with { type: 'json' };
-import _Draft202012MetaMetaData from './schemas/draft-2020-12-meta-meta-data.json' with { type: 'json' };
-import _Draft202012MetaUnevaluated from './schemas/draft-2020-12-meta-unevaluated.json' with { type: 'json' };
-import _Draft202012MetaValidation from './schemas/draft-2020-12-meta-validation.json' with { type: 'json' };
-import _Draft202012Schema from './schemas/draft-2020-12-schema.json' with { type: 'json' };
-// draft-04
-const Draft4Schema = _Draft4Schema;
-// draft-06
-const Draft6Schema = _Draft6Schema;
-// draft-07
-const Draft7Schema = _Draft7Schema;
-// draft2019-09
-const Draft201909Schema = _Draft201909Schema;
-const Draft201909MetaApplicator = _Draft201909MetaApplicator;
-const Draft201909MetaContent = _Draft201909MetaContent;
-const Draft201909MetaCore = _Draft201909MetaCore;
-const Draft201909MetaFormat = _Draft201909MetaFormat;
-const Draft201909MetaMetaData = _Draft201909MetaMetaData;
-const Draft201909MetaValidation = _Draft201909MetaValidation;
-// draft2020-12
-const Draft202012Schema = _Draft202012Schema;
-const Draft202012MetaApplicator = _Draft202012MetaApplicator;
-const Draft202012MetaContent = _Draft202012MetaContent;
-const Draft202012MetaCore = _Draft202012MetaCore;
-const Draft202012MetaFormatAnnotation = _Draft202012MetaFormatAnnotation;
-const Draft202012MetaFormatAssertion = _Draft202012MetaFormatAssertion;
-const Draft202012MetaMetaData = _Draft202012MetaMetaData;
-const Draft202012MetaUnevaluated = _Draft202012MetaUnevaluated;
-const Draft202012MetaValidation = _Draft202012MetaValidation;
-const registerRemoteReference = (uri, schema, validationOptions) => {
-    const preparedSchema = schema;
-    if (!preparedSchema.id) {
-        preparedSchema.id = uri;
-    }
-    if (validationOptions) {
-        preparedSchema.__$validationOptions = normalizeOptions(validationOptions);
-    }
-    SchemaCache.cacheSchemaByUri(uri, preparedSchema);
-};
-// draft-04
-registerRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, { version: 'none' });
-// draft-06
-registerRemoteReference('http://json-schema.org/draft-06/schema', Draft6Schema, { version: 'none' });
-// draft-07
-registerRemoteReference('http://json-schema.org/draft-07/schema', Draft7Schema, { version: 'none' });
-// draft2019-09
-registerRemoteReference('https://json-schema.org/draft/2019-09/schema', Draft201909Schema, { version: 'none' });
-registerRemoteReference('https://json-schema.org/draft/2019-09/meta/applicator', Draft201909MetaApplicator, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2019-09/meta/content', Draft201909MetaContent, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2019-09/meta/core', Draft201909MetaCore, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2019-09/meta/format', Draft201909MetaFormat, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2019-09/meta/meta-data', Draft201909MetaMetaData, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2019-09/meta/validation', Draft201909MetaValidation, {
-    version: 'none',
-});
-// draft2020-12
-registerRemoteReference('https://json-schema.org/draft/2020-12/schema', Draft202012Schema, { version: 'none' });
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/applicator', Draft202012MetaApplicator, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/content', Draft202012MetaContent, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/core', Draft202012MetaCore, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/format-annotation', Draft202012MetaFormatAnnotation, { version: 'none' });
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/format-assertion', Draft202012MetaFormatAssertion, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/meta-data', Draft202012MetaMetaData, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/unevaluated', Draft202012MetaUnevaluated, {
-    version: 'none',
-});
-registerRemoteReference('https://json-schema.org/draft/2020-12/meta/validation', Draft202012MetaValidation, {
-    version: 'none',
-});