@jarenjs/validate 0.8.4 → 0.9.2

package/src/string.js

@@ -0,0 +1,152 @@
+//@ts-check
+
+import {
+  isStringType,
+  getStringType,
+} from '@jarenjs/core';
+
+import {
+  getIntishType,
+} from '@jarenjs/core/number';
+
+import {
+  createRegExp,
+  getStringLength,
+  getSegmenter,
+} from '@jarenjs/core/string';
+
+import {
+  trueThat,
+} from '@jarenjs/core/function';
+
+function compileMinLength(schemaObj, jsonSchema) {
+  const min = getIntishType(jsonSchema.minLength) || 0;
+  if (min < 1) return undefined;
+
+  const addError = schemaObj.createErrorHandler(min, 'minLength');
+
+  return function validateIsMinLength(len = 0, dataPath) {
+    return len >= min
+      || addError(len, dataPath);
+  };
+}
+
+function compileMaxLength(schemaObj, jsonSchema) {
+  const max = getIntishType(jsonSchema.maxLength) || -1;
+  if (max < 0) return undefined;
+
+  const addError = schemaObj.createErrorHandler(max, 'maxLength');
+
+  return function validateIsMaxLength(len = 0, dataPath) {
+    return len <= max
+      || addError(len, dataPath);
+  };
+}
+
+function compilePattern(schemaObj, jsonSchema) {
+  // Skip if pattern is a $data reference object (has $data property)
+  if (jsonSchema.pattern && typeof jsonSchema.pattern === 'object' && jsonSchema.pattern.$data) return undefined;
+
+  const pattern = createRegExp(jsonSchema.pattern);
+  if (pattern == null) return undefined;
+
+  const addError = schemaObj.createErrorHandler(pattern, 'pattern');
+
+  return function validateIsMatch(str = '', dataPath) {
+    return pattern.test(str)
+      || addError(str, dataPath);
+  };
+}
+
+function compileStringIntern(schemaObj, jsonSchema) {
+  const minLength = compileMinLength(schemaObj, jsonSchema);
+  const maxLength = compileMaxLength(schemaObj, jsonSchema);
+  const pattern = compilePattern(schemaObj, jsonSchema);
+
+  if ((minLength || maxLength || pattern) == null) return undefined;
+
+  const isMinLength = minLength || trueThat;
+  const isMaxLength = maxLength || trueThat;
+  const isMatch = pattern || trueThat;
+  const useGrapheme = schemaObj.options.useGrapheme;
+
+  return function validateStringIntern(data, dataPath) {
+    const len = getStringLength(data, useGrapheme);
+    return isMinLength(len, dataPath)
+      && isMaxLength(len, dataPath)
+      && isMatch(data, dataPath);
+  };
+}
+
+export function compileStringBasic(schemaObj, jsonSchema) {
+  const intern = compileStringIntern(schemaObj, jsonSchema);
+  if (intern == null) return undefined;
+
+  // Fast path for simple maxLength-only schemas (most common case)
+  // This inlines the validation to reduce function call overhead
+  const max = getIntishType(jsonSchema.maxLength) ?? -1;
+  const min = getIntishType(jsonSchema.minLength) || 0;
+  const hasPattern = jsonSchema.pattern != null;
+  const useGrapheme = schemaObj.options.useGrapheme;
+
+  if (!hasPattern) {
+    if (!useGrapheme) {
+      // Simple maxLength-only without grapheme counting
+      if (max >= 0 && min < 1) {
+        const addError = schemaObj.createErrorHandler(max, 'maxLength');
+        return function validateStringMaxLength(data, dataPath) {
+          if (!isStringType(data)) return true;
+          return data.length <= max || addError(data.length, dataPath);
+        };
+      }
+
+      // Simple minLength-only without grapheme counting
+      if (min > 0 && max < 0) {
+        const addError = schemaObj.createErrorHandler(min, 'minLength');
+        return function validateStringMinLength(data, dataPath) {
+          if (!isStringType(data)) return true;
+          return data.length >= min || addError(data.length, dataPath);
+        };
+      }
+    } else {
+      // Fast path WITH grapheme counting - inline the ASCII fast-path logic
+      // This avoids the function call overhead of getStringLength for ASCII strings
+      if (max >= 0 && min < 1) {
+        const addError = schemaObj.createErrorHandler(max, 'maxLength');
+        return function validateStringMaxLengthGrapheme(data, dataPath) {
+          if (!isStringType(data)) return true;
+          const len = getStringLength(data, true);
+          return len <= max || addError(len, dataPath);
+        };
+      }
+
+      if (min > 0 && max < 0) {
+        const addError = schemaObj.createErrorHandler(min, 'minLength');
+        return function validateStringMinLengthGrapheme(data, dataPath) {
+          if (!isStringType(data)) return true;
+          const len = getStringLength(data, true);
+          return len >= min || addError(len, dataPath);
+        };
+      }
+    }
+  }
+
+  // Fast path for pattern-only schemas (common in ecmascript-regex tests)
+  // This eliminates the intermediate function call overhead
+  if (hasPattern && max < 0 && min < 1) {
+    const pattern = createRegExp(jsonSchema.pattern);
+    if (pattern != null) {
+      const addError = schemaObj.createErrorHandler(pattern, 'pattern');
+      return function validateStringPatternOnly(data, dataPath) {
+        if (!isStringType(data)) return true;
+        return pattern.test(data) || addError(data, dataPath);
+      };
+    }
+  }
+
+  // Generic case
+  return function validateStringBasic(data, dataPath) {
+    return !isStringType(data)
+      || intern(data, dataPath);
+  };
+}

package/src/tools.js

@@ -0,0 +1,205 @@
+//@ts-check
+
+import {
+  isBigIntType,
+  isNullValue,
+  isBooleanType,
+  isIntegerType,
+  isNumberType,
+  isStringType,
+  isObjectClass,
+  isObjectType,
+  isMapClass,
+  isArrayClass,
+  isSetClass,
+} from '@jarenjs/core';
+
+import {
+  isRegExpType,
+  isStringWhiteSpace,
+} from '@jarenjs/core/string';
+
+import {
+  isArrayish,
+} from '@jarenjs/core/array';
+
+//#region Object
+export function isBoolOrObjectClass(obj) {
+  return isBooleanType(obj)
+    || isObjectClass(obj);
+}
+
+/**
+ * getBoolOrObjectClass
+ * extract the data of first parameter if data is boolean or object type otherwise return default
+ * @param {any} obj any data data has to be tested on boolean or object type
+ * @param {boolean | object | undefined} def default return type if not boolean or object type
+ * @returns {boolean | undefined} return value when boolean or object otherwise def
+ */
+export function getBoolOrObjectClass(obj, def = undefined) {
+  return isBoolOrObjectClass(obj) ? obj : def;
+}
+
+export function getArrayClassMinItems(obj, len = 1, def = undefined) {
+  return (isArrayClass(obj) && obj.length >= len && obj) || def;
+}
+//#endregion
+
+//#region Schema Helpers
+export function isOfSchemaType(schema, type) {
+  const stype = schema.type;
+  if (stype == null) return false;
+  if (stype === type) return true;
+  if (stype.constructor === Array) {
+    return stype.includes(type);
+  }
+  if (stype.constructor === Set) {
+    return stype.has(type);
+  }
+  return false;
+}
+
+export function hasSchemaRef(schema) {
+  return isObjectClass(schema)
+    && isStringType(schema.$ref)
+    && !isStringWhiteSpace(schema.$ref);
+}
+
+export function hasSchemaRecursiveRef(schema) {
+  return isObjectClass(schema)
+    && isStringType(schema.$recursiveRef)
+    && !isStringWhiteSpace(schema.$recursiveRef);
+}
+
+export function hasSchemaDynamicRef(schema) {
+  return isObjectClass(schema)
+    && isStringType(schema.$dynamicRef)
+    && !isStringWhiteSpace(schema.$dynamicRef);
+}
+
+export function createIsSchemaTypeHandler(type, isStrict = false) {
+  switch (type) {
+    case 'null': return isNullValue;
+    case 'boolean': return isBooleanType;
+    case 'integer': return isIntegerType;
+    case 'bigint': return isBigIntType;
+    case 'number': return isNumberType;
+    case 'string': return isStringType;
+    case 'object': return isStrict
+      ? isObjectClass
+      : isObjectType;
+    case 'array': return isStrict
+      ? isArrayish
+      : isArrayClass;
+    case 'set': return isSetClass;
+    case 'map': return isMapClass;
+    case 'tuple': return isArrayClass;
+    case 'regex': return isRegExpType;
+    default: break;
+  }
+
+  if (type === null)
+    return isNullValue;
+
+  if (typeof type === 'function')
+    throw new Error('This is interesting!');
+
+  return undefined;
+}
+
+//#endregion
+
+/**
+ * Records which properties (string keys) and items (numeric indexes) of a
+ * data instance were successfully evaluated during validation, so that
+ * unevaluatedProperties/unevaluatedItems can be checked afterwards.
+ *
+ * Entries are (data reference, key) pairs appended in application order.
+ * Applicators that discard annotations (failed anyOf/oneOf branches, not,
+ * failed if) take a mark() before running and rollback(mark) afterwards.
+ * The numeric key -1 means "all items of this array were evaluated".
+ */
+export class EvalLog {
+  #data = [];
+  #keys = [];
+  #len = 0;
+
+  /** Clears the log; called at the start of each root validation. */
+  reset() {
+    this.#data.length = 0;
+    this.#keys.length = 0;
+    this.#len = 0;
+  }
+
+  /** @returns {number} The current log position */
+  mark() {
+    return this.#len;
+  }
+
+  /** Discards all entries recorded after the given mark. */
+  rollback(mark) {
+    this.#len = mark;
+  }
+
+  /** Records that `key` of instance `data` was evaluated. */
+  add(data, key) {
+    this.#data[this.#len] = data;
+    this.#keys[this.#len] = key;
+    this.#len++;
+  }
+
+  /** @returns {boolean} True when property `key` of `data` was evaluated at or after `from` */
+  hasKey(data, key, from) {
+    const len = this.#len;
+    const datas = this.#data;
+    const keys = this.#keys;
+    for (let i = from; i < len; ++i) {
+      if (datas[i] === data && keys[i] === key) return true;
+    }
+    return false;
+  }
+
+  /** @returns {boolean} True when item `index` of `data` was evaluated at or after `from` (-1 entries cover all items) */
+  hasItem(data, index, from) {
+    const len = this.#len;
+    const datas = this.#data;
+    const keys = this.#keys;
+    for (let i = from; i < len; ++i) {
+      if (datas[i] === data) {
+        const k = keys[i];
+        if (k === index || k === -1) return true;
+      }
+    }
+    return false;
+  }
+}
+
+export class ValidationResult {
+  static undefThat() {
+    return new ValidationResult();
+  }
+
+  constructor(match = false, errors = 0) {
+    this.match = match;
+    this.errors = Number(errors);
+  }
+
+  addValid(valid = true) {
+    if (valid === false)// this.errors += valid|0
+      this.errors++;
+    return this;
+  }
+
+  addMatch(valid = true) {
+    this.match = true;
+    if (valid === false)// this.errors += valid|0
+      this.errors++;
+    return this;
+  }
+
+  addResult(result = new ValidationResult()) {
+    this.match = this.match || result.match;
+    this.errors += result.errors;
+    return this;
+  }
+}