serializable-bptree 4.0.1 → 4.0.3

package/dist/esm/index.mjs

@@ -27,371 +27,6 @@ var StringComparator = class extends ValueComparator {
   }
 };
 
-// node_modules/cachebranch/dist/esm/index.mjs
-var CacheBranch = class {
-  data;
-  branches;
-  constructor(data) {
-    this.data = data;
-    this.branches = /* @__PURE__ */ new Map();
-  }
-  /**
-   * The method splits the provided key value into tokens and returns them as an array.
-   * For instance, if you pass `'user/name/middle'` as the parameter, it will return `['user', 'name', 'middle']` as the split values.
-   * @param key The key value to split.
-   */
-  tokens(key) {
-    return key.split("/");
-  }
-  to(key, getNextBranch) {
-    const tokens = this.tokens(key);
-    let current = this;
-    for (let i = 0, len = tokens.length; i < len; i++) {
-      const last = i === len - 1;
-      const key2 = tokens[i];
-      const next = getNextBranch(current, key2, i, last);
-      if (next === null) {
-        return void 0;
-      }
-      current = next;
-    }
-    return current;
-  }
-};
-var VOID = -1;
-var PRIMITIVE = 0;
-var ARRAY = 1;
-var OBJECT = 2;
-var DATE = 3;
-var REGEXP = 4;
-var MAP = 5;
-var SET = 6;
-var ERROR = 7;
-var BIGINT = 8;
-var env = typeof self === "object" ? self : globalThis;
-var deserializer = ($, _) => {
-  const as = (out, index) => {
-    $.set(index, out);
-    return out;
-  };
-  const unpair = (index) => {
-    if ($.has(index))
-      return $.get(index);
-    const [type, value] = _[index];
-    switch (type) {
-      case PRIMITIVE:
-      case VOID:
-        return as(value, index);
-      case ARRAY: {
-        const arr = as([], index);
-        for (const index2 of value)
-          arr.push(unpair(index2));
-        return arr;
-      }
-      case OBJECT: {
-        const object = as({}, index);
-        for (const [key, index2] of value)
-          object[unpair(key)] = unpair(index2);
-        return object;
-      }
-      case DATE:
-        return as(new Date(value), index);
-      case REGEXP: {
-        const { source, flags } = value;
-        return as(new RegExp(source, flags), index);
-      }
-      case MAP: {
-        const map = as(/* @__PURE__ */ new Map(), index);
-        for (const [key, index2] of value)
-          map.set(unpair(key), unpair(index2));
-        return map;
-      }
-      case SET: {
-        const set = as(/* @__PURE__ */ new Set(), index);
-        for (const index2 of value)
-          set.add(unpair(index2));
-        return set;
-      }
-      case ERROR: {
-        const { name, message } = value;
-        return as(new env[name](message), index);
-      }
-      case BIGINT:
-        return as(BigInt(value), index);
-      case "BigInt":
-        return as(Object(BigInt(value)), index);
-    }
-    return as(new env[type](value), index);
-  };
-  return unpair;
-};
-var deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
-var EMPTY = "";
-var { toString } = {};
-var { keys } = Object;
-var typeOf = (value) => {
-  const type = typeof value;
-  if (type !== "object" || !value)
-    return [PRIMITIVE, type];
-  const asString = toString.call(value).slice(8, -1);
-  switch (asString) {
-    case "Array":
-      return [ARRAY, EMPTY];
-    case "Object":
-      return [OBJECT, EMPTY];
-    case "Date":
-      return [DATE, EMPTY];
-    case "RegExp":
-      return [REGEXP, EMPTY];
-    case "Map":
-      return [MAP, EMPTY];
-    case "Set":
-      return [SET, EMPTY];
-  }
-  if (asString.includes("Array"))
-    return [ARRAY, asString];
-  if (asString.includes("Error"))
-    return [ERROR, asString];
-  return [OBJECT, asString];
-};
-var shouldSkip = ([TYPE, type]) => TYPE === PRIMITIVE && (type === "function" || type === "symbol");
-var serializer = (strict, json, $, _) => {
-  const as = (out, value) => {
-    const index = _.push(out) - 1;
-    $.set(value, index);
-    return index;
-  };
-  const pair = (value) => {
-    if ($.has(value))
-      return $.get(value);
-    let [TYPE, type] = typeOf(value);
-    switch (TYPE) {
-      case PRIMITIVE: {
-        let entry = value;
-        switch (type) {
-          case "bigint":
-            TYPE = BIGINT;
-            entry = value.toString();
-            break;
-          case "function":
-          case "symbol":
-            if (strict)
-              throw new TypeError("unable to serialize " + type);
-            entry = null;
-            break;
-          case "undefined":
-            return as([VOID], value);
-        }
-        return as([TYPE, entry], value);
-      }
-      case ARRAY: {
-        if (type)
-          return as([type, [...value]], value);
-        const arr = [];
-        const index = as([TYPE, arr], value);
-        for (const entry of value)
-          arr.push(pair(entry));
-        return index;
-      }
-      case OBJECT: {
-        if (type) {
-          switch (type) {
-            case "BigInt":
-              return as([type, value.toString()], value);
-            case "Boolean":
-            case "Number":
-            case "String":
-              return as([type, value.valueOf()], value);
-          }
-        }
-        if (json && "toJSON" in value)
-          return pair(value.toJSON());
-        const entries = [];
-        const index = as([TYPE, entries], value);
-        for (const key of keys(value)) {
-          if (strict || !shouldSkip(typeOf(value[key])))
-            entries.push([pair(key), pair(value[key])]);
-        }
-        return index;
-      }
-      case DATE:
-        return as([TYPE, value.toISOString()], value);
-      case REGEXP: {
-        const { source, flags } = value;
-        return as([TYPE, { source, flags }], value);
-      }
-      case MAP: {
-        const entries = [];
-        const index = as([TYPE, entries], value);
-        for (const [key, entry] of value) {
-          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
-            entries.push([pair(key), pair(entry)]);
-        }
-        return index;
-      }
-      case SET: {
-        const entries = [];
-        const index = as([TYPE, entries], value);
-        for (const entry of value) {
-          if (strict || !shouldSkip(typeOf(entry)))
-            entries.push(pair(entry));
-        }
-        return index;
-      }
-    }
-    const { message } = value;
-    return as([TYPE, { name: type, message }], value);
-  };
-  return pair;
-};
-var serialize = (value, { json, lossy } = {}) => {
-  const _ = [];
-  return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
-};
-var esm_default = typeof structuredClone === "function" ? (
-  /* c8 ignore start */
-  (any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any)
-) : (any, options) => deserialize(serialize(any, options));
-var CacheData = class _CacheData {
-  static IsDirty(data) {
-    return data.dirty;
-  }
-  static SetDirty(data, value) {
-    data.dirty = value;
-    return data;
-  }
-  static StructuredClone = globalThis.structuredClone ?? esm_default;
-  _raw;
-  generator;
-  dirty;
-  constructor(generator) {
-    this._raw = void 0;
-    this.dirty = false;
-    this.generator = generator;
-  }
-  /**
-   * This is cached data.
-   * It was generated at the time of caching, so there is a risk of modification if it's an object due to shallow copying.
-   * Therefore, if it's not a primitive type, please avoid using this value directly and use the `clone` method to use a copied version of the data.
-   */
-  get raw() {
-    if (!this.dirty) {
-      throw new Error(`The data is not initialized and cannot be accessed. Please use the 'ensure' or 'set' method to create the data first.`);
-    }
-    return this._raw;
-  }
-  /**
-   * The method returns a copied value of the cached data.
-   * You can pass a function as a parameter to copy the value. This parameter function should return the copied value.
-   * 
-   * If no parameter is passed, it defaults to using Javascript's or \@ungap/structured-clone's `structuredClone` function to copy the value.
-   * If you prefer shallow copying instead of deep copying,
-   * you can use the default options `array-shallow-copy`, `object-shallow-copy` and `deep-copy`,
-   * which are replaced with functions to shallow copy arrays and objects, respectively. This is a syntactic sugar.
-   * @param strategy The function that returns the copied value.
-   * If you want to perform a shallow copy, simply pass the strings `array-shallow-copy` or `object-shallow-copy` for easy use.
-   * The default is `structuredClone`.
-   */
-  clone(strategy = "deep-copy") {
-    if (strategy && typeof strategy !== "string") {
-      return strategy(this.raw);
-    }
-    switch (strategy) {
-      case "array-shallow-copy":
-        return [].concat(this.raw);
-      case "object-shallow-copy":
-        return Object.assign({}, this.raw);
-      case "deep-copy":
-      default:
-        return _CacheData.StructuredClone(this.raw);
-    }
-  }
-};
-var CacheDataSync = class extends CacheData {
-  static EmptyDataGenerator = () => void 0;
-  static Update(branch, data, generator) {
-    data._raw = generator(branch);
-    data.generator = generator;
-    data.dirty = true;
-    return data;
-  }
-  static Cache(branch, data) {
-    data._raw = data.generator(branch);
-    return data;
-  }
-};
-var CacheBranchSync = class _CacheBranchSync extends CacheBranch {
-  root;
-  constructor(generator = CacheDataSync.EmptyDataGenerator, root) {
-    super(new CacheDataSync(generator));
-    this.root = root ?? this;
-  }
-  ensureBranch(key, generator) {
-    return this.to(key, (b, k) => {
-      const branch = b;
-      if (!branch.branches.has(k)) {
-        branch.branches.set(k, new _CacheBranchSync(generator, this.root));
-      }
-      return branch.branches.get(k);
-    });
-  }
-  getBranch(key) {
-    return this.to(key, (b, k) => {
-      const branch = b;
-      if (!branch.branches.has(k)) {
-        return null;
-      }
-      return branch.branches.get(k);
-    });
-  }
-  cache(key, recursive) {
-    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
-    if (!branch) {
-      return this;
-    }
-    if (recursive === "bottom-up") {
-      for (const key2 of branch.branches.keys()) {
-        branch.cache(key2, recursive);
-      }
-    }
-    CacheDataSync.Cache(this.root, branch.data);
-    if (recursive === "top-down") {
-      for (const key2 of branch.branches.keys()) {
-        branch.cache(key2, recursive);
-      }
-    }
-    return this;
-  }
-  ensure(key, generator) {
-    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
-    if (!CacheDataSync.IsDirty(branch.data)) {
-      CacheDataSync.Update(this.root, branch.data, generator);
-    }
-    return branch.data;
-  }
-  get(key) {
-    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
-    if (!CacheDataSync.IsDirty(branch.data)) {
-      return void 0;
-    }
-    return branch.data;
-  }
-  set(key, generator) {
-    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
-    CacheDataSync.Update(this.root, branch.data, generator);
-    return this;
-  }
-  delete(key) {
-    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
-    if (branch) {
-      branch.branches.clear();
-      CacheDataSync.Update(this.root, branch.data, CacheDataSync.EmptyDataGenerator);
-      CacheDataSync.SetDirty(branch.data, false);
-    }
-    return this;
-  }
-};
-
 // src/utils/InvertedWeakMap.ts
 var InvertedWeakMap = class {
   _map;
@@ -446,10 +81,12 @@ var BPTree = class {
     like: (nv, v) => {
       const nodeValue = this.comparator.match(nv);
       const value = this.comparator.match(v);
-      const regexp = this._cachedRegexp.ensure(value, () => {
+      if (!this._cachedRegexp.has(value)) {
         const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
-        return new RegExp(`^${pattern}$`, "i");
-      }).raw;
+        const regexp2 = new RegExp(`^${pattern}$`, "i");
+        this._cachedRegexp.set(value, regexp2);
+      }
+      const regexp = this._cachedRegexp.get(value);
       return regexp.test(nodeValue);
     }
   };
@@ -481,7 +118,7 @@ var BPTree = class {
     like: true
   };
   constructor(strategy, comparator) {
-    this._cachedRegexp = new CacheBranchSync();
+    this._cachedRegexp = new InvertedWeakMap();
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
     this._nodeDeleteBuffer = /* @__PURE__ */ new Map();
@@ -494,8 +131,8 @@ var BPTree = class {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         if (this.comparator.isSame(value, nValue)) {
-          const keys2 = node.keys[i];
-          keys2.push(key);
+          const keys = node.keys[i];
+          keys.push(key);
           this.bufferForNodeUpdate(node);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
@@ -549,12 +186,12 @@ var BPTreeSync = class extends BPTree {
       let i = node.values.length;
       while (i--) {
         const nValue = node.values[i];
-        const keys2 = node.keys[i];
+        const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          let j = keys2.length;
+          let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys2[j], value: nValue });
+            pairs.push({ key: keys[j], value: nValue });
           }
         } else if (found && !fullScan) {
           done = true;
@@ -577,10 +214,10 @@ var BPTreeSync = class extends BPTree {
     while (!done) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
-        const keys2 = node.keys[i];
+        const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys2) {
+          for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
         } else if (found && !fullScan) {
@@ -613,11 +250,11 @@ var BPTreeSync = class extends BPTree {
     }
     return id;
   }
-  _createNode(isLeaf, keys2, values, leaf = false, parent = null, next = null, prev = null) {
+  _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
     const id = this._createNodeId(isLeaf);
     const node = {
       id,
-      keys: keys2,
+      keys,
       values,
       leaf,
       parent,
@@ -647,9 +284,9 @@ var BPTreeSync = class extends BPTree {
       }
     }
     if (this.root === node && node.keys.length === 1) {
-      const keys2 = node.keys;
+      const keys = node.keys;
       this.bufferForNodeDelete(this.root);
-      this.root = this.getNode(keys2[0]);
+      this.root = this.getNode(keys[0]);
       this.root.parent = null;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
@@ -723,8 +360,8 @@ var BPTreeSync = class extends BPTree {
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {
-          const keys2 = pointer.keys;
-          for (const key2 of keys2) {
+          const keys = pointer.keys;
+          for (const key2 of keys) {
             const node2 = this.getNode(key2);
             node2.parent = pointer.id;
             this.bufferForNodeUpdate(node2);
@@ -924,8 +561,8 @@ var BPTreeSync = class extends BPTree {
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      const keys2 = node.keys;
-      node = this.getNode(keys2[0]);
+      const keys = node.keys;
+      node = this.getNode(keys[0]);
     }
     return node;
   }
@@ -1036,17 +673,17 @@ var BPTreeSync = class extends BPTree {
     while (i--) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys2 = node.keys[i];
-        if (keys2.includes(key)) {
-          if (keys2.length > 1) {
-            keys2.splice(keys2.indexOf(key), 1);
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          if (keys.length > 1) {
+            keys.splice(keys.indexOf(key), 1);
             this.bufferForNodeUpdate(node);
           } else if (node === this.root) {
             node.values.splice(i, 1);
             node.keys.splice(i, 1);
             this.bufferForNodeUpdate(node);
           } else {
-            keys2.splice(keys2.indexOf(key), 1);
+            keys.splice(keys.indexOf(key), 1);
             node.keys.splice(i, 1);
             node.values.splice(node.values.indexOf(value), 1);
             this._deleteEntry(node, key, value);
@@ -1065,8 +702,8 @@ var BPTreeSync = class extends BPTree {
     for (let i = 0, len = node.values.length; i < len; i++) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys2 = node.keys[i];
-        return keys2.includes(key);
+        const keys = node.keys[i];
+        return keys.includes(key);
       }
     }
     return false;
@@ -1076,13 +713,13 @@ var BPTreeSync = class extends BPTree {
     this.commitHeadBuffer();
   }
   forceUpdate() {
-    const keys2 = [...this.nodes.keys()];
+    const keys = [...this.nodes.keys()];
     this.nodes.clear();
     this.init();
-    for (const key of keys2) {
+    for (const key of keys) {
       this.getNode(key);
     }
-    return keys2.length;
+    return keys.length;
   }
 };
 
@@ -1100,12 +737,12 @@ var BPTreeAsync = class extends BPTree {
       let i = node.values.length;
       while (i--) {
         const nValue = node.values[i];
-        const keys2 = node.keys[i];
+        const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          let j = keys2.length;
+          let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys2[j], value: nValue });
+            pairs.push({ key: keys[j], value: nValue });
           }
         } else if (found && !fullScan) {
           done = true;
@@ -1128,10 +765,10 @@ var BPTreeAsync = class extends BPTree {
     while (!done) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
-        const keys2 = node.keys[i];
+        const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys2) {
+          for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
         } else if (found && !fullScan) {
@@ -1164,11 +801,11 @@ var BPTreeAsync = class extends BPTree {
     }
     return id;
   }
-  async _createNode(isLeaf, keys2, values, leaf = false, parent = null, next = null, prev = null) {
+  async _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
     const id = await this._createNodeId(isLeaf);
     const node = {
       id,
-      keys: keys2,
+      keys,
       values,
       leaf,
       parent,
@@ -1198,9 +835,9 @@ var BPTreeAsync = class extends BPTree {
       }
     }
     if (this.root === node && node.keys.length === 1) {
-      const keys2 = node.keys;
+      const keys = node.keys;
       this.bufferForNodeDelete(this.root);
-      this.root = await this.getNode(keys2[0]);
+      this.root = await this.getNode(keys[0]);
       this.root.parent = null;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
@@ -1274,8 +911,8 @@ var BPTreeAsync = class extends BPTree {
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {
-          const keys2 = pointer.keys;
-          for (const key2 of keys2) {
+          const keys = pointer.keys;
+          for (const key2 of keys) {
             const node2 = await this.getNode(key2);
             node2.parent = pointer.id;
             this.bufferForNodeUpdate(node2);
@@ -1475,8 +1112,8 @@ var BPTreeAsync = class extends BPTree {
   async leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      const keys2 = node.keys;
-      node = await this.getNode(keys2[0]);
+      const keys = node.keys;
+      node = await this.getNode(keys[0]);
     }
     return node;
   }
@@ -1587,17 +1224,17 @@ var BPTreeAsync = class extends BPTree {
     while (i--) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys2 = node.keys[i];
-        if (keys2.includes(key)) {
-          if (keys2.length > 1) {
-            keys2.splice(keys2.indexOf(key), 1);
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          if (keys.length > 1) {
+            keys.splice(keys.indexOf(key), 1);
             this.bufferForNodeUpdate(node);
           } else if (node === this.root) {
             node.values.splice(i, 1);
             node.keys.splice(i, 1);
             this.bufferForNodeUpdate(node);
           } else {
-            keys2.splice(keys2.indexOf(key), 1);
+            keys.splice(keys.indexOf(key), 1);
             node.keys.splice(i, 1);
             node.values.splice(node.values.indexOf(value), 1);
             await this._deleteEntry(node, key, value);
@@ -1616,8 +1253,8 @@ var BPTreeAsync = class extends BPTree {
     for (let i = 0, len = node.values.length; i < len; i++) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys2 = node.keys[i];
-        return keys2.includes(key);
+        const keys = node.keys[i];
+        return keys.includes(key);
       }
     }
     return false;
@@ -1627,13 +1264,13 @@ var BPTreeAsync = class extends BPTree {
     await this.commitHeadBuffer();
   }
   async forceUpdate() {
-    const keys2 = [...this.nodes.keys()];
+    const keys = [...this.nodes.keys()];
     this.nodes.clear();
     await this.init();
-    for (const key of keys2) {
+    for (const key of keys) {
       await this.getNode(key);
     }
-    return keys2.length;
+    return keys.length;
   }
 };
 

package/dist/{typings → types}/base/BPTree.d.ts

@@ -96,19 +96,19 @@ export declare abstract class BPTree<K, V> {
     /**
      * You enter the key and value as a pair. You can later search for the pair by value.
      * This data is stored in the tree, sorted in ascending order of value.
-     * @param key The key of the pair.
+     * @param key The key of the pair. This key must be unique.
      * @param value The value of the pair.
      */
     abstract insert(key: K, value: V): Deferred<void>;
     /**
      * Deletes the pair that matches the key and value.
-     * @param key The key of the pair.
+     * @param key The key of the pair. This key must be unique.
      * @param value The value of the pair.
      */
     abstract delete(key: K, value: V): Deferred<void>;
     /**
      * It returns whether there is a value in the tree.
-     * @param key The key value to search for.
+     * @param key The key value to search for. This key must be unique.
      * @param value The value to search for.
      */
     abstract exists(key: K, value: V): Deferred<boolean>;