z-schema 6.0.1 → 7.0.0-beta.1

package/dist/types/Errors.d.ts

@@ -0,0 +1,44 @@
+export declare const Errors: {
+    INVALID_TYPE: string;
+    INVALID_FORMAT: string;
+    ENUM_MISMATCH: string;
+    ENUM_CASE_MISMATCH: string;
+    ANY_OF_MISSING: string;
+    ONE_OF_MISSING: string;
+    ONE_OF_MULTIPLE: string;
+    NOT_PASSED: string;
+    ARRAY_LENGTH_SHORT: string;
+    ARRAY_LENGTH_LONG: string;
+    ARRAY_UNIQUE: string;
+    ARRAY_ADDITIONAL_ITEMS: string;
+    MULTIPLE_OF: string;
+    MINIMUM: string;
+    MINIMUM_EXCLUSIVE: string;
+    MAXIMUM: string;
+    MAXIMUM_EXCLUSIVE: string;
+    OBJECT_PROPERTIES_MINIMUM: string;
+    OBJECT_PROPERTIES_MAXIMUM: string;
+    OBJECT_MISSING_REQUIRED_PROPERTY: string;
+    OBJECT_ADDITIONAL_PROPERTIES: string;
+    OBJECT_DEPENDENCY_KEY: string;
+    MIN_LENGTH: string;
+    MAX_LENGTH: string;
+    PATTERN: string;
+    KEYWORD_TYPE_EXPECTED: string;
+    KEYWORD_UNDEFINED_STRICT: string;
+    KEYWORD_UNEXPECTED: string;
+    KEYWORD_MUST_BE: string;
+    KEYWORD_DEPENDENCY: string;
+    KEYWORD_PATTERN: string;
+    KEYWORD_VALUE_TYPE: string;
+    UNKNOWN_FORMAT: string;
+    CUSTOM_MODE_FORCE_PROPERTIES: string;
+    REF_UNRESOLVED: string;
+    UNRESOLVABLE_REFERENCE: string;
+    SCHEMA_NOT_REACHABLE: string;
+    SCHEMA_TYPE_EXPECTED: string;
+    SCHEMA_NOT_AN_OBJECT: string;
+    ASYNC_TIMEOUT: string;
+    PARENT_SCHEMA_VALIDATION_FAILED: string;
+    REMOTE_NOT_VALID: string;
+};

package/dist/types/FormatValidators.d.ts

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,37 @@
+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/Report.d.ts

@@ -0,0 +1,87 @@
+import { ZSchemaOptions } from './ZSchema.js';
+export interface SchemaError extends Error {
+    /**
+     * Implements the Error.name contract.  The value is always "z-schema validation error".
+     */
+    name: string;
+    /**
+     * An identifier indicating the type of error.
+     * Example: "JSON_OBJECT_VALIDATION_FAILED"
+     */
+    message: string;
+    /**
+     * Returns details for each error that occurred during validation.
+     * See Options.breakOnFirstError.
+     */
+    details?: SchemaErrorDetail[];
+}
+export interface SchemaErrorDetail {
+    /**
+     * Example: "Expected type string but found type array"
+     */
+    message: string;
+    /**
+     * An error identifier that can be used to format a custom error message.
+     * Example: "INVALID_TYPE"
+     */
+    code: string;
+    /**
+     * Format parameters that can be used to format a custom error message.
+     * Example: ["string","array"]
+     */
+    params: Array<string>;
+    /**
+     * A JSON path indicating the location of the error.
+     * Example: "#/projects/1"
+     */
+    path: string | string[];
+    /**
+     * The schema rule description, which is included for certain errors where
+     * this information is useful (e.g. to describe a constraint).
+     */
+    title?: string;
+    description?: string;
+    /**
+     * Returns details for sub-schemas that failed to match.  For example, if the schema
+     * uses the "oneOf" constraint to accept several alternative possibilities, each
+     * alternative will have its own inner detail object explaining why it failed to match.
+     */
+    inner?: SchemaErrorDetail[];
+    schemaId?: string;
+}
+export interface ReportOptions {
+    maxErrors?: number;
+}
+type TaskResult = unknown;
+type TaskFn = (...args: unknown[]) => TaskResult;
+type TaskFnArgs = Parameters<TaskFn>;
+type TaskProcessFn = (result: ReturnType<TaskFn>) => void;
+type AsyncTask = [TaskFn, TaskFnArgs, TaskProcessFn];
+export declare class Report {
+    errors: SchemaErrorDetail[];
+    parentReport?: Report;
+    options: ZSchemaOptions;
+    reportOptions: ReportOptions;
+    path: string[];
+    asyncTasks: AsyncTask[];
+    rootSchema?: {
+        id?: string;
+    };
+    commonErrorMessage?: string;
+    json?: unknown;
+    constructor(parentOrOptions: any, reportOptions?: any);
+    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;
+}
+export {};

package/dist/types/SchemaCache.d.ts

@@ -0,0 +1,26 @@
+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

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

package/dist/types/SchemaValidation.d.ts

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

package/dist/types/Utils.d.ts

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,97 @@
+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;
+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 default ZSchema;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "z-schema",
-  "version": "6.0.1",
+  "version": "7.0.0-beta.1",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=22.0.0"
   },
   "description": "JSON schema validator",
   "homepage": "https://github.com/zaggino/z-schema",
@@ -22,48 +22,39 @@
   "bugs": {
     "url": "https://github.com/zaggino/z-schema/issues"
   },
-  "main": "src/ZSchema.js",
+  "type": "module",
+  "main": "dist/ZSchema.js",
+  "types": "dist/types/ZSchema.d.ts",
   "bin": {
     "z-schema": "./bin/z-schema"
   },
   "files": [
-    "bin",
-    "src",
-    "dist",
+    "bin/",
+    "dist/",
+    "src/",
     "LICENSE",
-    "README.md",
-    "index.d.ts"
+    "README.md"
   ],
-  "types": "index.d.ts",
   "scripts": {
-    "prepare": "grunt",
-    "prepublishOnly": "npm test",
-    "test": "jasmine-node test/ && grunt lint",
-    "test-z": "jasmine-node test/spec/ZSchemaTestSuiteSpec.js",
-    "grunt": "grunt"
-  },
-  "testling": {
-    "scripts": [
-      "test/lib/jasmine-2.0.1/jasmine.js",
-      "test/lib/jasmine-2.0.1/jasmine-html.js",
-      "test/lib/jasmine-2.0.1/boot.js",
-      "test/lib/jasmine-2.0.1/tap_reporter.js",
-      "test/Runner.js",
-      "dist/ZSchema-browser-min.js",
-      "dist/ZSchema-browser-test.js"
-    ],
-    "browsers": [
-      "iexplore/9..latest",
-      "chrome/4",
-      "chrome/28..latest",
-      "firefox/3.5",
-      "firefox/23..latest",
-      "safari/5.1..latest",
-      "opera/12..latest",
-      "iphone/6..latest",
-      "ipad/6..latest",
-      "android-browser/4.2..latest"
-    ]
+    "prepare": "husky",
+    "pre-commit": "npx lint-staged",
+    "pre-push": "",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint --fix",
+    "lint:check": "eslint",
+    "clean": "rimraf ./dist && rimraf --glob \"./src/schemas/*.json\"",
+    "build": "npm run copy:schemas && tsc && rollup -c",
+    "build:browser": "rollup -c --environment BROWSER",
+    "build:watch": "rollup -c -w",
+    "copy:schemas": "npm run copy:schema && npm run copy:hyper-schema",
+    "copy:schema": "node -e \"fs.copyFileSync('./json-schema/draft-04/schema', './src/schemas/schema.json')\"",
+    "copy:hyper-schema": "node -e \"fs.copyFileSync('./json-schema/draft-04/hyper-schema', './src/schemas/hyper-schema.json')\"",
+    "prepublishOnly": "npm run clean && npm run build && npm test",
+    "test": "vitest run",
+    "test:browsers": "vitest run --project browsers --silent=true",
+    "test:node": "vitest run --project node --silent=true",
+    "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\""
   },
   "dependencies": {
     "lodash.get": "^4.4.2",
@@ -71,22 +62,42 @@
     "validator": "^13.7.0"
   },
   "optionalDependencies": {
-    "commander": "^10.0.0"
+    "commander": "^14.0.2"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@eslint/json": "^0.14.0",
+    "@eslint/markdown": "^7.5.1",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/lodash.get": "^4.4.9",
+    "@types/node": "^25.1.0",
+    "@vitest/browser-playwright": "^4.0.18",
+    "@vitest/eslint-plugin": "^1.6.6",
     "browserify": "^17.0.0",
     "coveralls": "^3.1.1",
-    "grunt": "^1.4.1",
+    "eslint": "^9.39.2",
+    "globals": "^17.2.0",
     "grunt-browserify": "^6.0.0",
     "grunt-cli": "^1.4.3",
     "grunt-contrib-copy": "^1.0.0",
-    "grunt-contrib-jasmine": "^4.0.0",
     "grunt-contrib-jshint": "^3.2.0",
     "grunt-contrib-uglify": "^5.2.2",
     "grunt-jscs": "^3.0.1",
     "grunt-lineending": "^1.0.0",
-    "jasmine-node": "^3.0.0",
-    "jasmine-reporters": "^2.5.0",
-    "remapify": "^2.2.0"
+    "husky": "^9.1.7",
+    "jsdom": "^27.4.0",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.1",
+    "remapify": "^2.2.0",
+    "rimraf": "^6.1.2",
+    "rollup": "^4.57.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "vitest": "^4.0.18"
   }
 }

package/src/Errors.ts

@@ -0,0 +1,56 @@
+export const Errors = {
+  INVALID_TYPE: 'Expected type {0} but found type {1}',
+  INVALID_FORMAT: "Object didn't pass validation for format {0}: {1}",
+  ENUM_MISMATCH: 'No enum match for: {0}',
+  ENUM_CASE_MISMATCH: 'Enum does not match case for: {0}',
+  ANY_OF_MISSING: "Data does not match any schemas from 'anyOf'",
+  ONE_OF_MISSING: "Data does not match any schemas from 'oneOf'",
+  ONE_OF_MULTIPLE: "Data is valid against more than one schema from 'oneOf'",
+  NOT_PASSED: "Data matches schema from 'not'",
+
+  // Array errors
+  ARRAY_LENGTH_SHORT: 'Array is too short ({0}), minimum {1}',
+  ARRAY_LENGTH_LONG: 'Array is too long ({0}), maximum {1}',
+  ARRAY_UNIQUE: 'Array items are not unique (indexes {0} and {1})',
+  ARRAY_ADDITIONAL_ITEMS: 'Additional items not allowed',
+
+  // Numeric errors
+  MULTIPLE_OF: 'Value {0} is not a multiple of {1}',
+  MINIMUM: 'Value {0} is less than minimum {1}',
+  MINIMUM_EXCLUSIVE: 'Value {0} is equal or less than exclusive minimum {1}',
+  MAXIMUM: 'Value {0} is greater than maximum {1}',
+  MAXIMUM_EXCLUSIVE: 'Value {0} is equal or greater than exclusive maximum {1}',
+
+  // Object errors
+  OBJECT_PROPERTIES_MINIMUM: 'Too few properties defined ({0}), minimum {1}',
+  OBJECT_PROPERTIES_MAXIMUM: 'Too many properties defined ({0}), maximum {1}',
+  OBJECT_MISSING_REQUIRED_PROPERTY: 'Missing required property: {0}',
+  OBJECT_ADDITIONAL_PROPERTIES: 'Additional properties not allowed: {0}',
+  OBJECT_DEPENDENCY_KEY: 'Dependency failed - key must exist: {0} (due to key: {1})',
+
+  // String errors
+  MIN_LENGTH: 'String is too short ({0} chars), minimum {1}',
+  MAX_LENGTH: 'String is too long ({0} chars), maximum {1}',
+  PATTERN: 'String does not match pattern {0}: {1}',
+
+  // Schema validation errors
+  KEYWORD_TYPE_EXPECTED: "Keyword '{0}' is expected to be of type '{1}'",
+  KEYWORD_UNDEFINED_STRICT: "Keyword '{0}' must be defined in strict mode",
+  KEYWORD_UNEXPECTED: "Keyword '{0}' is not expected to appear in the schema",
+  KEYWORD_MUST_BE: "Keyword '{0}' must be {1}",
+  KEYWORD_DEPENDENCY: "Keyword '{0}' requires keyword '{1}'",
+  KEYWORD_PATTERN: "Keyword '{0}' is not a valid RegExp pattern: {1}",
+  KEYWORD_VALUE_TYPE: "Each element of keyword '{0}' array must be a '{1}'",
+  UNKNOWN_FORMAT: "There is no validation function for format '{0}'",
+  CUSTOM_MODE_FORCE_PROPERTIES: '{0} must define at least one property if present',
+
+  // Remote errors
+  REF_UNRESOLVED: 'Reference has not been resolved during compilation: {0}',
+  UNRESOLVABLE_REFERENCE: 'Reference could not be resolved: {0}',
+  SCHEMA_NOT_REACHABLE: 'Validator was not able to read schema with uri: {0}',
+  SCHEMA_TYPE_EXPECTED: "Schema is expected to be of type 'object'",
+  SCHEMA_NOT_AN_OBJECT: 'Schema is not an object: {0}',
+  ASYNC_TIMEOUT: '{0} asynchronous task(s) have timed out after {1} ms',
+  PARENT_SCHEMA_VALIDATION_FAILED: 'Schema failed to validate against its parent schema, see inner errors for details.',
+  REMOTE_NOT_VALID: "Remote reference didn't compile successfully: {0}",
+};