serializable-bptree 1.0.0

package/dist/typings/BPTree.d.ts

@@ -0,0 +1,91 @@
+import { BinarySearch } from './utils/BinarySearch';
+import { ValueComparator } from './ValueComparator';
+import { SerializeStrategy } from './SerializeStrategy';
+type BPTreeNodeKey<K, V> = K[] | BPTreeNode<K, V>;
+type BPTreeCondition<V> = {
+    gt?: V;
+    lt?: V;
+} | {
+    equal: V;
+} | {
+    notEqual: V;
+};
+type BPTreePair<K, V> = {
+    key: K;
+    value: V;
+};
+export interface BPTreeNode<K, V> {
+    id: number;
+    keys: BPTreeNodeKey<K, V>[];
+    values: V[];
+    leaf: boolean;
+    parent: number;
+    next: number;
+}
+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, BPTreeNode<K, V>>;
+    protected root: BPTreeNode<K, V>;
+    private readonly _creates;
+    private readonly _updates;
+    private _updatedHead;
+    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): BPTreeNode<K, V>;
+    protected leftestNode(): BPTreeNode<K, V>;
+    private _insertableNode;
+    /**
+     * 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 _equalCondition;
+    private _notEqualCondition;
+    private _onlyGtCondition;
+    private _onlyLtCondition;
+    private _rangeCondition;
+    private _getPairsFromValue;
+    private _getPairsFromNEValue;
+    private _getPairsFromRange;
+    private _getPairsFromGt;
+    private _getPairsFromLt;
+    /**
+     * 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.
+     * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` 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;
+}
+export {};

package/dist/typings/SerializeStrategy.d.ts

@@ -0,0 +1,55 @@
+import { BPTreeNode } from './BPTree';
+export interface SerializeStrategyHead {
+    root: number;
+    order: number;
+}
+export declare abstract class SerializeStrategy<K, V> {
+    readonly order: number;
+    constructor(order: number);
+    /**
+     * The rule for generating node IDs is set.
+     * When a new node is created within the tree, the value returned by this method becomes the node's ID.
+     *
+     * **WARNING!** The return value should never be `0`.
+     */
+    abstract id(): 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>;
+    /**
+     * 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;
+    /**
+     * It is called when a tree instance is created.
+     * This method should return the information needed to initialize the tree. This information refers to the values stored in the `writeHead` method.
+     *
+     * If it's the first creation and there are no saved root nodes, return `null`.
+     * In this case, the tree is created based on the order specified in the strategy instance constructor parameters.
+     */
+    abstract readHead(): 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;
+}

package/dist/typings/ValueComparator.d.ts

@@ -0,0 +1,18 @@
+export declare abstract class ValueComparator<V> {
+    /**
+     * Implement an algorithm that sorts values in ascending order.
+     * If it returns a negative number, a is less than b. If it returns 0, the two values are equal. If it returns a positive number, a is greater than b.
+     * @param a Value a.
+     * @param b Value b.
+     */
+    abstract asc(a: V, b: V): number;
+    isLower(value: V, than: V): boolean;
+    isSame(value: V, than: V): boolean;
+    isHigher(value: V, than: V): boolean;
+}
+export declare class NumericComparator extends ValueComparator<number> {
+    asc(a: number, b: number): number;
+}
+export declare class StringComparator extends ValueComparator<string> {
+    asc(a: string, b: string): number;
+}

package/dist/typings/index.d.ts

@@ -0,0 +1,3 @@
+export { BPTree, BPTreeNode } from './BPTree';
+export { SerializeStrategy, SerializeStrategyHead, InMemoryStoreStrategy } from './SerializeStrategy';
+export { ValueComparator, NumericComparator, StringComparator } from './ValueComparator';

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

@@ -0,0 +1,9 @@
+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];
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "serializable-bptree",
+  "version": "1.0.0",
+  "description": "Store the B+tree flexibly, not only in-memory.",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "typings": "dist/typings/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "node build/index.js && tsc"
+  },
+  "author": "izure1 <admin@izure.org>",
+  "keywords": [
+    "serializable-bptree",
+    "b-plus-tree",
+    "serialize",
+    "store",
+    "btree",
+    "bptree",
+    "event"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.8",
+    "esbuild": "^0.19.5",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.2.2"
+  }
+}