z-schema 7.0.0 → 7.0.6

package/dist/Utils.js

@@ -1,266 +0,0 @@
-export const jsonSymbol = Symbol.for('z-schema/json');
-export const schemaSymbol = Symbol.for('z-schema/schema');
-/**
- * @param {object} obj
- *
- * @returns {string[]}
- */
-export function sortedKeys(obj) {
-    return Object.keys(obj).sort();
-}
-/**
- *
- * @param {string} uri
- *
- * @returns {boolean}
- */
-export function isAbsoluteUri(uri) {
-    return /^https?:\/\//.test(uri);
-}
-/**
- *
- * @param {string} uri
- *
- * @returns {boolean}
- */
-export function isRelativeUri(uri) {
-    // relative URIs that end with a hash sign, issue #56
-    return /.+#/.test(uri);
-}
-export function whatIs(what) {
-    const to = typeof what;
-    if (to === 'object') {
-        if (what === null) {
-            return 'null';
-        }
-        if (Array.isArray(what)) {
-            return 'array';
-        }
-        return 'object'; // typeof what === 'object' && what === Object(what) && !Array.isArray(what);
-    }
-    if (to === 'number') {
-        if (Number.isFinite(what)) {
-            if (what % 1 === 0) {
-                return 'integer';
-            }
-            else {
-                return 'number';
-            }
-        }
-        if (Number.isNaN(what)) {
-            return 'not-a-number';
-        }
-        return 'unknown-number';
-    }
-    return to; // undefined, boolean, string, function
-}
-/**
- *
- * @param {*} json1
- * @param {*} json2
- * @param {*} [options]
- *
- * @returns {boolean}
- */
-export function areEqual(json1, json2, options) {
-    options = options || {};
-    const caseInsensitiveComparison = options.caseInsensitiveComparison || false;
-    // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
-    // Two JSON values are said to be equal if and only if:
-    // both are nulls; or
-    // both are booleans, and have the same value; or
-    // both are strings, and have the same value; or
-    // both are numbers, and have the same mathematical value; or
-    if (json1 === json2) {
-        return true;
-    }
-    if (caseInsensitiveComparison === true &&
-        typeof json1 === 'string' &&
-        typeof json2 === 'string' &&
-        json1.toUpperCase() === json2.toUpperCase()) {
-        return true;
-    }
-    let i, len;
-    // both are arrays, and:
-    if (Array.isArray(json1) && Array.isArray(json2)) {
-        // have the same number of items; and
-        if (json1.length !== json2.length) {
-            return false;
-        }
-        // items at the same index are equal according to this definition; or
-        len = json1.length;
-        for (i = 0; i < len; i++) {
-            if (!areEqual(json1[i], json2[i], { caseInsensitiveComparison: caseInsensitiveComparison })) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // both are objects, and:
-    if (whatIs(json1) === 'object' && whatIs(json2) === 'object') {
-        // have the same set of property names; and
-        const keys1 = sortedKeys(json1);
-        const keys2 = sortedKeys(json2);
-        if (!areEqual(keys1, keys2, { caseInsensitiveComparison: caseInsensitiveComparison })) {
-            return false;
-        }
-        // values for a same property name are equal according to this definition.
-        len = keys1.length;
-        for (i = 0; i < len; i++) {
-            if (!areEqual(json1[keys1[i]], json2[keys1[i]], { caseInsensitiveComparison: caseInsensitiveComparison })) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-}
-/**
- *
- * @param {*[]} arr
- * @param {number[]} [indexes]
- *
- * @returns {boolean}
- */
-export function isUniqueArray(arr, indexes) {
-    let i;
-    let j;
-    const l = arr.length;
-    for (i = 0; i < l; i++) {
-        for (j = i + 1; j < l; j++) {
-            if (areEqual(arr[i], arr[j])) {
-                if (indexes) {
-                    indexes.push(i, j);
-                }
-                return false;
-            }
-        }
-    }
-    return true;
-}
-/**
- *
- * @param {*} bigSet
- * @param {*} subSet
- *
- * @returns {*[]}
- */
-export function difference(bigSet, subSet) {
-    const arr = [];
-    let idx = bigSet.length;
-    while (idx--) {
-        if (subSet.indexOf(bigSet[idx]) === -1) {
-            arr.push(bigSet[idx]);
-        }
-    }
-    return arr;
-}
-// NOT a deep version of clone
-export function clone(src) {
-    if (typeof src === 'undefined') {
-        return void 0;
-    }
-    if (typeof src !== 'object' || src === null) {
-        return src;
-    }
-    let res, idx;
-    if (Array.isArray(src)) {
-        res = [];
-        idx = src.length;
-        while (idx--) {
-            res[idx] = src[idx];
-        }
-    }
-    else {
-        res = {};
-        const keys = Object.keys(src);
-        idx = keys.length;
-        while (idx--) {
-            const key = keys[idx];
-            res[key] = src[key];
-        }
-    }
-    return res;
-}
-export function cloneDeep(src) {
-    let vidx = 0;
-    const visited = new Map();
-    const cloned = [];
-    function cloneDeepInner(src) {
-        if (typeof src !== 'object' || src === null) {
-            return src;
-        }
-        let res;
-        let idx;
-        const cidx = visited.get(src);
-        if (cidx !== undefined) {
-            return cloned[cidx];
-        }
-        visited.set(src, vidx++);
-        if (Array.isArray(src)) {
-            res = [];
-            cloned.push(res);
-            idx = src.length;
-            while (idx--) {
-                res[idx] = cloneDeepInner(src[idx]);
-            }
-        }
-        else {
-            res = {};
-            cloned.push(res);
-            const keys = Object.keys(src);
-            idx = keys.length;
-            while (idx--) {
-                const key = keys[idx];
-                res[key] = cloneDeepInner(src[key]);
-            }
-        }
-        return res;
-    }
-    return cloneDeepInner(src);
-}
-/*
-  following function comes from punycode.js library
-  see: https://github.com/bestiejs/punycode.js
-*/
-/**
- * Creates an array containing the numeric code points of each Unicode
- * character in the string. While JavaScript uses UCS-2 internally,
- * this function will convert a pair of surrogate halves (each of which
- * UCS-2 exposes as separate characters) into a single code point,
- * matching UTF-16.
- * @see `punycode.ucs2.encode`
- * @see <https://mathiasbynens.be/notes/javascript-encoding>
- * @memberOf punycode.ucs2
- * @name decode
- * @param {String} string The Unicode input string (UCS-2).
- * @returns {Array} The new array of code points.
- */
-export function ucs2decode(string) {
-    const output = [];
-    let counter = 0;
-    const length = string.length;
-    let value;
-    let extra;
-    while (counter < length) {
-        value = string.charCodeAt(counter++);
-        if (value >= 0xd800 && value <= 0xdbff && counter < length) {
-            // high surrogate, and there is a next character
-            extra = string.charCodeAt(counter++);
-            if ((extra & 0xfc00) == 0xdc00) {
-                // low surrogate
-                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
-            }
-            else {
-                // unmatched surrogate; only append this code unit, in case the next
-                // code unit is the high surrogate of a surrogate pair
-                output.push(value);
-                counter--;
-            }
-        }
-        else {
-            output.push(value);
-        }
-    }
-    return output;
-}

package/dist/types/FormatValidators.d.ts

@@ -1,12 +0,0 @@
-export declare const FormatValidators: {
-    date: (date: any) => boolean;
-    'date-time': (dateTime: any) => boolean;
-    email: (email: any) => any;
-    hostname: (hostname: any) => boolean;
-    'host-name': (hostname: any) => any;
-    ipv4: (ipv4: any) => any;
-    ipv6: (ipv6: any) => any;
-    regex: (str: any) => boolean;
-    uri: (args_0: string) => any;
-    'strict-uri': (uri: any) => any;
-};

package/dist/types/JsonValidation.d.ts

@@ -1,37 +0,0 @@
-export declare const JsonValidators: {
-    multipleOf: (report: any, schema: any, json: any) => void;
-    maximum: (report: any, schema: any, json: any) => void;
-    exclusiveMaximum: () => void;
-    minimum: (report: any, schema: any, json: any) => void;
-    exclusiveMinimum: () => void;
-    maxLength: (report: any, schema: any, json: any) => void;
-    minLength: (report: any, schema: any, json: any) => void;
-    pattern: (report: any, schema: any, json: any) => void;
-    additionalItems: (report: any, schema: any, json: any) => void;
-    items: () => void;
-    maxItems: (report: any, schema: any, json: any) => void;
-    minItems: (report: any, schema: any, json: any) => void;
-    uniqueItems: (report: any, schema: any, json: any) => void;
-    maxProperties: (report: any, schema: any, json: any) => void;
-    minProperties: (report: any, schema: any, json: any) => void;
-    required: (report: any, schema: any, json: any) => void;
-    additionalProperties: (report: any, schema: any, json: any) => any;
-    patternProperties: (report: any, schema: any, json: any) => any;
-    properties: (report: any, schema: any, json: any) => void;
-    dependencies: (report: any, schema: any, json: any) => void;
-    enum: (report: any, schema: any, json: any) => void;
-    type: (report: any, schema: any, json: any) => void;
-    allOf: (report: any, schema: any, json: any) => void;
-    anyOf: (report: any, schema: any, json: any) => void;
-    oneOf: (report: any, schema: any, json: any) => void;
-    not: (report: any, schema: any, json: any) => void;
-    definitions: () => void;
-    format: (report: any, schema: any, json: any) => void;
-};
-/**
- *
- * @param {Report} report
- * @param {*} schema
- * @param {*} json
- */
-export declare function validate(report: any, schema: any, json: any): boolean;

package/dist/types/SchemaCache.d.ts

@@ -1,26 +0,0 @@
-export declare function getRemotePath(uri: any): any;
-/**
- *
- * @param {*} uri
- * @param {*} schema
- *
- * @returns {void}
- */
-export declare function cacheSchemaByUri(uri: any, schema: any): void;
-/**
- *
- * @param {*} uri
- *
- * @returns {void}
- */
-export declare function removeFromCacheByUri(uri: any): void;
-/**
- *
- * @param {*} uri
- *
- * @returns {boolean}
- */
-export declare function checkCacheForUri(uri: any): boolean;
-export declare function getSchema(report: any, schema: any): any;
-export declare function getSchemaByReference(report: any, key: any): any;
-export declare function getSchemaByUri(report: any, uri: any, root: any): any;

package/dist/types/SchemaCompilation.d.ts

@@ -1 +0,0 @@
-export declare function compileSchema(report: any, schema: any): any;

package/dist/types/SchemaValidation.d.ts

@@ -1,6 +0,0 @@
-/**
- *
- * @param {Report} report
- * @param {*} schema
- */
-export declare function validateSchema(report: any, schema: any): any;

package/dist/types/Utils.d.ts

@@ -1,64 +0,0 @@
-export declare const jsonSymbol: unique symbol;
-export declare const schemaSymbol: unique symbol;
-/**
- * @param {object} obj
- *
- * @returns {string[]}
- */
-export declare function sortedKeys(obj: any): string[];
-/**
- *
- * @param {string} uri
- *
- * @returns {boolean}
- */
-export declare function isAbsoluteUri(uri: any): boolean;
-/**
- *
- * @param {string} uri
- *
- * @returns {boolean}
- */
-export declare function isRelativeUri(uri: any): boolean;
-export declare function whatIs(what: any): "string" | "bigint" | "boolean" | "symbol" | "undefined" | "function" | "object" | "null" | "array" | "integer" | "number" | "not-a-number" | "unknown-number";
-/**
- *
- * @param {*} json1
- * @param {*} json2
- * @param {*} [options]
- *
- * @returns {boolean}
- */
-export declare function areEqual(json1: any, json2: any, options?: any): boolean;
-/**
- *
- * @param {*[]} arr
- * @param {number[]} [indexes]
- *
- * @returns {boolean}
- */
-export declare function isUniqueArray(arr: any, indexes?: any): boolean;
-/**
- *
- * @param {*} bigSet
- * @param {*} subSet
- *
- * @returns {*[]}
- */
-export declare function difference(bigSet: any, subSet: any): any[];
-export declare function clone(src: any): any;
-export declare function cloneDeep(src: any): any;
-/**
- * Creates an array containing the numeric code points of each Unicode
- * character in the string. While JavaScript uses UCS-2 internally,
- * this function will convert a pair of surrogate halves (each of which
- * UCS-2 exposes as separate characters) into a single code point,
- * matching UTF-16.
- * @see `punycode.ucs2.encode`
- * @see <https://mathiasbynens.be/notes/javascript-encoding>
- * @memberOf punycode.ucs2
- * @name decode
- * @param {String} string The Unicode input string (UCS-2).
- * @returns {Array} The new array of code points.
- */
-export declare function ucs2decode(string: any): any[];

package/dist/types/ZSchema.d.ts

@@ -1,97 +0,0 @@
-import { Report, SchemaError, SchemaErrorDetail } from './Report.js';
-import type { Errors } from './Errors.js';
-export interface ZSchemaOptions {
-    asyncTimeout?: number;
-    forceAdditional?: boolean;
-    assumeAdditional?: boolean;
-    forceItems?: boolean;
-    forceMinItems?: boolean;
-    forceMaxItems?: boolean;
-    forceMinLength?: boolean;
-    forceMaxLength?: boolean;
-    forceProperties?: boolean;
-    ignoreUnresolvableReferences?: boolean;
-    noExtraKeywords?: boolean;
-    noTypeless?: boolean;
-    noEmptyStrings?: boolean;
-    noEmptyArrays?: boolean;
-    strictUris?: boolean;
-    strictMode?: boolean;
-    reportPathAsArray?: boolean;
-    breakOnFirstError?: boolean;
-    pedanticCheck?: boolean;
-    ignoreUnknownFormats?: boolean;
-    customValidator?: (report: Report, schema: unknown, json: unknown) => void;
-}
-export interface ValidateOptions {
-    schemaPath?: string;
-    includeErrors?: Array<keyof typeof Errors>;
-}
-type ValidateCallback = (e: Error, valid: boolean) => void;
-type SchemaReader = (uri: string) => unknown;
-export declare class ZSchema {
-    lastReport: Report | undefined;
-    /**
-     * Register a custom format.
-     *
-     * @param name - name of the custom format
-     * @param validatorFunction - custom format validator function.
-     *   Returns `true` if `value` matches the custom format.
-     */
-    static registerFormat(formatName: string, validatorFunction: (value: unknown) => boolean): void;
-    /**
-     * Unregister a format.
-     *
-     * @param name - name of the custom format
-     */
-    static unregisterFormat(name: string): void;
-    /**
-     * Get the list of all registered formats.
-     *
-     * Both the names of the burned-in formats and the custom format names are
-     * returned by this function.
-     *
-     * @returns {string[]} the list of all registered format names.
-     */
-    static getRegisteredFormats(): string[];
-    static getDefaultOptions(): ZSchemaOptions;
-    private cache;
-    private referenceCache;
-    private validateOptions;
-    options: ZSchemaOptions;
-    constructor(options?: ZSchemaOptions);
-    /**
-     * @param schema - JSON object representing schema
-     * @returns {boolean} true if schema is valid.
-     */
-    validateSchema(schema: unknown): boolean;
-    /**
-     * @param json - either a JSON string or a parsed JSON object
-     * @param schema - the JSON object representing the schema
-     * @returns true if json matches schema
-     */
-    validate(json: any, schema: any, options?: ValidateOptions, callback?: ValidateCallback): boolean;
-    validate(json: any, schema: any, callback?: any): boolean;
-    validate(json: any, schema: any): boolean;
-    /**
-     * Returns an Error object for the most recent failed validation, or null if the validation was successful.
-     */
-    getLastError(): SchemaError;
-    /**
-     * Returns the error details for the most recent validation, or undefined if the validation was successful.
-     * This is the same list as the SchemaError.details property.
-     */
-    getLastErrors(): SchemaErrorDetail[];
-    setRemoteReference(uri: any, schema: any, validationOptions: any): void;
-    compileSchema(schema: any): boolean;
-    getMissingReferences(arr?: any): any[];
-    getMissingRemoteReferences(): any[];
-    getResolvedSchema(schema: any): any;
-    static schemaReader: SchemaReader;
-    setSchemaReader(schemaReader: any): void;
-    getSchemaReader(): SchemaReader;
-    static setSchemaReader(schemaReader: any): void;
-    static schemaSymbol: symbol;
-    static jsonSymbol: symbol;
-}
-export {};

package/src/SchemaCache.ts

@@ -1,189 +0,0 @@
-import isequal from 'lodash.isequal';
-import { Report } from './Report.js';
-import { compileSchema } from './SchemaCompilation.js';
-import * as SchemaValidation from './SchemaValidation.js';
-import * as Utils from './Utils.js';
-
-function decodeJSONPointer(str) {
-  // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
-  return decodeURIComponent(str).replace(/~[0-1]/g, function (x) {
-    return x === '~1' ? '/' : '~';
-  });
-}
-
-export function getRemotePath(uri) {
-  const io = uri.indexOf('#');
-  return io === -1 ? uri : uri.slice(0, io);
-}
-
-function getQueryPath(uri) {
-  const io = uri.indexOf('#');
-  const res = io === -1 ? undefined : uri.slice(io + 1);
-  // WARN: do not slice slash, #/ means take root and go down from it
-  // if (res && res[0] === "/") { res = res.slice(1); }
-  return res;
-}
-
-function findId(schema, id) {
-  // process only arrays and objects
-  if (typeof schema !== 'object' || schema === null) {
-    return;
-  }
-
-  // no id means root so return itself
-  if (!id) {
-    return schema;
-  }
-
-  if (schema.id) {
-    if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
-      return schema;
-    }
-  }
-
-  let idx, result;
-  if (Array.isArray(schema)) {
-    idx = schema.length;
-    while (idx--) {
-      result = findId(schema[idx], id);
-      if (result) {
-        return result;
-      }
-    }
-  } else {
-    const keys = Object.keys(schema);
-    idx = keys.length;
-    while (idx--) {
-      const k = keys[idx];
-      if (k.indexOf('__$') === 0) {
-        continue;
-      }
-      result = findId(schema[k], id);
-      if (result) {
-        return result;
-      }
-    }
-  }
-}
-
-/**
- *
- * @param {*} uri
- * @param {*} schema
- *
- * @returns {void}
- */
-export function cacheSchemaByUri(uri, schema) {
-  const remotePath = getRemotePath(uri);
-  if (remotePath) {
-    this.cache[remotePath] = schema;
-  }
-}
-
-/**
- *
- * @param {*} uri
- *
- * @returns {void}
- */
-export function removeFromCacheByUri(uri) {
-  const remotePath = getRemotePath(uri);
-  if (remotePath) {
-    delete this.cache[remotePath];
-  }
-}
-
-/**
- *
- * @param {*} uri
- *
- * @returns {boolean}
- */
-export function checkCacheForUri(uri) {
-  const remotePath = getRemotePath(uri);
-  return remotePath ? this.cache[remotePath] != null : false;
-}
-
-export function getSchema(report, schema) {
-  if (typeof schema === 'object') {
-    schema = getSchemaByReference.call(this, report, schema);
-  }
-  if (typeof schema === 'string') {
-    schema = getSchemaByUri.call(this, report, schema);
-  }
-  return schema;
-}
-
-export function getSchemaByReference(report, key) {
-  let i = this.referenceCache.length;
-  while (i--) {
-    if (isequal(this.referenceCache[i][0], key)) {
-      return this.referenceCache[i][1];
-    }
-  }
-  // not found
-  const schema = Utils.cloneDeep(key);
-  this.referenceCache.push([key, schema]);
-  return schema;
-}
-
-export function getSchemaByUri(report, uri, root) {
-  const remotePath = getRemotePath(uri);
-  const queryPath = getQueryPath(uri);
-  let result = remotePath ? this.cache[remotePath] : root;
-
-  if (result && remotePath) {
-    // we need to avoid compiling schemas in a recursive loop
-    const compileRemote = result !== root;
-    // now we need to compile and validate resolved schema (in case it's not already)
-    if (compileRemote) {
-      report.path.push(remotePath);
-
-      let remoteReport;
-
-      const anscestorReport = report.getAncestor(result.id);
-      if (anscestorReport) {
-        remoteReport = anscestorReport;
-      } else {
-        remoteReport = new Report(report);
-        if (compileSchema.call(this, remoteReport, result)) {
-          const savedOptions = this.options;
-          try {
-            // If custom validationOptions were provided to setRemoteReference(),
-            // use them instead of the default options
-            this.options = result.__$validationOptions || this.options;
-            SchemaValidation.validateSchema.call(this, remoteReport, result);
-          } finally {
-            this.options = savedOptions;
-          }
-        }
-      }
-      const remoteReportIsValid = remoteReport.isValid();
-      if (!remoteReportIsValid) {
-        report.addError('REMOTE_NOT_VALID', [uri], remoteReport);
-      }
-
-      report.path.pop();
-
-      if (!remoteReportIsValid) {
-        return undefined;
-      }
-    }
-  }
-
-  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);
-      } else {
-        // it's a path behind id
-        result = result[key];
-      }
-    }
-  }
-
-  return result;
-}