z-schema 12.0.4 → 12.1.0

package/dist/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/dist/report.js

@@ -1,265 +0,0 @@
-import { Errors, getValidateError } from './errors.js';
-import { shallowClone } from './utils/clone.js';
-import { MAX_ASYNC_TIMEOUT } from './utils/constants.js';
-import { get } from './utils/json.js';
-import { jsonSymbol, schemaSymbol } from './utils/symbols.js';
-import { isAbsoluteUri } from './utils/uri.js';
-import { isObject } from './utils/what-is.js';
-const ASYNC_TIMEOUT_POLL_MS = 10;
-export class Report {
-    asyncTasks = [];
-    commonErrorMessage;
-    __$recursiveAnchorStack = [];
-    __$dynamicScopeStack = [];
-    __validationResultCache = new Map();
-    errors = [];
-    json;
-    path = [];
-    schemaPath = [];
-    rootSchema;
-    parentReport;
-    options;
-    reportOptions;
-    validateOptions = {};
-    constructor(parentOrOptions, reportOptionsOrValidate, validateOptions) {
-        this.parentReport = parentOrOptions instanceof Report ? parentOrOptions : undefined;
-        this.options = parentOrOptions instanceof Report ? parentOrOptions.options : parentOrOptions || {};
-        if (parentOrOptions instanceof Report) {
-            // subreport
-            this.reportOptions = reportOptionsOrValidate || {};
-            this.validateOptions = validateOptions || parentOrOptions.validateOptions;
-            this.__$recursiveAnchorStack = [...parentOrOptions.__$recursiveAnchorStack];
-            this.__$dynamicScopeStack = [...parentOrOptions.__$dynamicScopeStack];
-            this.__validationResultCache = parentOrOptions.__validationResultCache;
-        }
-        else {
-            // primary
-            this.reportOptions = {};
-            this.validateOptions = reportOptionsOrValidate || {};
-            this.__$recursiveAnchorStack = [];
-            this.__$dynamicScopeStack = [];
-            this.__validationResultCache = new Map();
-        }
-    }
-    isValid() {
-        if (this.asyncTasks.length > 0) {
-            throw new Error("Async tasks pending, can't answer isValid");
-        }
-        return this.errors.length === 0;
-    }
-    addAsyncTask(fn, args, asyncTaskResultProcessFn) {
-        this.asyncTasks.push([fn, args, asyncTaskResultProcessFn]);
-    }
-    /**
-     * Like {@link addAsyncTask}, but automatically saves the current `path` and
-     * restores it around `processFn`.  This eliminates the manual
-     * path-save/restore boilerplate that every async-aware validator would
-     * otherwise need.
-     */
-    addAsyncTaskWithPath(fn, args, processFn) {
-        const pathBefore = shallowClone(this.path);
-        this.asyncTasks.push([
-            fn,
-            args,
-            (result) => {
-                const backup = this.path;
-                this.path = pathBefore;
-                processFn(result);
-                this.path = backup;
-            },
-        ]);
-    }
-    getAncestor(id) {
-        if (!this.parentReport) {
-            return undefined;
-        }
-        if (this.parentReport.getSchemaId() === id) {
-            return this.parentReport;
-        }
-        return this.parentReport.getAncestor(id);
-    }
-    processAsyncTasks(timeout, callback) {
-        const validationTimeout = Math.min(Math.max(timeout || 2000, 0), MAX_ASYNC_TIMEOUT);
-        const timeoutAt = Date.now() + validationTimeout;
-        let tasksCount = this.asyncTasks.length;
-        let timedOut = false;
-        const finish = () => {
-            setTimeout(() => {
-                const valid = this.errors.length === 0;
-                const err = valid ? undefined : getValidateError({ details: this.errors });
-                callback(err, valid);
-            }, 0);
-        };
-        const respond = (asyncTaskResultProcessFn) => (asyncTaskResult) => {
-            if (timedOut) {
-                return;
-            }
-            asyncTaskResultProcessFn(asyncTaskResult);
-            if (--tasksCount === 0) {
-                finish();
-            }
-        };
-        // finish if tasks are completed or there are any errors and breaking on first error was requested
-        if (tasksCount === 0 || (this.errors.length > 0 && this.options.breakOnFirstError)) {
-            finish();
-            return;
-        }
-        for (let i = 0; i < this.asyncTasks.length; i++) {
-            const [fn, fnArgs, processFn] = this.asyncTasks[i];
-            const respondCallback = respond(processFn);
-            fn(...fnArgs, respondCallback);
-        }
-        const checkTimeout = () => {
-            if (timedOut || tasksCount <= 0) {
-                return;
-            }
-            if (Date.now() >= timeoutAt) {
-                timedOut = true;
-                this.addError('ASYNC_TIMEOUT', [tasksCount, validationTimeout]);
-                callback(getValidateError({ details: this.errors }), false);
-                return;
-            }
-            setTimeout(checkTimeout, ASYNC_TIMEOUT_POLL_MS);
-        };
-        setTimeout(checkTimeout, ASYNC_TIMEOUT_POLL_MS);
-    }
-    getPath(returnPathAsString) {
-        let path = [];
-        if (this.parentReport) {
-            path = path.concat(this.parentReport.path);
-        }
-        path = path.concat(this.path);
-        if (returnPathAsString !== true) {
-            // Sanitize the path segments (http://tools.ietf.org/html/rfc6901#section-4)
-            return ('#/' +
-                path
-                    .map(function (segment) {
-                    segment = segment.toString();
-                    if (isAbsoluteUri(segment)) {
-                        return 'uri(' + segment + ')';
-                    }
-                    return segment.replace(/~/g, '~0').replace(/\//g, '~1');
-                })
-                    .join('/'));
-        }
-        return path;
-    }
-    getSchemaPath() {
-        let schemaPath = [];
-        if (this.parentReport) {
-            schemaPath = schemaPath.concat(this.parentReport.schemaPath);
-        }
-        schemaPath = schemaPath.concat(this.schemaPath);
-        return schemaPath;
-    }
-    getSchemaId() {
-        if (!this.rootSchema) {
-            return undefined;
-        }
-        // get the error path as an array
-        let path = [];
-        if (this.parentReport) {
-            path = path.concat(this.parentReport.path);
-        }
-        path = path.concat(this.path);
-        // try to find id in the error path
-        while (path.length > 0) {
-            const obj = get(this.rootSchema, path);
-            if (obj && obj.id) {
-                return obj.id;
-            }
-            path.pop();
-        }
-        // return id of the root
-        return this.rootSchema.id;
-    }
-    hasError(errCode, errParams) {
-        for (let idx = 0; idx < this.errors.length; idx++) {
-            if (this.errors[idx].code === errCode) {
-                // assume match
-                let match = true;
-                // check the params too
-                for (let idx2 = 0; idx2 < this.errors[idx].params.length; idx2++) {
-                    if (this.errors[idx].params[idx2] !== errParams[idx2]) {
-                        match = false;
-                    }
-                }
-                // if match, return true
-                if (match) {
-                    return match;
-                }
-            }
-        }
-        return false;
-    }
-    addError(errCode, errParams, subReports, schema, keyword) {
-        if (!errCode) {
-            throw new Error('No errorCode passed into addError()');
-        }
-        this.addCustomError(errCode, Errors[errCode], errParams, subReports, schema, keyword);
-    }
-    // this returns the root object being validated (the one passed into validator.validate)
-    getJson() {
-        if (this.json) {
-            return this.json;
-        }
-        if (this.parentReport) {
-            return this.parentReport.getJson();
-        }
-        return undefined;
-    }
-    addCustomError(errorCode, errorMessage, params, subReports, schema, keyword) {
-        if (typeof this.reportOptions.maxErrors === 'number' && this.errors.length >= this.reportOptions.maxErrors) {
-            return;
-        }
-        if (!errorMessage) {
-            throw new Error('No errorMessage known for code ' + errorCode);
-        }
-        params = params || [];
-        for (let idx = 0; idx < params.length; idx++) {
-            const param = params[idx] === null || isObject(params[idx]) ? JSON.stringify(params[idx]) : params[idx];
-            errorMessage = errorMessage.replace('{' + idx + '}', param.toString());
-        }
-        const err = {
-            code: errorCode,
-            params: params,
-            message: errorMessage,
-            path: this.getPath(this.options.reportPathAsArray),
-            schemaPath: this.getSchemaPath(),
-            schemaId: this.getSchemaId(),
-            keyword: keyword,
-        };
-        err[schemaSymbol] = schema;
-        err[jsonSymbol] = this.getJson();
-        if (schema && typeof schema === 'string') {
-            err.description = schema;
-        }
-        else if (schema && typeof schema === 'object') {
-            if (schema.title) {
-                err.title = schema.title;
-            }
-            if (schema.description) {
-                err.description = schema.description;
-            }
-        }
-        if (subReports != null) {
-            if (!Array.isArray(subReports)) {
-                subReports = [subReports];
-            }
-            err.inner = [];
-            for (const subReport of subReports) {
-                for (const error of subReport.errors) {
-                    err.inner.push(error);
-                }
-            }
-            if (err.inner.length === 0) {
-                err.inner = undefined;
-            }
-        }
-        // Check if this error code should be excluded
-        if (Array.isArray(this.validateOptions.excludeErrors) && this.validateOptions.excludeErrors.includes(errorCode)) {
-            return;
-        }
-        this.errors.push(err);
-    }
-}

package/dist/schema-cache.js

@@ -1,211 +0,0 @@
-import { findId, getId } from './json-schema.js';
-import { Report } from './report.js';
-import { deepClone } from './utils/clone.js';
-import { decodeJSONPointer } from './utils/json.js';
-import { getQueryPath, getRemotePath, isAbsoluteUri } from './utils/uri.js';
-import { normalizeOptions } from './z-schema-options.js';
-// Normalize a URI into a cache key, rejecting keys that could pollute Object.prototype.
-function getSafeRemotePath(uri) {
-    const remotePath = getRemotePath(uri);
-    if (!remotePath) {
-        return undefined;
-    }
-    if (remotePath === '__proto__' || remotePath === 'constructor' || remotePath === 'prototype') {
-        return undefined;
-    }
-    return remotePath;
-}
-const getEffectiveId = (schema) => {
-    let id = getId(schema);
-    if ((!id || !isAbsoluteUri(id)) && typeof schema.id === 'string' && isAbsoluteUri(schema.id)) {
-        id = schema.id;
-    }
-    return id;
-};
-/**
- * Shared logic for registering a remote reference schema.
- * Used by both the static `ZSchema.setRemoteReference()` (global cache) and
- * the instance `validator.setRemoteReference()` (instance cache).
- */
-export function prepareRemoteSchema(schema, uri, validationOptions, maxCloneDepth) {
-    let _schema;
-    if (typeof schema === 'string') {
-        _schema = JSON.parse(schema);
-    }
-    else {
-        _schema = deepClone(schema, maxCloneDepth);
-    }
-    if (!_schema.id) {
-        _schema.id = uri;
-    }
-    if (validationOptions) {
-        _schema.__$validationOptions = normalizeOptions(validationOptions);
-    }
-    return _schema;
-}
-export class SchemaCache {
-    validator;
-    static global_cache = Object.create(null);
-    cache = Object.create(null);
-    constructor(validator) {
-        this.validator = validator;
-    }
-    static cacheSchemaByUri(uri, schema) {
-        const remotePath = getSafeRemotePath(uri);
-        if (remotePath) {
-            this.global_cache[remotePath] = schema;
-        }
-    }
-    cacheSchemaByUri(uri, schema) {
-        const remotePath = getSafeRemotePath(uri);
-        if (remotePath) {
-            this.cache[remotePath] = schema;
-        }
-    }
-    removeFromCacheByUri(uri) {
-        const remotePath = getSafeRemotePath(uri);
-        if (remotePath) {
-            delete this.cache[remotePath];
-        }
-    }
-    checkCacheForUri(uri) {
-        const remotePath = getSafeRemotePath(uri);
-        return remotePath ? this.cache[remotePath] != null : false;
-    }
-    getSchema(report, refOrSchema) {
-        if (Array.isArray(refOrSchema)) {
-            return refOrSchema.map((i) => this.getSchema(report, i));
-        }
-        if (typeof refOrSchema === 'string') {
-            // ref input
-            return this.getSchemaByUri(report, refOrSchema);
-        }
-        // no caching done on this, but we need to return a clone so we can mutate it
-        return deepClone(refOrSchema, this.validator.options.maxRecursionDepth);
-    }
-    fromCache(path) {
-        if (path === '__proto__' || path === 'constructor' || path === 'prototype') {
-            return undefined;
-        }
-        let found = this.cache[path];
-        if (found) {
-            return found;
-        }
-        found = SchemaCache.global_cache[path];
-        if (found) {
-            // Clone once from global cache into instance cache so subsequent lookups
-            // never deep-clone again for the same path on this instance.
-            const clone = deepClone(found, this.validator.options.maxRecursionDepth);
-            if (!clone.id || (!isAbsoluteUri(clone.id) && isAbsoluteUri(path))) {
-                clone.id = path;
-            }
-            this.cache[path] = clone;
-            return clone;
-        }
-        return undefined;
-    }
-    getSchemaByUri(report, uri, root) {
-        if (root && !isAbsoluteUri(uri)) {
-            const rootId = getEffectiveId(root);
-            if (rootId && isAbsoluteUri(rootId)) {
-                const hashIndex = rootId.indexOf('#');
-                const rootBase = hashIndex === -1 ? rootId : rootId.slice(0, hashIndex);
-                try {
-                    uri = new URL(uri, rootBase).toString();
-                }
-                catch {
-                    // keep original uri when URL construction fails
-                }
-            }
-        }
-        const remotePath = getSafeRemotePath(uri);
-        const queryPath = getQueryPath(uri);
-        let result;
-        let resolvedFromAncestor = false;
-        if (remotePath) {
-            const ancestorReport = report.getAncestor(remotePath);
-            if (ancestorReport?.rootSchema) {
-                result = ancestorReport.rootSchema;
-                resolvedFromAncestor = true;
-            }
-        }
-        if (!result && root && remotePath) {
-            const rootId = getEffectiveId(root);
-            const rootRemotePath = rootId ? getRemotePath(rootId) : undefined;
-            if (rootRemotePath && rootRemotePath === remotePath) {
-                result = root;
-            }
-        }
-        if (!result) {
-            result = remotePath ? this.fromCache(remotePath) : root;
-        }
-        if (result && remotePath && isAbsoluteUri(remotePath) && (!result.id || !isAbsoluteUri(result.id))) {
-            result.id = remotePath;
-        }
-        if (result && remotePath) {
-            // we need to avoid compiling schemas in a recursive loop
-            const compileRemote = result !== root && !resolvedFromAncestor;
-            // now we need to compile and validate resolved schema (in case it's not already)
-            if (compileRemote) {
-                report.path.push(remotePath);
-                let remoteReport;
-                let usesAncestorReport = false;
-                const anscestorReport = result.id ? report.getAncestor(result.id) : undefined;
-                if (anscestorReport) {
-                    remoteReport = anscestorReport;
-                    usesAncestorReport = true;
-                }
-                else {
-                    remoteReport = new Report(report);
-                    const noCache = result.id && isAbsoluteUri(result.id) ? false : true;
-                    if (this.validator.sc.compileSchema(remoteReport, result, { noCache })) {
-                        const savedOptions = this.validator.options;
-                        try {
-                            // If custom validationOptions were provided to setRemoteReference(),
-                            // use them instead of the default options
-                            this.validator.options = result.__$validationOptions || this.validator.options;
-                            const parentSchemaUri = typeof result.$schema === 'string' ? getRemotePath(result.$schema) : undefined;
-                            const currentSchemaUri = report.getSchemaId();
-                            const parentSchemaIsCompiling = !!parentSchemaUri &&
-                                parentSchemaUri.length > 0 &&
-                                (currentSchemaUri === parentSchemaUri || !!report.getAncestor(parentSchemaUri));
-                            if (!parentSchemaIsCompiling) {
-                                this.validator.sv.validateSchema(remoteReport, result);
-                            }
-                        }
-                        finally {
-                            this.validator.options = savedOptions;
-                        }
-                    }
-                }
-                const remoteReportIsValid = usesAncestorReport ? true : remoteReport.isValid();
-                if (!remoteReportIsValid) {
-                    report.addError('REMOTE_NOT_VALID', [uri], remoteReport);
-                }
-                report.path.pop();
-                if (!remoteReportIsValid) {
-                    return undefined;
-                }
-            }
-        }
-        const resourceRoot = result;
-        if (result && queryPath) {
-            const parts = queryPath.split('/');
-            for (let idx = 0, lim = parts.length; result && idx < lim; idx++) {
-                const key = decodeJSONPointer(parts[idx]);
-                if (idx === 0) {
-                    // it's an id
-                    result = findId(result, key, remotePath, remotePath, this.validator.options.maxRecursionDepth);
-                }
-                else {
-                    // it's a path behind id
-                    result = result[key];
-                }
-            }
-        }
-        if (result && typeof result === 'object' && resourceRoot && typeof resourceRoot === 'object') {
-            result.__$resourceRoot = resourceRoot;
-        }
-        return result;
-    }
-}