cmpstr 3.2.1 → 3.3.0

package/dist/cjs/phonetic/Phonetic.cjs

@@ -1,7 +1,8 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var DeepMerge = require('../utils/DeepMerge.cjs');
+var Errors = require('../utils/Errors.cjs');
 var HashTable = require('../utils/HashTable.cjs');
 var Profiler = require('../utils/Profiler.cjs');
 var Registry = require('../utils/Registry.cjs');
@@ -14,16 +15,26 @@ class Phonetic {
   options;
   optKey;
   map;
-  static clear = () => this.cache.clear();
+  ignoreSet;
+  static clear() {
+    this.cache.clear();
+  }
   constructor(algo, opt = {}) {
     const defaults = this.constructor.default ?? {};
     const mapId = opt.map ?? defaults.map;
-    if (!mapId) throw new Error(`No mapping specified for phonetic algorithm`);
+    if (!mapId)
+      throw new Errors.CmpStrNotFoundError(
+        `No mapping specified for phonetic algorithm`,
+        { algo }
+      );
     const map = PhoneticMappingRegistry.get(algo, mapId);
     if (map === undefined)
-      throw new Error(`Requested mapping <${mapId}> is not declared`);
-    this.options = DeepMerge.merge(
-      DeepMerge.merge(defaults, map.options ?? {}),
+      throw new Errors.CmpStrNotFoundError(
+        `Requested mapping <${mapId}> is not declared`,
+        { algo, mapId }
+      );
+    this.options = DeepMerge.DeepMerge.merge(
+      DeepMerge.DeepMerge.merge(defaults, map.options ?? {}),
       opt
     );
     this.optKey = HashTable.Hasher.fastFNV1a(
@@ -31,28 +42,32 @@ class Phonetic {
     ).toString();
     this.algo = algo;
     this.map = map;
+    this.ignoreSet = new Set(map.ignore ?? []);
   }
   applyPattern(word) {
     const { patterns = [] } = this.map;
-    if (!patterns || !patterns.length) return word;
+    if (!patterns.length) return word;
     for (const { pattern, replace, all = false } of patterns) {
-      word = word[all ? 'replaceAll' : 'replace'](pattern, replace);
+      word = all
+        ? word.replaceAll(pattern, replace)
+        : word.replace(pattern, replace);
     }
     return word;
   }
   applyRules(char, i, chars, charLen) {
     const { ruleset = [] } = this.map;
-    if (!ruleset || !ruleset.length) return undefined;
+    if (!ruleset.length) return undefined;
     const prev = chars[i - 1] || '',
       prev2 = chars[i - 2] || '';
     const next = chars[i + 1] || '',
       next2 = chars[i + 2] || '';
+    const str = chars.join('');
     for (const rule of ruleset) {
       if (rule.char && rule.char !== char) continue;
       if (rule.position === 'start' && i !== 0) continue;
       if (rule.position === 'middle' && (i === 0 || i === charLen - 1))
         continue;
-      if (rule.position === 'end' && i !== charLen) continue;
+      if (rule.position === 'end' && i !== charLen - 1) continue;
       if (rule.prev && !rule.prev.includes(prev)) continue;
       if (rule.prevNot && rule.prevNot.includes(prev)) continue;
       if (rule.prev2 && !rule.prev2.includes(prev2)) continue;
@@ -63,12 +78,12 @@ class Phonetic {
       if (rule.next2Not && rule.next2Not.includes(next2)) continue;
       if (
         rule.leading &&
-        !rule.leading.includes(chars.slice(0, rule.leading.length).join(''))
+        !rule.leading.includes(str.slice(0, rule.leading.length))
       )
         continue;
       if (
         rule.trailing &&
-        !rule.trailing.includes(chars.slice(-rule.trailing.length).join(''))
+        !rule.trailing.includes(str.slice(-rule.trailing.length))
       )
         continue;
       if (rule.match && !rule.match.every((c, j) => chars[i + j] === c))
@@ -78,7 +93,7 @@ class Phonetic {
     return undefined;
   }
   encode(word) {
-    const { map = {}, ignore = [] } = this.map;
+    const { map = {} } = this.map;
     word = this.applyPattern(word);
     const chars = this.word2Chars(word);
     const charLen = chars.length;
@@ -86,7 +101,7 @@ class Phonetic {
       lastCode = null;
     for (let i = 0; i < charLen; i++) {
       const char = chars[i];
-      if (ignore.includes(char)) continue;
+      if (this.ignoreSet.has(char)) continue;
       const mapped = this.mapChar(char, i, chars, charLen, lastCode, map);
       if (mapped === undefined) continue;
       ((code += mapped), (lastCode = mapped));
@@ -105,7 +120,9 @@ class Phonetic {
       ? input
       : (input + pad.repeat(length)).slice(0, length);
   }
-  word2Chars = (word) => word.toLowerCase().split('');
+  word2Chars(word) {
+    return Array.from(word.toLowerCase());
+  }
   exitEarly(code, i) {
     const { length = -1 } = this.options;
     return length > 0 && code.length >= length;
@@ -114,37 +131,52 @@ class Phonetic {
     return code;
   }
   loop(words) {
-    const index = [];
-    for (const word of words) {
-      const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
-      const code =
-        Phonetic.cache.get(key || '') ??
-        (() => {
-          const res = this.encode(word);
-          if (key) Phonetic.cache.set(key, res);
-          return res;
-        })();
-      if (code && code.length) index.push(this.equalLen(code));
-    }
-    return index;
+    return Errors.ErrorUtil.wrap(
+      () => {
+        const index = [];
+        for (const word of words) {
+          let key = Phonetic.cache.key(this.algo, [word]);
+          if (key) key += this.optKey;
+          const code =
+            Phonetic.cache.get(key || '') ??
+            (() => {
+              const res = this.encode(word);
+              if (key) Phonetic.cache.set(key, res);
+              return res;
+            })();
+          if (code && code.length) index.push(this.equalLen(code));
+        }
+        return index;
+      },
+      `Failed to generate phonetic index`,
+      { algo: this.algo, words }
+    );
   }
   async loopAsync(words) {
-    const index = [];
-    for (const word of words) {
-      const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
-      const code = await Promise.resolve(
-        Phonetic.cache.get(key || '') ??
-          (() => {
-            const res = this.encode(word);
-            if (key) Phonetic.cache.set(key, res);
-            return res;
-          })()
-      );
-      if (code && code.length) index.push(this.equalLen(code));
-    }
-    return index;
+    return Errors.ErrorUtil.wrapAsync(
+      async () => {
+        const index = [];
+        for (const word of words) {
+          const key = Phonetic.cache.key(this.algo, [word]) + this.optKey;
+          const code = await Promise.resolve(
+            Phonetic.cache.get(key || '') ??
+              (() => {
+                const res = this.encode(word);
+                if (key) Phonetic.cache.set(key, res);
+                return res;
+              })()
+          );
+          if (code && code.length) index.push(this.equalLen(code));
+        }
+        return index;
+      },
+      `Failed to generate phonetic index asynchronously`,
+      { algo: this.algo, words }
+    );
+  }
+  getAlgoName() {
+    return this.algo;
   }
-  getAlgoName = () => this.algo;
   getIndex(input) {
     const { delimiter = ' ' } = this.options;
     return profiler.run(() =>
@@ -167,10 +199,11 @@ const PhoneticMappingRegistry = (() => {
   return Object.freeze({
     add(algo, id, map, update = false) {
       const mappings = maps(algo);
-      if (!update && id in mappings)
-        throw new Error(
-          `Entry <${id}> already exists / use <update=true> to overwrite`
-        );
+      Errors.ErrorUtil.assert(
+        !(!id || id in mappings) || update,
+        `Entry <${id}> already exists / use <update=true> to overwrite`,
+        { algo, id }
+      );
       mappings[id] = map;
     },
     remove(algo, id) {
@@ -191,4 +224,3 @@ const PhoneticMappingRegistry = (() => {
 exports.Phonetic = Phonetic;
 exports.PhoneticMappingRegistry = PhoneticMappingRegistry;
 exports.PhoneticRegistry = PhoneticRegistry;
-//# sourceMappingURL=Phonetic.cjs.map

package/dist/cjs/phonetic/Soundex.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var Phonetic = require('./Phonetic.cjs');
@@ -86,4 +86,3 @@ Phonetic.PhoneticMappingRegistry.add('soundex', 'de', {
 });
 
 exports.Soundex = Soundex;
-//# sourceMappingURL=Soundex.cjs.map

package/dist/cjs/root.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 var CmpStr = require('./CmpStr.cjs');
@@ -24,8 +24,10 @@ require('./phonetic/Metaphone.cjs');
 require('./phonetic/Soundex.cjs');
 var Phonetic = require('./phonetic/Phonetic.cjs');
 var DeepMerge = require('./utils/DeepMerge.cjs');
+var Errors = require('./utils/Errors.cjs');
 var Filter = require('./utils/Filter.cjs');
 var HashTable = require('./utils/HashTable.cjs');
+var OptionsValidator = require('./utils/OptionsValidator.cjs');
 var Pool = require('./utils/Pool.cjs');
 var Profiler = require('./utils/Profiler.cjs');
 var StructuredData = require('./utils/StructuredData.cjs');
@@ -40,11 +42,12 @@ exports.MetricRegistry = Metric.MetricRegistry;
 exports.Phonetic = Phonetic.Phonetic;
 exports.PhoneticMappingRegistry = Phonetic.PhoneticMappingRegistry;
 exports.PhoneticRegistry = Phonetic.PhoneticRegistry;
-exports.DeepMerge = DeepMerge;
+exports.DeepMerge = DeepMerge.DeepMerge;
+exports.CmpStrError = Errors;
 exports.Filter = Filter.Filter;
 exports.HashTable = HashTable.HashTable;
 exports.Hasher = HashTable.Hasher;
+exports.OptionsValidator = OptionsValidator.OptionsValidator;
 exports.Pool = Pool.Pool;
 exports.Profiler = Profiler.Profiler;
 exports.StructuredData = StructuredData.StructuredData;
-//# sourceMappingURL=root.cjs.map

package/dist/cjs/utils/DeepMerge.cjs

@@ -1,108 +1,118 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
 'use strict';
 
-const BRACKET_PATTERN = /\[(\d+)]/g;
-const PATH_CACHE = new Map();
-function parse(p) {
-  let cached = PATH_CACHE.get(p);
-  if (cached) return cached;
-  const parsed = p
-    .replace(BRACKET_PATTERN, '.$1')
-    .split('.')
-    .map((s) => {
-      const n = Number(s);
-      return Number.isInteger(n) && String(n) === s ? n : s;
-    });
-  PATH_CACHE.set(p, parsed);
-  return parsed;
-}
-function get(t, path, fb) {
-  let o = t;
-  for (const k of parse(path)) {
-    if (o == null || !(k in o)) return fb;
-    o = o[k];
+var Errors = require('./Errors.cjs');
+
+class DeepMerge {
+  static BRACKET_PATTERN = /\[(\d+)]/g;
+  static PATH_CACHE = new Map();
+  static walk(obj, keys) {
+    let o = obj;
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      if (o == null || !(k in o)) return { exists: false };
+      o = o[k];
+    }
+    return { exists: true, value: o };
   }
-  return o;
-}
-function has(t, path) {
-  let o = t;
-  for (const k of parse(path)) {
-    if (o == null || !(k in o)) return false;
-    o = o[k];
+  static parse(p) {
+    const cached = DeepMerge.PATH_CACHE.get(p);
+    if (cached) return cached;
+    const parsed = p
+      .replace(DeepMerge.BRACKET_PATTERN, '.$1')
+      .split('.')
+      .map((s) => {
+        const n = Number(s);
+        return Number.isInteger(n) && String(n) === s ? n : s;
+      });
+    if (DeepMerge.PATH_CACHE.size > 2000) DeepMerge.PATH_CACHE.clear();
+    DeepMerge.PATH_CACHE.set(p, parsed);
+    return parsed;
   }
-  return true;
-}
-function set(t, path, value) {
-  if (path === '') return value;
-  const keys = parse(path);
-  if (t !== undefined && (typeof t !== 'object' || t === null))
-    throw Error(`Cannot set property <${keys[0]}> of <${JSON.stringify(t)}>`);
-  const root = t ?? (typeof keys[0] === 'number' ? [] : Object.create(null));
-  let cur = root;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const k = keys[i];
-    let n = cur[k];
-    if (n != null && typeof n !== 'object')
-      throw Error(
-        `Cannot set property <${keys[i + 1]}> of <${JSON.stringify(n)}>`
-      );
-    if (n == null)
-      n = cur[k] = typeof keys[i + 1] === 'number' ? [] : Object.create(null);
-    cur = n;
+  static has(t, path) {
+    return DeepMerge.walk(t, DeepMerge.parse(path)).exists;
   }
-  cur[keys[keys.length - 1]] = value;
-  return root;
-}
-function merge(
-  t = Object.create(null),
-  o = Object.create(null),
-  mergeUndefined = false
-) {
-  const target = t ?? Object.create(null);
-  Object.keys(o).forEach((k) => {
-    const val = o[k];
-    if (!mergeUndefined && val === undefined) return;
-    if (k === '__proto__' || k === 'constructor') return;
-    if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
-      const existing = target[k];
-      target[k] = merge(
-        existing !== null &&
-          typeof existing === 'object' &&
-          !Array.isArray(existing)
-          ? existing
-          : Object.create(null),
-        val,
-        mergeUndefined
+  static get(t, path, fb) {
+    const r = DeepMerge.walk(t, DeepMerge.parse(path));
+    return r.exists ? r.value : fb;
+  }
+  static set(t, path, value) {
+    if (path === '') return value;
+    const keys = DeepMerge.parse(path);
+    Errors.ErrorUtil.assert(
+      t === undefined || (typeof t === 'object' && t !== null),
+      `Cannot set property <${keys[0]}> of <${JSON.stringify(t)}>`,
+      { path: keys[0], target: t }
+    );
+    const root = t ?? (typeof keys[0] === 'number' ? [] : Object.create(null));
+    let cur = root;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      let n = cur[k];
+      Errors.ErrorUtil.assert(
+        n == null || typeof n === 'object',
+        `Cannot set property <${keys[i + 1]}> of <${JSON.stringify(n)}>`,
+        { path: keys.slice(0, i + 2), value: n }
       );
-    } else target[k] = val;
-  });
-  return target;
-}
-function rmv(t, path, preserveEmpty = false) {
-  const keys = parse(path);
-  const remove = (obj, i = 0) => {
-    const key = keys[i];
-    if (!obj || typeof obj !== 'object') return false;
-    if (i === keys.length - 1) return delete obj[key];
-    if (!remove(obj[key], i + 1)) return false;
-    if (!preserveEmpty) {
-      const val = obj[key];
-      if (
-        typeof val === 'object' &&
-        ((Array.isArray(val) && val.every((v) => v == null)) ||
-          (!Array.isArray(val) && Object.keys(val).length === 0))
-      )
-        delete obj[key];
+      if (n == null)
+        n = cur[k] = typeof keys[i + 1] === 'number' ? [] : Object.create(null);
+      cur = n;
+    }
+    cur[keys[keys.length - 1]] = value;
+    return root;
+  }
+  static rmv(t, path, preserveEmpty = false) {
+    const keys = DeepMerge.parse(path);
+    const remove = (obj, i = 0) => {
+      const key = keys[i];
+      if (!obj || typeof obj !== 'object') return false;
+      if (i === keys.length - 1) return delete obj[key];
+      if (!remove(obj[key], i + 1)) return false;
+      if (!preserveEmpty) {
+        const val = obj[key];
+        let empty = true;
+        if (typeof val === 'object') {
+          if (Array.isArray(val))
+            for (let i = 0; i < val.length; i++) {
+              if (val[i] != null) {
+                empty = false;
+                break;
+              }
+            }
+          else empty = false;
+        }
+        if (empty) delete obj[key];
+      }
+      return true;
+    };
+    remove(t);
+    return t;
+  }
+  static merge(
+    t = Object.create(null),
+    o = Object.create(null),
+    mergeUndefined = false
+  ) {
+    const target = t ?? Object.create(null);
+    for (const k in o) {
+      const val = o[k];
+      if (!mergeUndefined && val === undefined) continue;
+      if (k === '__proto__' || k === 'constructor') continue;
+      if (val !== null && typeof val === 'object' && !Array.isArray(val)) {
+        const existing = target[k];
+        target[k] = DeepMerge.merge(
+          existing !== null &&
+            typeof existing === 'object' &&
+            !Array.isArray(existing)
+            ? existing
+            : Object.create(null),
+          val,
+          mergeUndefined
+        );
+      } else target[k] = val;
     }
-    return true;
-  };
-  remove(t);
-  return t;
+    return target;
+  }
 }
 
-exports.get = get;
-exports.has = has;
-exports.merge = merge;
-exports.rmv = rmv;
-exports.set = set;
-//# sourceMappingURL=DeepMerge.cjs.map
+exports.DeepMerge = DeepMerge;

package/dist/cjs/utils/DiffChecker.cjs

@@ -1,4 +1,4 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
 'use strict';
 
 class DiffChecker {
@@ -297,4 +297,3 @@ class DiffChecker {
 }
 
 exports.DiffChecker = DiffChecker;
-//# sourceMappingURL=DiffChecker.cjs.map

package/dist/cjs/utils/Errors.cjs

@@ -0,0 +1,106 @@
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+'use strict';
+
+class CmpStrError extends Error {
+  code;
+  meta;
+  when = new Date().toISOString();
+  constructor(code, message, meta, cause) {
+    super(message, cause !== undefined ? { cause } : undefined);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.meta = meta;
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  format(stack = false) {
+    const parts = [`${this.name} [${this.code}]`, this.message];
+    if (this.meta)
+      for (const _ in this.meta) {
+        parts.push(JSON.stringify(this.meta));
+        break;
+      }
+    return (
+      parts.join(' - ') +
+      (stack && this.stack ? `\nStack Trace:\n${this.stack}` : '')
+    );
+  }
+  toString() {
+    return this.format(false);
+  }
+  toJSON(stack = false) {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      meta: this.meta,
+      when: this.when,
+      cause:
+        this.cause instanceof Error
+          ? {
+              name: this.cause.name,
+              message: this.cause.message,
+              stack: stack && this.cause.stack
+            }
+          : this.cause
+    };
+  }
+}
+class CmpStrValidationError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_VALIDATION', message, meta, cause);
+  }
+}
+class CmpStrNotFoundError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_NOT_FOUND', message, meta, cause);
+  }
+}
+class CmpStrUsageError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_USAGE', message, meta, cause);
+  }
+}
+class CmpStrInternalError extends CmpStrError {
+  constructor(message, meta, cause) {
+    super('E_INTERNAL', message, meta, cause);
+  }
+}
+class ErrorUtil {
+  static assert(condition, message, meta) {
+    if (!condition) throw new CmpStrUsageError(message, meta);
+  }
+  static rethrow(err, message, meta) {
+    if (err instanceof CmpStrError) throw err;
+    throw new CmpStrInternalError(message, meta, err);
+  }
+  static format(err) {
+    if (err instanceof CmpStrError) return err.toString();
+    if (err instanceof Error) return `${err.name}: ${err.message}`;
+    return String(err);
+  }
+  static wrap(fn, message, meta) {
+    try {
+      return fn();
+    } catch (err) {
+      if (err instanceof CmpStrError) throw err;
+      throw new CmpStrInternalError(message, meta, err);
+    }
+  }
+  static async wrapAsync(fn, message, meta) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (err instanceof CmpStrError) throw err;
+      throw new CmpStrInternalError(message, meta, err);
+    }
+  }
+}
+
+exports.CmpStrError = CmpStrError;
+exports.CmpStrInternalError = CmpStrInternalError;
+exports.CmpStrNotFoundError = CmpStrNotFoundError;
+exports.CmpStrUsageError = CmpStrUsageError;
+exports.CmpStrValidationError = CmpStrValidationError;
+exports.ErrorUtil = ErrorUtil;