serializable-bptree 1.0.3 → 1.0.4

package/dist/cjs/index.js

@@ -321,6 +321,124 @@ var BPTree = class {
   _rangeCondition(condition) {
     return Object.prototype.hasOwnProperty.call(condition, "gt") && Object.prototype.hasOwnProperty.call(condition, "lt");
   }
+  _getKeysFromValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    const node = this._insertableNode(value);
+    const [start, end] = this.search.range(node.values, value);
+    if (start === -1) {
+      return keys;
+    }
+    for (let i = start; i < end; i++) {
+      const pairKeys = node.keys[i];
+      for (const key of pairKeys) {
+        keys.add(key);
+      }
+    }
+    return keys;
+  }
+  _getKeysFromNEValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const pairKeys = node.keys[i];
+        if (this.comparator.isSame(nValue, value) === false) {
+          for (const key of pairKeys) {
+            keys.add(key);
+          }
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromRange(gt, lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromGt(gt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromLt(lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
   _getPairsFromValue(value) {
     const node = this._insertableNode(value);
     const [start, end] = this.search.range(node.values, value);
@@ -439,6 +557,28 @@ var BPTree = class {
     }
     return pairs;
   }
+  /**
+   * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.  
+   * The result is key set instance, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * This method operates much faster than first searching with `where` and then retrieving only the key list.
+   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   */
+  keys(condition) {
+    if (this._equalCondition(condition)) {
+      return this._getKeysFromValue(condition.equal);
+    } else if (this._notEqualCondition(condition)) {
+      return this._getKeysFromNEValue(condition.notEqual);
+    } else if (this._rangeCondition(condition)) {
+      const { gt, lt } = condition;
+      return this._getKeysFromRange(gt, lt);
+    } else if (this._onlyGtCondition(condition)) {
+      return this._getKeysFromGt(condition.gt);
+    } else if (this._onlyLtCondition(condition)) {
+      return this._getKeysFromLt(condition.lt);
+    } else {
+      throw new Error(`The 'condition' parameter is invalid.`);
+    }
+  }
   /**
    * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.  
    * The result includes the key and value attributes, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.

package/dist/esm/index.js

@@ -290,6 +290,124 @@ var BPTree = class {
   _rangeCondition(condition) {
     return Object.prototype.hasOwnProperty.call(condition, "gt") && Object.prototype.hasOwnProperty.call(condition, "lt");
   }
+  _getKeysFromValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    const node = this._insertableNode(value);
+    const [start, end] = this.search.range(node.values, value);
+    if (start === -1) {
+      return keys;
+    }
+    for (let i = start; i < end; i++) {
+      const pairKeys = node.keys[i];
+      for (const key of pairKeys) {
+        keys.add(key);
+      }
+    }
+    return keys;
+  }
+  _getKeysFromNEValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const pairKeys = node.keys[i];
+        if (this.comparator.isSame(nValue, value) === false) {
+          for (const key of pairKeys) {
+            keys.add(key);
+          }
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromRange(gt, lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromGt(gt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromLt(lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
   _getPairsFromValue(value) {
     const node = this._insertableNode(value);
     const [start, end] = this.search.range(node.values, value);
@@ -408,6 +526,28 @@ var BPTree = class {
     }
     return pairs;
   }
+  /**
+   * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.  
+   * The result is key set instance, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * This method operates much faster than first searching with `where` and then retrieving only the key list.
+   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   */
+  keys(condition) {
+    if (this._equalCondition(condition)) {
+      return this._getKeysFromValue(condition.equal);
+    } else if (this._notEqualCondition(condition)) {
+      return this._getKeysFromNEValue(condition.notEqual);
+    } else if (this._rangeCondition(condition)) {
+      const { gt, lt } = condition;
+      return this._getKeysFromRange(gt, lt);
+    } else if (this._onlyGtCondition(condition)) {
+      return this._getKeysFromGt(condition.gt);
+    } else if (this._onlyLtCondition(condition)) {
+      return this._getKeysFromLt(condition.lt);
+    } else {
+      throw new Error(`The 'condition' parameter is invalid.`);
+    }
+  }
   /**
    * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.  
    * The result includes the key and value attributes, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.

package/dist/typings/BPTree.d.ts

@@ -70,11 +70,23 @@ export declare class BPTree<K, V> {
     private _onlyGtCondition;
     private _onlyLtCondition;
     private _rangeCondition;
+    private _getKeysFromValue;
+    private _getKeysFromNEValue;
+    private _getKeysFromRange;
+    private _getKeysFromGt;
+    private _getKeysFromLt;
     private _getPairsFromValue;
     private _getPairsFromNEValue;
     private _getPairsFromRange;
     private _getPairsFromGt;
     private _getPairsFromLt;
+    /**
+     * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.
+     * The result is key set instance, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+     * This method operates much faster than first searching with `where` and then retrieving only the key list.
+     * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+     */
+    keys(condition: BPTreeCondition<V>): Set<K>;
     /**
      * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.
      * The result includes the key and value attributes, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",