@jarenjs/validate 0.8.2 → 0.8.4

package/dist/index.js

@@ -367,6 +367,13 @@ function equalsDeep(target, source) {
   }
   return true;
 }
+function mapMerge(map, ...iterables) {
+  for (const iterable of iterables) {
+    for (const item of iterable) {
+      map.set(...item);
+    }
+  }
+}
 
 // src/enum.js
 function compileConst(schemaObj, jsonSchema) {
@@ -1360,15 +1367,15 @@ function compileSchemaObject(schemaObj, jsonSchema) {
   };
 }
 
-// ../strings/src/punycode.js
+// ../core/src/text/punycode.js
 var base = 36;
 var tMin = 1;
 var baseMinusTMin = base - tMin;
 var stringFromCharCode = String.fromCharCode;
 
-// ../strings/src/index.js
+// ../core/src/text/index.js
 var CONST_REGEXP_HTML_IDENTIFIER = /^[A-Za-z]+[\w\-\:\.]{0,30}$/;
-function isStringHtmlIdentifier(str) {
+function isValidHtmlIdentifier(str) {
   return (
     /* str != null && */
     CONST_REGEXP_HTML_IDENTIFIER.test(str)
@@ -1408,7 +1415,7 @@ function createJsonPointer(refUri, baseUri, opts = new JsonPointerOptions()) {
   const [uri, fragment] = url.href.split("#");
   const [leftUri, search] = uri.split("?");
   if (!isStringWhiteSpace(fragment)) {
-    if (opts.anchorsAllowed == true && isStringHtmlIdentifier(fragment)) {
+    if (opts.anchorsAllowed == true && isValidHtmlIdentifier(fragment)) {
       return opts.anchorsGlobal == true ? new JsonPointer(`#${fragment}`, search, `${leftUri}#`, fragment) : new JsonPointer(`${leftUri}#${fragment}`, search, `${leftUri}#`, fragment);
     } else if (fragment.startsWith("/")) {
       return new JsonPointer(`${leftUri}#${fragment}`, search, `${leftUri}#`, fragment);
@@ -1445,8 +1452,9 @@ var TRAVERSE_SCHEMA_MAPS = [
 ];
 function storeSchemaIdsInMap(schemas, baseUri, schema, opts = new JsonPointerOptions()) {
   if (!isObjectClass(schema)) {
-    schemas.set(baseUri, schema);
-    return null;
+    const { id } = createJsonPointer(baseUri, void 0, opts);
+    schemas.set(id, schema);
+    return id;
   }
   const { id: rootUri } = createJsonPointer(schema.$id, baseUri, opts);
   if (!isStringType(schema.$id) || isStringWhiteSpace(schema.$id)) {
@@ -1558,7 +1566,7 @@ function restoreSchemaRefsInMap(schemas, opts = new JsonPointerOptions()) {
   }
 }
 var TraverseOptions = class extends JsonPointerOptions {
-  constructor(origin = "https://github.com/jklarenbeek/jaren", mergeSchemas = true, anchorsGlobal, anchorsAllowed, skipErrors) {
+  constructor(origin = "https://github.com/jklarenbeek/jaren", mergeSchemas = true, anchorsGlobal = true, anchorsAllowed = true, skipErrors = true) {
     super(anchorsGlobal, anchorsAllowed, skipErrors);
     this.origin = origin, this.mergeSchemas = mergeSchemas;
   }
@@ -1590,6 +1598,7 @@ function resolveRefSchemaDeep(schemas, baseUri, refschema, opts = new TraverseOp
 }
 
 // src/index.js
+var DEFAULT_SCHEMA_DRAFT = "http://json-schema.org/draft-06/schema#";
 var isBrowser = typeof window !== "undefined";
 var performance = (() => isBrowser ? window.performance : {
   now: function performanceNow(start) {
@@ -1627,12 +1636,13 @@ var ValidationRoot = class _ValidationRoot {
     objects.set(path, obj);
     return obj;
   }
-  constructor(schemas, schema, origin, formats, opts = new ValidationOptions(), traverse = new TraverseOptions()) {
-    this._options = opts;
-    this._traverse = traverse;
-    this._schemas = schemas;
+  constructor(origin, schemas, formats, opts = new ValidationOptions(), traverse = new TraverseOptions()) {
+    const schema = schemas.get(origin);
     this._rootOrigin = origin;
+    this._schemas = schemas;
     this._formats = formats;
+    this._options = opts;
+    this._traverse = traverse;
     this._objects = /* @__PURE__ */ new Map();
     this._errors = [];
     this._firstSchema = _ValidationRoot._createObject(this, origin, schema);
@@ -1643,6 +1653,9 @@ var ValidationRoot = class _ValidationRoot {
   get formats() {
     return this._formats;
   }
+  get errors() {
+    return this._errors;
+  }
   createObject(path, schema) {
     return _ValidationRoot._createObject(this, path, schema);
   }
@@ -1670,7 +1683,7 @@ var ValidationRoot = class _ValidationRoot {
     return false;
   }
   validate(data) {
-    this._errors.length = 0;
+    this._errors = [];
     return this._firstSchema.validate(data, data);
   }
 };
@@ -1782,9 +1795,8 @@ function compileSchemaValidator(schema, opts = new ValidatorOptions()) {
   ));
   restoreSchemaRefsInMap(schemas, opts.traverse);
   const root = new ValidationRoot(
-    schemas,
-    schema,
     origin,
+    schemas,
     opts.formats,
     opts.validation,
     opts.traverse
@@ -1793,7 +1805,191 @@ function compileSchemaValidator(schema, opts = new ValidatorOptions()) {
     validate: (data) => root.validate(data)
   };
 }
+var JarenValidator = class _JarenValidator {
+  #formats = {};
+  #schemas = /* @__PURE__ */ new Map();
+  #metaSchemas = /* @__PURE__ */ new Map();
+  #options = new ValidatorOptions();
+  /**
+   * Create a new JarenValidator instance
+   * @param {ValidatorOptions} [options] - Validator options
+   */
+  constructor(options = new ValidatorOptions()) {
+    this.#formats = options.formats || {};
+    this.#schemas = /* @__PURE__ */ new Map();
+    this.#metaSchemas = /* @__PURE__ */ new Map();
+    this.#options = options;
+  }
+  /**
+   * Add format to validate strings or numbers.
+   * @param {string} name 
+   * @param {Function} formatCompiler 
+   * @returns {JarenValidator}
+   */
+  addFormat(name, formatCompiler) {
+    registerFormatCompiler(
+      this.#formats,
+      name,
+      formatCompiler
+    );
+    return this;
+  }
+  addFormats(formatCompilers) {
+    registerFormatCompilers(
+      this.#formats,
+      formatCompilers
+    );
+    return this;
+  }
+  /**
+   * 
+   * @param {boolean | object} schema 
+   * @param {object[] | undefined} schemas 
+   * @param {TraverseOptions} opts
+   * @returns {{origin:string, map: Map}}
+   */
+  static #traverseSchema(schema, schemas = void 0, fromMap = void 0, opts = new TraverseOptions()) {
+    const schemaMap = new Map(fromMap);
+    const origin = storeSchemaIdsInMap(
+      schemaMap,
+      opts.origin,
+      schema,
+      opts
+    );
+    if (Array.isArray(schemas) && schemas.length > 0) {
+      schemas.forEach((ref) => storeSchemaIdsInMap(
+        schemaMap,
+        origin,
+        ref,
+        opts
+      ));
+    }
+    restoreSchemaRefsInMap(schemaMap, opts);
+    return { origin, map: schemaMap };
+  }
+  /**
+   * Add schema(s) to validator instance. 
+   * This method does not compile schemas (but it still validates them). 
+   * Because of that dependencies can be added in any order and 
+   * circular dependencies are supported. 
+   * It also prevents unnecessary compilation of schemas that are 
+   * containers for other schemas but not used as a whole.
+   * @param {boolean | object | object[]} schema 
+   * @param {string | undefined} key
+   * @returns {JarenValidator}
+   */
+  addSchema(schema, key = void 0) {
+    if (Array.isArray(schema)) {
+      schema.forEach((s, index) => this.addSchema(s, key ? `${key}[${index}]` : void 0));
+    } else if (typeof schema === "object") {
+      const schemaKey = key || schema.$id;
+      if (schemaKey) {
+        this.#schemas.set(schemaKey, schema);
+      }
+    }
+    return this;
+  }
+  /**
+   * 
+   * @param {JarenValidator} self 
+   * @param {string} origin 
+   * @param {Map} schemas 
+   * @returns {(data) => boolean}
+   */
+  static #compileSchema(self, origin, schemas) {
+    const root = new ValidationRoot(
+      origin,
+      schemas,
+      self.#formats,
+      self.#options.validation,
+      self.#options.traverse
+    );
+    function jarenValidateSchema(data) {
+      return root.validate(data);
+    }
+    Object.defineProperty(jarenValidateSchema, "errors", {
+      get: function() {
+        return root._errors;
+      }
+    });
+    return jarenValidateSchema;
+  }
+  static normalizeUriKey(key) {
+    return key;
+  }
+  /**
+   * Adds meta schema(s) that can be used to validate other schemas.
+   * @param {boolean | object | object[]} schema 
+   * @param {string | undefined} key
+   * @returns {JarenValidator}
+   */
+  addMetaSchema(schema, key = void 0) {
+    key = _JarenValidator.normalizeUriKey(key);
+    if (Array.isArray(schema)) {
+      const first = schema.shift();
+      const { origin, map } = _JarenValidator.#traverseSchema(first, schema, void 0, new TraverseOptions(key));
+      const compiled = _JarenValidator.#compileSchema(this, origin, map);
+      this.#metaSchemas.set(origin, compiled);
+      mapMerge(this.#schemas, map);
+    } else if (isBoolOrObjectClass(schema)) {
+      const { origin, map } = _JarenValidator.#traverseSchema(schema, void 0, void 0, new TraverseOptions(key));
+      const compiled = _JarenValidator.#compileSchema(this, origin, map);
+      this.#metaSchemas.set(origin, compiled);
+      mapMerge(this.#schemas, map);
+    }
+    return this;
+  }
+  /**
+   * 
+   * @param {string} key 
+   * @returns {object}
+   */
+  getSchema(key) {
+    key = _JarenValidator.normalizeUriKey(key);
+    return this.#schemas.get(key) || null;
+  }
+  /**
+   * Validates schema. This method should be used to validate schemas rather than validate due to the inconsistency of uri format in JSON Schema standard.
+   * By default this method is called automatically when the schema is added, so you rarely need to use it directly.
+   * If schema doesn't have $schema property, it is validated against draft 6 meta-schema (option meta should not be false).
+   * If schema has $schema property, then the schema with this id (that should be previously added) is used to validate passed schema.
+   * Errors will be available at ajv.errors
+   * @param {boolean | object} schema 
+   * @returns {boolean}
+   */
+  validateSchema(schema) {
+    if (this.#metaSchemas.size == 0)
+      return true;
+    const schemaId = _JarenValidator.normalizeUriKey(schema.$schema || DEFAULT_SCHEMA_DRAFT);
+    const metaSchema = this.#metaSchemas.get(schemaId);
+    if (!metaSchema)
+      return false;
+    return metaSchema(schema);
+  }
+  /**
+   * Generate validating function and cache the compiled schema for future use.
+   * Note: This function does NOT return a promise. Use compileAsync instead!
+   * @param {boolean | object} schema
+   * @param {object[] | undefined} [schemas=undefined] 
+   * @returns {(data: any) => boolean}
+   */
+  compile(schema, schemas = void 0) {
+    const { origin, map } = _JarenValidator.#traverseSchema(schema, schemas, this.#schemas, this.#options.traverse);
+    return _JarenValidator.#compileSchema(this, origin, map);
+  }
+  /**
+   * Generate validating function and cache the compiled schema for future use.
+   * Note: This function returns a promise.
+   * @param {boolean | object} schema
+   * @returns {Promise<any>}
+   */
+  compileAsync(schema) {
+    throw new Error("compileAsync is not implemented");
+  }
+};
 export {
+  DEFAULT_SCHEMA_DRAFT,
+  JarenValidator,
   TraverseOptions,
   ValidatorOptions,
   compileSchemaValidator,