z-schema 7.0.0-beta.1 → 7.0.0-beta.3

package/bin/z-schema

@@ -8,7 +8,7 @@ import path from 'path';
 import { program } from 'commander';
 import { request } from 'https';
 import pkg from '../package.json' with { type: 'json' };
-import ZSchema from '../dist/ZSchema.js';
+import ZSchema from '../dist/index.js';
 
 program
   .version(pkg.version)

package/{dist → cjs}/ZSchema.cjs

@@ -13782,4 +13782,4 @@ class ZSchema {
     static jsonSymbol = jsonSymbol;
 }
 
-module.exports = ZSchema;
+exports.ZSchema = ZSchema;

package/cjs/ZSchema.cjs.d.ts

@@ -0,0 +1,227 @@
+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[];
+}
+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;
+}
+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];
+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;
+}
+
+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;
+};
+
+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;
+}
+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 { ZSchema as default };

package/dist/ZSchema.js

@@ -95,7 +95,7 @@ function normalizeOptions(options) {
     }
     return normalized;
 }
-class ZSchema {
+export class ZSchema {
     lastReport;
     /**
      * Register a custom format.
@@ -363,4 +363,3 @@ class ZSchema {
     static schemaSymbol = Utils.schemaSymbol;
     static jsonSymbol = Utils.jsonSymbol;
 }
-export default ZSchema;

package/dist/index.js

@@ -0,0 +1,2 @@
+import { ZSchema } from './ZSchema.js';
+export default ZSchema;

package/dist/types/ZSchema.d.ts

@@ -29,7 +29,7 @@ export interface ValidateOptions {
 }
 type ValidateCallback = (e: Error, valid: boolean) => void;
 type SchemaReader = (uri: string) => unknown;
-declare class ZSchema {
+export declare class ZSchema {
     lastReport: Report | undefined;
     /**
      * Register a custom format.
@@ -94,4 +94,4 @@ declare class ZSchema {
     static schemaSymbol: symbol;
     static jsonSymbol: symbol;
 }
-export default ZSchema;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { ZSchema } from './ZSchema.js';
+export default ZSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "7.0.0-beta.1",
+  "version": "7.0.0-beta.3",
   "engines": {
     "node": ">=22.0.0"
   },
@@ -17,21 +17,28 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/zaggino/z-schema.git"
+    "url": "git+https://github.com/zaggino/z-schema.git"
   },
   "bugs": {
     "url": "https://github.com/zaggino/z-schema/issues"
   },
   "type": "module",
-  "main": "dist/ZSchema.js",
-  "types": "dist/types/ZSchema.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/types/index.d.ts",
+      "require": "./cjs/ZSchema.cjs"
+    }
+  },
   "bin": {
-    "z-schema": "./bin/z-schema"
+    "z-schema": "bin/z-schema"
   },
   "files": [
     "bin/",
+    "cjs/",
     "dist/",
     "src/",
+    "umd/",
     "LICENSE",
     "README.md"
   ],
@@ -43,7 +50,7 @@
     "format:check": "prettier --check .",
     "lint": "eslint --fix",
     "lint:check": "eslint",
-    "clean": "rimraf ./dist && rimraf --glob \"./src/schemas/*.json\"",
+    "clean": "rimraf ./cjs && rimraf ./dist && rimraf ./umd && rimraf --glob \"./src/schemas/*.json\"",
     "build": "npm run copy:schemas && tsc && rollup -c",
     "build:browser": "rollup -c --environment BROWSER",
     "build:watch": "rollup -c -w",
@@ -95,6 +102,7 @@
     "remapify": "^2.2.0",
     "rimraf": "^6.1.2",
     "rollup": "^4.57.0",
+    "rollup-plugin-dts": "^6.3.0",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.54.0",

package/src/ZSchema.ts

@@ -140,7 +140,7 @@ type ValidateCallback = (e: Error, valid: boolean) => void;
 // a sync function that loads schemas for future use, for example from schemas directory, during server startup
 type SchemaReader = (uri: string) => unknown;
 
-class ZSchema {
+export class ZSchema {
   public lastReport: Report | undefined;
 
   /**
@@ -465,5 +465,3 @@ class ZSchema {
 
   static jsonSymbol = Utils.jsonSymbol;
 }
-
-export default ZSchema;

package/src/index.ts

@@ -0,0 +1,3 @@
+import { ZSchema } from './ZSchema.js';
+
+export default ZSchema;

package/{dist/ZSchema-umd.js → umd/ZSchema.js}

@@ -1,8 +1,8 @@
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-	typeof define === 'function' && define.amd ? define(factory) :
-	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ZSchema = factory());
-})(this, (function () { 'use strict';
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ZSchema = {}));
+})(this, (function (exports) { 'use strict';
 
 	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -13786,6 +13786,6 @@
 	    static jsonSymbol = jsonSymbol;
 	}
 
-	return ZSchema;
+	exports.ZSchema = ZSchema;
 
 }));