z-schema 7.0.0 → 7.0.6

package/dist/types/{Report.d.ts → report.d.ts}

@@ -1,4 +1,6 @@
-import { ZSchemaOptions } from './ZSchema.js';
+import { ErrorCode, ErrorParam } from './errors.js';
+import { ValidateCallback, ZSchemaOptions } from './z-schema.js';
+import { JsonSchema, JsonSchemaInternal } from './json-schema.js';
 export interface SchemaError extends Error {
     /**
      * Implements the Error.name contract.  The value is always "z-schema validation error".
@@ -29,12 +31,12 @@ export interface SchemaErrorDetail {
      * Format parameters that can be used to format a custom error message.
      * Example: ["string","array"]
      */
-    params: Array<string>;
+    params: ErrorParam[];
     /**
      * A JSON path indicating the location of the error.
      * Example: "#/projects/1"
      */
-    path: string | string[];
+    path: string | Array<string | number>;
     /**
      * The schema rule description, which is included for certain errors where
      * this information is useful (e.g. to describe a constraint).
@@ -58,30 +60,27 @@ type TaskFnArgs = Parameters<TaskFn>;
 type TaskProcessFn = (result: ReturnType<TaskFn>) => void;
 type AsyncTask = [TaskFn, TaskFnArgs, TaskProcessFn];
 export declare class Report {
+    asyncTasks: AsyncTask[];
+    commonErrorMessage?: string;
     errors: SchemaErrorDetail[];
+    json?: unknown;
+    path: Array<number | string>;
+    rootSchema?: JsonSchemaInternal;
     parentReport?: Report;
     options: ZSchemaOptions;
     reportOptions: ReportOptions;
-    path: string[];
-    asyncTasks: AsyncTask[];
-    rootSchema?: {
-        id?: string;
-    };
-    commonErrorMessage?: string;
-    json?: unknown;
-    constructor(parentOrOptions: any, reportOptions?: any);
+    constructor(zschemaOptions: ZSchemaOptions);
+    constructor(parentReport: Report);
+    constructor(parentReport: Report, reportOptions: ReportOptions);
     isValid(): boolean;
-    addAsyncTask(fn: any, args: any, asyncTaskResultProcessFn: any): void;
-    getAncestor(id: any): any;
-    processAsyncTasks(timeout: any, callback: any): void;
-    getPath(returnPathAsString: any): string | any[];
-    getSchemaId(): any;
-    hasError(errorCode: any, params: any): boolean;
-    addError(errorCode: any, params: any, subReports?: any, schema?: any): void;
-    getJson(): any;
-    addCustomError(errorCode: string, errorMessage: string, params: string[], subReports?: Report[] | Report, schema?: {
-        title?: string;
-        description?: string;
-    }): void;
+    addAsyncTask<FV, FN extends (...args: any[]) => FV>(fn: FN, args: Parameters<FN>, asyncTaskResultProcessFn: (result: ReturnType<FN>) => void): void;
+    getAncestor(id: string): Report | undefined;
+    processAsyncTasks(timeout: number | undefined, callback: ValidateCallback): void;
+    getPath(returnPathAsString?: boolean): string | (string | number)[];
+    getSchemaId(): string | undefined;
+    hasError(errCode: string, errParams: Array<any>): boolean;
+    addError(errCode: ErrorCode, errParams?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema): void;
+    getJson(): unknown;
+    addCustomError(errorCode: string, errorMessage: string, params?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema): void;
 }
 export {};

package/dist/types/schema-cache.d.ts

@@ -0,0 +1,17 @@
+import type { ZSchema } from './z-schema.js';
+import { Report } from './report.js';
+import { JsonSchemaInternal } from './json-schema.js';
+export type SchemaCacheStorage = Record<string, JsonSchemaInternal>;
+export type ReferenceSchemaCacheStorage = Array<[JsonSchemaInternal, JsonSchemaInternal]>;
+export declare class SchemaCache {
+    private validator;
+    cache: SchemaCacheStorage;
+    referenceCache: ReferenceSchemaCacheStorage;
+    constructor(validator: ZSchema);
+    cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
+    removeFromCacheByUri(uri: string): void;
+    checkCacheForUri(uri: string): boolean;
+    getSchema(report: Report, refOrSchema: string | JsonSchemaInternal): JsonSchemaInternal | undefined;
+    getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal): JsonSchemaInternal | undefined;
+    getSchemaByReference(report: Report, schema: JsonSchemaInternal): JsonSchemaInternal;
+}

package/dist/types/schema-compiler.d.ts

@@ -0,0 +1,16 @@
+import type { ZSchema } from './z-schema.js';
+import { JsonSchemaInternal } from './json-schema.js';
+import { Report } from './report.js';
+export interface Reference {
+    ref: string;
+    key: '$ref' | '$schema';
+    obj: JsonSchemaInternal;
+    path: Array<string | number>;
+}
+export declare class SchemaCompiler {
+    private validator;
+    constructor(validator: ZSchema);
+    compileSchema(report: Report, schema: JsonSchemaInternal): boolean;
+    compileArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]): boolean;
+    compileArrayOfSchemasLoop(mainReport: Report, arr: JsonSchemaInternal[]): number;
+}

package/dist/types/schema-validator.d.ts

@@ -0,0 +1,10 @@
+import type { ZSchema } from './z-schema.js';
+import { Report } from './report.js';
+import { JsonSchemaInternal } from './json-schema.js';
+export declare class SchemaValidator {
+    private validator;
+    constructor(validator: ZSchema);
+    get options(): import("./z-schema.js").ZSchemaOptions;
+    validateArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]): boolean;
+    validateSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[]): boolean;
+}

package/dist/types/utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare const isUniqueArray: <T>(arr: T[], indexes?: number[]) => boolean;
+export declare const difference: (bigSet: any[], subSet: any[]) => any[];

package/dist/types/utils/clone.d.ts

@@ -0,0 +1,2 @@
+export declare const shallowClone: <T>(src: T) => T;
+export declare const deepClone: <T>(src: T) => T;

package/dist/types/utils/json.d.ts

@@ -0,0 +1,7 @@
+interface AreEqualOptions {
+    caseInsensitiveComparison?: boolean;
+}
+export declare const areEqual: (json1: unknown, json2: unknown, options?: AreEqualOptions) => boolean;
+export declare const decodeJSONPointer: (str: string) => string;
+export declare const sortedKeys: (obj: Record<string, unknown>) => string[];
+export {};

package/dist/types/utils/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const jsonSymbol: unique symbol;
+export declare const schemaSymbol: unique symbol;

package/dist/types/utils/unicode.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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: string): number[];

package/dist/types/utils/uri.d.ts

@@ -0,0 +1,4 @@
+export declare const getQueryPath: (uri: string) => string | undefined;
+export declare const getRemotePath: (uri: string) => string;
+export declare const isAbsoluteUri: (uri: string) => boolean;
+export declare const isRelativeUri: (uri: string) => boolean;

package/dist/types/utils/what-is.d.ts

@@ -0,0 +1,3 @@
+export type WHAT_IS = 'undefined' | 'null' | 'object' | 'array' | 'integer' | 'number' | 'string' | 'not-a-number' | 'unknown-number' | 'bigint' | 'boolean' | 'symbol' | 'function';
+export declare const whatIs: (what: unknown) => WHAT_IS;
+export declare function isObject(value: unknown): value is Record<any, any>;

package/dist/types/z-schema.d.ts

@@ -0,0 +1,75 @@
+import { Report, SchemaError, SchemaErrorDetail } from './report.js';
+import { FormatValidatorFn } from './format-validators.js';
+import { SchemaCache } from './schema-cache.js';
+import { SchemaCompiler } from './schema-compiler.js';
+import { SchemaValidator } from './schema-validator.js';
+import type { Errors } from './errors.js';
+import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+export interface ZSchemaOptions {
+    asyncTimeout?: number;
+    forceAdditional?: boolean;
+    assumeAdditional?: boolean | string[];
+    enumCaseInsensitiveComparison?: 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>;
+}
+export type ValidateCallback = (e: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
+type SchemaReader = (uri: string) => JsonSchema;
+export declare class ZSchema {
+    static registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
+    static unregisterFormat(name: string): void;
+    static getRegisteredFormats(): string[];
+    static getDefaultOptions(): ZSchemaOptions;
+    lastReport: Report | undefined;
+    scache: SchemaCache;
+    sc: SchemaCompiler;
+    sv: SchemaValidator;
+    validateOptions: ValidateOptions;
+    options: ZSchemaOptions;
+    constructor(options?: ZSchemaOptions);
+    validateSchema(schema: JsonSchemaInternal): boolean;
+    validate(json: unknown, schema: JsonSchema, options?: ValidateOptions, callback?: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema, callback?: ValidateCallback): void;
+    validate(json: unknown, schema: JsonSchema): boolean;
+    /**
+     * Returns an Error object for the most recent failed validation, or null if the validation was successful.
+     */
+    getLastError(): SchemaError | null;
+    /**
+     * 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[] | null;
+    setRemoteReference(uri: string, schema: string | JsonSchema, validationOptions: ZSchemaOptions): void;
+    compileSchema(schema: JsonSchema): boolean;
+    getMissingReferences(arr?: SchemaErrorDetail[]): string[];
+    getMissingRemoteReferences(): string[];
+    getResolvedSchema(schema: JsonSchemaInternal): JsonSchema;
+    static schemaReader: SchemaReader;
+    setSchemaReader(schemaReader: SchemaReader): void;
+    getSchemaReader(): SchemaReader;
+    static setSchemaReader(schemaReader: SchemaReader): void;
+    static schemaSymbol: symbol;
+    static jsonSymbol: symbol;
+}
+export {};

package/dist/utils/array.js

@@ -0,0 +1,27 @@
+import { areEqual } from './json.js';
+export const 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;
+};
+export const difference = (bigSet, subSet) => {
+    const arr = [];
+    let idx = bigSet.length;
+    while (idx--) {
+        if (subSet.indexOf(bigSet[idx]) === -1) {
+            arr.push(bigSet[idx]);
+        }
+    }
+    return arr;
+};

package/dist/utils/clone.js

@@ -0,0 +1,61 @@
+export const shallowClone = (src) => {
+    if (src == null || typeof src !== 'object') {
+        return src;
+    }
+    let res;
+    let 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 const deepClone = (src) => {
+    let vidx = 0;
+    const visited = new Map();
+    const cloned = [];
+    const 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);
+};

package/dist/utils/json.js

@@ -0,0 +1,59 @@
+import { isObject } from './what-is.js';
+export const 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 (isObject(json1) && isObject(json2)) {
+        // 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;
+};
+export const decodeJSONPointer = (str) => {
+    // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07#section-3
+    return decodeURIComponent(str).replace(/~[0-1]/g, (x) => (x === '~1' ? '/' : '~'));
+};
+export const sortedKeys = (obj) => Object.keys(obj).sort();

package/dist/utils/symbols.js

@@ -0,0 +1,2 @@
+export const jsonSymbol = Symbol.for('z-schema/json');
+export const schemaSymbol = Symbol.for('z-schema/schema');

package/dist/utils/unicode.js

@@ -0,0 +1,45 @@
+/*
+  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/utils/uri.js

@@ -0,0 +1,15 @@
+export const 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;
+};
+export const getRemotePath = (uri) => {
+    const io = uri.indexOf('#');
+    return io === -1 ? uri : uri.slice(0, io);
+};
+export const isAbsoluteUri = (uri) => /^https?:\/\//.test(uri);
+export const isRelativeUri = (uri) => 
+// relative URIs that end with a hash sign, issue #56
+/.+#/.test(uri);

package/dist/utils/what-is.js

@@ -0,0 +1,29 @@
+export const whatIs = (what) => {
+    if (typeof what === 'object') {
+        if (what === null) {
+            return 'null';
+        }
+        if (Array.isArray(what)) {
+            return 'array';
+        }
+        return 'object'; // typeof what === 'object' && what === Object(what) && !Array.isArray(what);
+    }
+    if (typeof what === '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 typeof what; // undefined, boolean, string, function
+};
+export function isObject(value) {
+    return whatIs(value) === 'object';
+}