serializable-bptree 2.0.0 → 3.0.0

package/dist/typings/BPTreeAsync.d.ts

@@ -0,0 +1,45 @@
+import type { Json } from './utils/types';
+import { BPTree, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
+import { SerializeStrategyAsync } from './SerializeStrategyAsync';
+import { ValueComparator } from './ValueComparator';
+export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
+    protected readonly strategy: SerializeStrategyAsync<K, V>;
+    constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>);
+    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
+    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): Promise<BPTreePair<K, V>[]>;
+    protected _createNodeId(): Promise<number>;
+    protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Promise<BPTreeUnknownNode<K, V>>;
+    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<void>;
+    protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Promise<void>;
+    init(): Promise<void>;
+    protected getNode(id: number): Promise<BPTreeUnknownNode<K, V>>;
+    protected insertableNode(value: V): Promise<BPTreeLeafNode<K, V>>;
+    protected leftestNode(): Promise<BPTreeLeafNode<K, V>>;
+    protected commitHeadBuffer(): Promise<void>;
+    protected commitNodeCreateBuffer(): Promise<void>;
+    protected commitNodeUpdateBuffer(): Promise<void>;
+    keys(condition: Partial<{
+        gt: V;
+        lt: V;
+        gte: V;
+        lte: V;
+        equal: V;
+        notEqual: V;
+        like: V;
+    }>): Promise<Set<K>>;
+    where(condition: Partial<{
+        gt: V;
+        lt: V;
+        gte: V;
+        lte: V;
+        equal: V;
+        notEqual: V;
+        like: V;
+    }>): Promise<BPTreePair<K, V>[]>;
+    insert(key: K, value: V): Promise<void>;
+    delete(key: K, value: V): Promise<void>;
+    exists(key: K, value: V): Promise<boolean>;
+    setHeadData(data: Record<string, Json>): Promise<void>;
+    forceUpdate(nodeId?: number | null): Promise<number>;
+}

package/dist/typings/BPTreeSync.d.ts

@@ -0,0 +1,46 @@
+import type { Json } from './utils/types';
+import { BPTree, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
+import { SerializeStrategySync } from './SerializeStrategySync';
+import { ValueComparator } from './ValueComparator';
+export declare class BPTreeSync<K, V> extends BPTree<K, V> {
+    protected readonly strategy: SerializeStrategySync<K, V>;
+    constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>);
+    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
+    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): BPTreePair<K, V>[];
+    protected _createNodeId(): number;
+    protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): BPTreeUnknownNode<K, V>;
+    protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;
+    protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
+    protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): void;
+    init(): void;
+    protected getNode(id: number): BPTreeUnknownNode<K, V>;
+    protected insertableNode(value: V): BPTreeLeafNode<K, V>;
+    protected leftestNode(): BPTreeLeafNode<K, V>;
+    protected commitHeadBuffer(): void;
+    protected commitNodeCreateBuffer(): void;
+    protected commitNodeUpdateBuffer(): void;
+    keys(condition: Partial<{
+        gt: V;
+        lt: V;
+        gte: V;
+        lte: V;
+        equal: V;
+        notEqual: V;
+        like: V;
+    }>): Set<K>;
+    where(condition: Partial<{
+        gt: V;
+        lt: V;
+        gte: V;
+        lte: V;
+        equal: V;
+        notEqual: V;
+        like: V;
+    }>): BPTreePair<K, V>[];
+    insert(key: K, value: V): void;
+    delete(key: K, value: V): void;
+    exists(key: K, value: V): boolean;
+    setHeadData(data: Record<string, Json>): void;
+    forceUpdate(nodeId?: number | null): number;
+}

package/dist/typings/SerializeStrategyAsync.d.ts

@@ -0,0 +1,21 @@
+import { BPTreeNode } from './base/BPTree';
+import { SerializeStrategy, SerializeStrategyHead } from './base/SerializeStrategy';
+export declare abstract class SerializeStrategyAsync<K, V> extends SerializeStrategy<K, V> {
+    abstract id(): Promise<number>;
+    abstract read(id: number): Promise<BPTreeNode<K, V>>;
+    abstract write(id: number, node: BPTreeNode<K, V>): Promise<void>;
+    abstract readHead(): Promise<SerializeStrategyHead | null>;
+    abstract writeHead(head: SerializeStrategyHead): Promise<void>;
+}
+export declare class InMemoryStoreStrategyAsync<K, V> extends SerializeStrategyAsync<K, V> {
+    protected readonly data: {
+        head: SerializeStrategyHead | null;
+        node: Record<number, BPTreeNode<K, V>>;
+    };
+    constructor(order: number);
+    id(): Promise<number>;
+    read(id: number): Promise<BPTreeNode<K, V>>;
+    write(id: number, node: BPTreeNode<K, V>): Promise<void>;
+    readHead(): Promise<SerializeStrategyHead | null>;
+    writeHead(head: SerializeStrategyHead): Promise<void>;
+}

package/dist/typings/SerializeStrategySync.d.ts

@@ -0,0 +1,21 @@
+import { BPTreeNode } from './base/BPTree';
+import { SerializeStrategy, SerializeStrategyHead } from './base/SerializeStrategy';
+export declare abstract class SerializeStrategySync<K, V> extends SerializeStrategy<K, V> {
+    abstract id(): number;
+    abstract read(id: number): BPTreeNode<K, V>;
+    abstract write(id: number, node: BPTreeNode<K, V>): void;
+    abstract readHead(): SerializeStrategyHead | null;
+    abstract writeHead(head: SerializeStrategyHead): void;
+}
+export declare class InMemoryStoreStrategySync<K, V> extends SerializeStrategySync<K, V> {
+    protected readonly data: {
+        head: SerializeStrategyHead | null;
+        node: Record<number, BPTreeNode<K, V>>;
+    };
+    constructor(order: number);
+    id(): number;
+    read(id: number): BPTreeNode<K, V>;
+    write(id: number, node: BPTreeNode<K, V>): void;
+    readHead(): SerializeStrategyHead | null;
+    writeHead(head: SerializeStrategyHead): void;
+}

package/dist/typings/base/BPTree.d.ts

@@ -0,0 +1,138 @@
+import type { Json } from '../utils/types';
+import { ValueComparator } from '../ValueComparator';
+import { SerializeStrategy, SerializeStrategyHead } from './SerializeStrategy';
+type Sync<T> = T;
+type Async<T> = Promise<T>;
+type Deferred<T> = Sync<T> | Async<T>;
+export type BPTreeNodeKey<K> = number | K;
+export type BPTreeCondition<V> = Partial<{
+    /** Searches for pairs greater than the given value. */
+    gt: V;
+    /** Searches for pairs less than the given value. */
+    lt: V;
+    /** Searches for pairs greater than or equal to the given value. */
+    gte: V;
+    /** Searches for pairs less than or equal to the given value. */
+    lte: V;
+    /** "Searches for pairs equal to the given value. */
+    equal: V;
+    /** Searches for pairs not equal to the given value. */
+    notEqual: V;
+    /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
+    like: V;
+}>;
+export type BPTreePair<K, V> = {
+    key: K;
+    value: V;
+};
+export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
+export interface BPTreeNode<K, V> {
+    id: number;
+    keys: number[] | K[][];
+    values: V[];
+    leaf: boolean;
+    parent: number;
+    next: number;
+    prev: number;
+}
+export interface BPTreeInternalNode<K, V> extends BPTreeNode<K, V> {
+    leaf: false;
+    keys: number[];
+}
+export interface BPTreeLeafNode<K, V> extends BPTreeNode<K, V> {
+    leaf: true;
+    keys: K[][];
+}
+export declare abstract class BPTree<K, V> {
+    protected readonly strategy: SerializeStrategy<K, V>;
+    protected readonly comparator: ValueComparator<V>;
+    protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
+    protected order: number;
+    protected data: Record<string, Json>;
+    protected root: BPTreeUnknownNode<K, V>;
+    protected readonly _nodeCreateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
+    protected readonly _nodeUpdateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
+    protected _headBuffer: SerializeStrategyHead | null;
+    protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V) => boolean>;
+    protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
+    protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
+    protected readonly verifierFullSearch: Record<keyof BPTreeCondition<V>, boolean>;
+    protected get headState(): SerializeStrategyHead;
+    protected constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>);
+    protected abstract _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
+    protected abstract _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
+    protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): Deferred<BPTreePair<K, V>[]>;
+    protected abstract _createNodeId(): Deferred<number>;
+    protected abstract _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Deferred<BPTreeUnknownNode<K, V>>;
+    protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
+    protected abstract _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Deferred<void>;
+    protected abstract getNode(id: number): Deferred<BPTreeUnknownNode<K, V>>;
+    protected abstract insertableNode(value: V): Deferred<BPTreeLeafNode<K, V>>;
+    protected abstract leftestNode(): Deferred<BPTreeLeafNode<K, V>>;
+    protected abstract commitHeadBuffer(): Deferred<void>;
+    protected abstract commitNodeCreateBuffer(): Deferred<void>;
+    protected abstract commitNodeUpdateBuffer(): Deferred<void>;
+    /**
+     * After creating a tree instance, it must be called.
+     * This method is used to initialize the stored tree and recover data.
+     * If it is not called, the tree will not function.
+     */
+    abstract init(): Deferred<void>;
+    /**
+     * 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`, `gte`, `lte`, `equal`, `notEqual`, `like` 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`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+     */
+    abstract keys(condition: BPTreeCondition<V>): Deferred<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`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+     * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+     */
+    abstract where(condition: BPTreeCondition<V>): Deferred<BPTreePair<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 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 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 value The value to search for.
+     */
+    abstract exists(key: K, value: V): Deferred<boolean>;
+    /**
+    * Inserts user-defined data into the head of the tree.
+    * This feature is useful when you need to store separate, non-volatile information in the tree.
+    * For example, you can store information such as the last update time and the number of insertions.
+    * @param data User-defined data to be stored in the head of the tree.
+    */
+    abstract setHeadData(data: Record<string, Json>): Deferred<void>;
+    /**
+     * This method deletes nodes cached in-memory and caches new nodes from the stored nodes.
+     * Typically, there's no need to use this method, but it can be used to synchronize data in scenarios where the remote storage and the client are in a 1:n relationship.
+     * @param nodeId The node ID to update. If no parameters are passed, it updates all currently cached nodes.
+     * @returns The return value is the total number of nodes updated.
+     */
+    abstract forceUpdate(nodeId: number): Deferred<number>;
+    protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
+    protected bufferForHeadUpdate(head: SerializeStrategyHead | null): Deferred<void>;
+    protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
+    protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
+    /**
+     * Returns the user-defined data stored in the head of the tree.
+     * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
+     * @returns User-defined data stored in the head of the tree.
+     */
+    getHeadData(): Record<string, Json>;
+}
+export {};

package/dist/typings/{SerializeStrategy.d.ts → base/SerializeStrategy.d.ts}

@@ -1,5 +1,5 @@
 import { BPTreeNode } from './BPTree';
-import type { Json } from './utils/types';
+import type { Json } from '../utils/types';
 export interface SerializeStrategyHead {
     root: number;
     order: number;
@@ -14,44 +14,32 @@ export declare abstract class SerializeStrategy<K, V> {
      *
      * **WARNING!** The return value should never be `0`.
      */
-    abstract id(): number;
+    abstract id(): number | Promise<number>;
     /**
      * Read the stored node from the ID.
      * The JSON object of the read node should be returned.
      * @param id This is the ID of the node to be read.
      */
-    abstract read(id: number): BPTreeNode<K, V>;
+    abstract read(id: number): BPTreeNode<K, V> | Promise<BPTreeNode<K, V>>;
     /**
      * It is called when a node is created or updated and needs to be stored.
      * The node ID and the node JSON object are passed as parameters. Use this to store the data.
      * @param id This is the ID of the node to be stored.
      * @param node This is the JSON object of the node to be stored.
      */
-    abstract write(id: number, node: BPTreeNode<K, V>): void;
+    abstract write(id: number, node: BPTreeNode<K, V>): void | Promise<void>;
     /**
-     * It is called when a tree instance is created.
+     * It is called when the `init` method of the tree instance is called.
      * This method should return the information needed to initialize the tree. This information refers to the values stored in the `writeHead` method.
      *
      * If it is the initial creation and there is no stored head, it should return `null`.
      * In this case, the tree is created based on the order specified in the strategy instance constructor parameters.
      */
-    abstract readHead(): SerializeStrategyHead | null;
+    abstract readHead(): (SerializeStrategyHead | null) | Promise<(SerializeStrategyHead | null)>;
     /**
      * It is called when the root node is created or updated.
      * The method takes the current state of the tree as a parameter. Serialize and store this value. It will be used for the `readHead` method later.
      * @param head This is the current state of the tree.
      */
-    abstract writeHead(head: SerializeStrategyHead): void;
-}
-export declare class InMemoryStoreStrategy<K, V> extends SerializeStrategy<K, V> {
-    protected readonly data: {
-        head: SerializeStrategyHead | null;
-        node: Record<number, BPTreeNode<K, V>>;
-    };
-    constructor(order: number);
-    id(): number;
-    read(id: number): BPTreeNode<K, V>;
-    write(id: number, node: BPTreeNode<K, V>): void;
-    readHead(): SerializeStrategyHead | null;
-    writeHead(head: SerializeStrategyHead): void;
+    abstract writeHead(head: SerializeStrategyHead): void | Promise<void>;
 }

package/dist/typings/index.d.ts

@@ -1,3 +1,7 @@
-export { BPTree, BPTreeNode } from './BPTree';
-export { SerializeStrategy, SerializeStrategyHead, InMemoryStoreStrategy } from './SerializeStrategy';
+export type { BPTreeNode } from './base/BPTree';
+export type { SerializeStrategyHead } from './base/SerializeStrategy';
+export { BPTreeSync } from './BPTreeSync';
+export { BPTreeAsync } from './BPTreeAsync';
+export { SerializeStrategySync, InMemoryStoreStrategySync } from './SerializeStrategySync';
+export { SerializeStrategyAsync, InMemoryStoreStrategyAsync } from './SerializeStrategyAsync';
 export { ValueComparator, NumericComparator, StringComparator } from './ValueComparator';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -23,6 +23,10 @@
     "bptree",
     "event"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/izure1/serializable-bptree.git"
+  },
   "license": "MIT",
   "devDependencies": {
     "@types/jest": "^29.5.8",

package/dist/typings/BPTree.d.ts

@@ -1,127 +0,0 @@
-import type { Json } from './utils/types';
-import { BinarySearch } from './utils/BinarySearch';
-import { ValueComparator } from './ValueComparator';
-import { SerializeStrategy } from './SerializeStrategy';
-type BPTreeCondition<V> = Partial<{
-    /** Searches for pairs greater than the given value. */
-    gt: V;
-    /** Searches for pairs less than the given value. */
-    lt: V;
-    /** Searches for pairs greater than or equal to the given value. */
-    gte: V;
-    /** Searches for pairs less than or equal to the given value. */
-    lte: V;
-    /** "Searches for pairs equal to the given value. */
-    equal: V;
-    /** Searches for pairs not equal to the given value. */
-    notEqual: V;
-    /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
-    like: V;
-}>;
-type BPTreePair<K, V> = {
-    key: K;
-    value: V;
-};
-export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
-export interface BPTreeNode<K, V> {
-    id: number;
-    keys: number[] | K[][];
-    values: V[];
-    leaf: boolean;
-    parent: number;
-    next: number;
-    prev: number;
-}
-export interface BPTreeInternalNode<K, V> extends BPTreeNode<K, V> {
-    leaf: false;
-    keys: number[];
-}
-export interface BPTreeLeafNode<K, V> extends BPTreeNode<K, V> {
-    leaf: true;
-    keys: K[][];
-}
-export declare class BPTree<K, V> {
-    protected readonly strategy: SerializeStrategy<K, V>;
-    protected readonly comparator: ValueComparator<V>;
-    protected readonly search: BinarySearch<V>;
-    protected readonly order: number;
-    protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
-    protected data: Record<string, Json>;
-    protected root: BPTreeUnknownNode<K, V>;
-    private readonly _creates;
-    private readonly _updates;
-    private _updatedHead;
-    private readonly _verifierMap;
-    private readonly _verifierStartNode;
-    private readonly _verifierDirection;
-    private readonly _verifierFullSearch;
-    private _createNodeId;
-    private _createNode;
-    /**
-     * @param strategy An instance of a strategy that manages the read/write state of a node.
-     * @param comparator An instance of a comparator that compares the size of values.
-     */
-    constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>);
-    private get _headState();
-    private _setHeadUpdate;
-    private _setCreates;
-    private _setUpdates;
-    private _emitHeadUpdates;
-    private _emitCreates;
-    private _emitUpdates;
-    protected getNode(id: number): BPTreeUnknownNode<K, V>;
-    protected leftestNode(): BPTreeLeafNode<K, V>;
-    protected insertableNode(value: V): BPTreeLeafNode<K, V>;
-    /**
-     * It returns whether there is a value in the tree.
-     * @param key The key value to search for.
-     * @param value The value to search for.
-     */
-    exists(key: K, value: V): boolean;
-    private _insertAtLeaf;
-    private _insertInParent;
-    private _getPairsRightToLeft;
-    private _getPairsLeftToRight;
-    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): BPTreePair<K, V>[];
-    /**
-     * 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`, `gte`, `lte`, `equal`, `notEqual`, `like` 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`, `gte`, `lte`, `equal`, `notEqual`, `like` 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`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-     * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-     */
-    where(condition: BPTreeCondition<V>): BPTreePair<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 value The value of the pair.
-     */
-    insert(key: K, value: V): void;
-    /**
-     * Deletes the pair that matches the key and value.
-     * @param key The key of the pair.
-     * @param value The value of the pair.
-     */
-    delete(key: K, value: V): void;
-    private _deleteEntry;
-    /**
-     * Returns the user-defined data stored in the head of the tree.
-     * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
-     * @returns User-defined data stored in the head of the tree.
-     */
-    getHeadData(): Record<string, Json>;
-    /**
-     * Inserts user-defined data into the head of the tree.
-     * This feature is useful when you need to store separate, non-volatile information in the tree.
-     * For example, you can store information such as the last update time and the number of insertions.
-     * @param data User-defined data to be stored in the head of the tree.
-     */
-    setHeadData(data: Record<string, Json>): void;
-}
-export {};

package/dist/typings/utils/BinarySearch.d.ts

@@ -1,9 +0,0 @@
-import { ValueComparator } from '../ValueComparator';
-export declare class BinarySearch<T> {
-    protected readonly comparator: ValueComparator<T>;
-    constructor(comparator: ValueComparator<T>);
-    _withRange(array: T[], value: T, left?: number, right?: number): number;
-    leftest(array: T[], value: T): number;
-    rightest(array: T[], value: T): number;
-    range(array: T[], value: T): [number, number];
-}