cmpstr 3.2.1 → 3.3.0

package/dist/esm/utils/DeepMerge.mjs

@@ -1,102 +1,116 @@
-// CmpStr v3.2.1 build-3439ccb-260130 by Paul Köhler @komed3 / MIT License
-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];
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+import { ErrorUtil } from './Errors.mjs';
+
+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);
+    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];
+      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;
+  }
 }
 
-export { get, has, merge, rmv, set };
-//# sourceMappingURL=DeepMerge.mjs.map
+export { DeepMerge };

package/dist/esm/utils/DiffChecker.mjs

@@ -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
 class DiffChecker {
   a;
   b;
@@ -295,4 +295,3 @@ class DiffChecker {
 }
 
 export { DiffChecker };
-//# sourceMappingURL=DiffChecker.mjs.map

package/dist/esm/utils/Errors.mjs

@@ -0,0 +1,106 @@
+// CmpStr v3.3.0 build-3699f85-260318 by Paul Köhler @komed3 / MIT License
+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);
+    }
+  }
+}
+
+export {
+  CmpStrError,
+  CmpStrInternalError,
+  CmpStrNotFoundError,
+  CmpStrUsageError,
+  CmpStrValidationError,
+  ErrorUtil
+};

package/dist/esm/utils/Filter.mjs

@@ -1,47 +1,89 @@
-// 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
+import { ErrorUtil } from './Errors.mjs';
+
 class Filter {
+  static IDENTITY = (s) => s;
   static filters = new Map();
   static pipeline = new Map();
-  static getPipeline(hook) {
-    const cached = Filter.pipeline.get(hook);
-    if (cached) return cached;
-    const filter = Filter.filters.get(hook);
-    if (!filter) return (s) => s;
-    const pipeline = Array.from(filter.values())
-      .filter((f) => f.active)
-      .sort((a, b) => a.priority - b.priority)
-      .map((f) => f.fn);
-    const fn = (input) => pipeline.reduce((v, f) => f(v), input);
-    Filter.pipeline.set(hook, fn);
-    return fn;
+  static getPipeline(hook, force = false) {
+    return ErrorUtil.wrap(
+      () => {
+        if (!force) {
+          const cached = Filter.pipeline.get(hook);
+          if (cached) return cached;
+        }
+        const filter = Filter.filters.get(hook);
+        if (!filter) {
+          Filter.pipeline.set(hook, Filter.IDENTITY);
+          return Filter.IDENTITY;
+        }
+        const pipeline = [];
+        for (const f of filter.values()) if (f.active) pipeline.push(f);
+        pipeline.sort((a, b) => a.priority - b.priority);
+        const fn =
+          pipeline.length === 0
+            ? Filter.IDENTITY
+            : (input) => {
+                let v = input;
+                for (let i = 0; i < pipeline.length; i++) v = pipeline[i].fn(v);
+                return v;
+              };
+        Filter.pipeline.set(hook, fn);
+        return fn;
+      },
+      `Error compiling filter pipeline for hook <${hook}>`,
+      { hook }
+    );
   }
   static has(hook, id) {
     return !!Filter.filters.get(hook)?.has(id);
   }
   static add(hook, id, fn, opt = {}) {
-    const { priority = 10, active = true, overrideable = true } = opt;
-    const filter = Filter.filters.get(hook) ?? new Map();
-    const index = filter.get(id);
-    if (index && !index.overrideable) return false;
-    filter.set(id, { id, fn, priority, active, overrideable });
-    Filter.filters.set(hook, filter);
-    Filter.pipeline.delete(hook);
-    return true;
+    return ErrorUtil.wrap(
+      () => {
+        const { priority = 10, active = true, overrideable = true } = opt;
+        const filter = Filter.filters.get(hook) ?? new Map();
+        const index = filter.get(id);
+        if (index && !index.overrideable) return false;
+        if (
+          index &&
+          index.fn === fn &&
+          index.priority === priority &&
+          index.active === active
+        )
+          return true;
+        filter.set(id, { id, fn, priority, active, overrideable });
+        Filter.filters.set(hook, filter);
+        Filter.getPipeline(hook, true);
+        return true;
+      },
+      `Error adding filter <${id}> to hook <${hook}>`,
+      { hook, id, opt }
+    );
   }
   static remove(hook, id) {
-    Filter.pipeline.delete(hook);
     const filter = Filter.filters.get(hook);
-    return filter ? filter.delete(id) : false;
+    if (!filter || !filter.delete(id)) return false;
+    Filter.getPipeline(hook, true);
+    return true;
   }
   static pause(hook, id) {
-    Filter.pipeline.delete(hook);
-    const f = Filter.filters.get(hook)?.get(id);
-    return !!(f && ((f.active = false), true));
+    const filter = Filter.filters.get(hook);
+    if (!filter) return false;
+    const f = filter.get(id);
+    if (!f || !f.active) return false;
+    f.active = false;
+    Filter.getPipeline(hook, true);
+    return true;
   }
   static resume(hook, id) {
-    Filter.pipeline.delete(hook);
-    const f = Filter.filters.get(hook)?.get(id);
-    return !!(f && ((f.active = true), true));
+    const filter = Filter.filters.get(hook);
+    if (!filter) return false;
+    const f = filter.get(id);
+    if (!f || f.active) return false;
+    f.active = true;
+    Filter.getPipeline(hook, true);
+    return true;
   }
   static list(hook, active = false) {
     const filter = Filter.filters.get(hook);
@@ -51,17 +93,36 @@ class Filter {
     return out;
   }
   static apply(hook, input) {
-    const fn = Filter.getPipeline(hook);
-    return Array.isArray(input) ? input.map(fn) : fn(input);
+    return ErrorUtil.wrap(
+      () => {
+        const fn = Filter.getPipeline(hook);
+        if (typeof input === 'string') return fn(input);
+        const arr = input;
+        const out = new Array(arr.length);
+        for (let i = 0; i < arr.length; i++) out[i] = fn(arr[i]);
+        return out;
+      },
+      `Error applying filters for hook <${hook}>`,
+      { hook, input }
+    );
   }
   static async applyAsync(hook, input) {
-    const fn = Filter.getPipeline(hook);
-    return Array.isArray(input)
-      ? Promise.all(input.map(fn))
-      : Promise.resolve(fn(input));
+    return ErrorUtil.wrapAsync(
+      async () => {
+        const fn = Filter.getPipeline(hook);
+        if (typeof input === 'string') return Promise.resolve(fn(input));
+        const arr = input;
+        const out = new Array(arr.length);
+        for (let i = 0; i < arr.length; i++)
+          out[i] = Promise.resolve(fn(arr[i]));
+        return Promise.all(out);
+      },
+      `Error applying filters for hook <${hook}>`,
+      { hook, input }
+    );
   }
   static clear(hook) {
-    Filter.pipeline.clear();
+    Filter.clearPipeline();
     if (hook) Filter.filters.delete(hook);
     else Filter.filters.clear();
   }
@@ -71,4 +132,3 @@ class Filter {
 }
 
 export { Filter };
-//# sourceMappingURL=Filter.mjs.map

package/dist/esm/utils/HashTable.mjs

@@ -1,28 +1,24 @@
-// 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
 class Hasher {
   static FNV_PRIME = 0x01000193;
   static HASH_OFFSET = 0x811c9dc5;
   static fastFNV1a(str) {
     const len = str.length;
+    const limit = len & -4;
     let hash = this.HASH_OFFSET;
-    const chunks = Math.floor(len / 4);
-    for (let i = 0; i < chunks; i++) {
-      const pos = i * 4;
+    let i = 0;
+    for (; i < limit; i += 4) {
       const chunk =
-        str.charCodeAt(pos) |
-        (str.charCodeAt(pos + 1) << 8) |
-        (str.charCodeAt(pos + 2) << 16) |
-        (str.charCodeAt(pos + 3) << 24);
+        str.charCodeAt(i) |
+        (str.charCodeAt(i + 1) << 8) |
+        (str.charCodeAt(i + 2) << 16) |
+        (str.charCodeAt(i + 3) << 24);
       hash ^= chunk;
       hash = Math.imul(hash, this.FNV_PRIME);
     }
-    const remaining = len % 4;
-    if (remaining > 0) {
-      const pos = chunks * 4;
-      for (let i = 0; i < remaining; i++) {
-        hash ^= str.charCodeAt(pos + i);
-        hash = Math.imul(hash, this.FNV_PRIME);
-      }
+    for (; i < len; i++) {
+      hash ^= str.charCodeAt(i);
+      hash = Math.imul(hash, this.FNV_PRIME);
     }
     hash ^= hash >>> 16;
     hash *= 0x85ebca6b;
@@ -33,33 +29,51 @@ class Hasher {
   }
 }
 class HashTable {
-  LRU;
+  FIFO;
+  maxSize;
   static MAX_LEN = 2048;
-  static TABLE_SIZE = 10_000;
   table = new Map();
-  constructor(LRU = true) {
-    this.LRU = LRU;
+  constructor(FIFO = true, maxSize = 10000) {
+    this.FIFO = FIFO;
+    this.maxSize = maxSize;
   }
   key(label, strs, sorted = false) {
-    for (const str of strs) if (str.length > HashTable.MAX_LEN) return false;
-    const hashes = strs.map((s) => Hasher.fastFNV1a(s));
-    return [label, ...(sorted ? hashes.sort() : hashes)].join('-');
+    const n = strs.length;
+    const hashes = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const s = strs[i];
+      if (s.length > HashTable.MAX_LEN) return false;
+      hashes[i] = Hasher.fastFNV1a(s);
+    }
+    if (sorted) hashes.sort((a, b) => a - b);
+    let key = label;
+    for (let i = 0; i < hashes.length; i++) key += '-' + hashes[i];
+    return key;
+  }
+  has(key) {
+    return this.table.has(key);
+  }
+  get(key) {
+    return this.table.get(key);
   }
-  has = (key) => this.table.has(key);
-  get = (key) => this.table.get(key);
   set(key, entry, update = true) {
     if (!update && this.table.has(key)) return false;
-    while (!this.table.has(key) && this.table.size >= HashTable.TABLE_SIZE) {
-      if (!this.LRU) return false;
+    if (!this.table.has(key) && this.table.size >= this.maxSize) {
+      if (!this.FIFO) return false;
       this.table.delete(this.table.keys().next().value);
     }
     this.table.set(key, entry);
     return true;
   }
-  delete = (key) => this.table.delete(key);
-  clear = () => this.table.clear();
-  size = () => this.table.size;
+  delete(key) {
+    return this.table.delete(key);
+  }
+  clear() {
+    this.table.clear();
+  }
+  size() {
+    return this.table.size;
+  }
 }
 
 export { HashTable, Hasher };
-//# sourceMappingURL=HashTable.mjs.map