avl-tree-typed 2.1.0 → 2.1.2

package/dist/data-structures/base/linear-base.js

@@ -1,415 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinearLinkedBase = exports.LinearBase = exports.LinkedListNode = void 0;
-const iterable_element_base_1 = require("./iterable-element-base");
-/**
- * Singly-linked list node.
- * @template E - Element type.
- * @remarks Time O(1), Space O(1)
- */
-class LinkedListNode {
-    /**
-     * Initialize a node.
-     * @param value - Element value.
-     * @remarks Time O(1), Space O(1)
-     */
-    constructor(value) {
-        this._value = value;
-        this._next = undefined;
-    }
-    /**
-     * Element payload getter.
-     * @returns Element value.
-     * @remarks Time O(1), Space O(1)
-     */
-    get value() {
-        return this._value;
-    }
-    /**
-     * Element payload setter.
-     * @param value - New value.
-     * @remarks Time O(1), Space O(1)
-     */
-    set value(value) {
-        this._value = value;
-    }
-    /**
-     * Next node getter.
-     * @returns Next node or `undefined`.
-     * @remarks Time O(1), Space O(1)
-     */
-    get next() {
-        return this._next;
-    }
-    /**
-     * Next node setter.
-     * @param value - Next node or `undefined`.
-     * @remarks Time O(1), Space O(1)
-     */
-    set next(value) {
-        this._next = value;
-    }
-}
-exports.LinkedListNode = LinkedListNode;
-/**
- * Abstract linear container with array-like utilities.
- * @template E - Element type.
- * @template R - Return type for mapped/derived views.
- * @template NODE - Linked node type used by some implementations.
- * @remarks Time O(1), Space O(1)
- */
-class LinearBase extends iterable_element_base_1.IterableElementBase {
-    /**
-     * Construct a linear container with runtime options.
-     * @param options - `{ maxLen?, ... }` bounds/behavior options.
-     * @remarks Time O(1), Space O(1)
-     */
-    constructor(options) {
-        super(options);
-        this._maxLen = -1;
-        if (options) {
-            const { maxLen } = options;
-            if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0)
-                this._maxLen = maxLen;
-        }
-    }
-    /**
-     * Upper bound for length (if positive), or `-1` when unbounded.
-     * @returns Maximum allowed length.
-     * @remarks Time O(1), Space O(1)
-     */
-    get maxLen() {
-        return this._maxLen;
-    }
-    /**
-     * First index of a value from the left.
-     * @param searchElement - Value to match.
-     * @param fromIndex - Start position (supports negative index).
-     * @returns Index or `-1` if not found.
-     * @remarks Time O(n), Space O(1)
-     */
-    indexOf(searchElement, fromIndex = 0) {
-        if (this.length === 0)
-            return -1;
-        if (fromIndex < 0)
-            fromIndex = this.length + fromIndex;
-        if (fromIndex < 0)
-            fromIndex = 0;
-        for (let i = fromIndex; i < this.length; i++) {
-            const element = this.at(i);
-            if (element === searchElement)
-                return i;
-        }
-        return -1;
-    }
-    /**
-     * Last index of a value from the right.
-     * @param searchElement - Value to match.
-     * @param fromIndex - Start position (supports negative index).
-     * @returns Index or `-1` if not found.
-     * @remarks Time O(n), Space O(1)
-     */
-    lastIndexOf(searchElement, fromIndex = this.length - 1) {
-        if (this.length === 0)
-            return -1;
-        if (fromIndex >= this.length)
-            fromIndex = this.length - 1;
-        if (fromIndex < 0)
-            fromIndex = this.length + fromIndex;
-        for (let i = fromIndex; i >= 0; i--) {
-            const element = this.at(i);
-            if (element === searchElement)
-                return i;
-        }
-        return -1;
-    }
-    /**
-     * Find the first index matching a predicate.
-     * @param predicate - `(element, index, self) => boolean`.
-     * @param thisArg - Optional `this` for callback.
-     * @returns Index or `-1`.
-     * @remarks Time O(n), Space O(1)
-     */
-    findIndex(predicate, thisArg) {
-        for (let i = 0; i < this.length; i++) {
-            const item = this.at(i);
-            if (item !== undefined && predicate.call(thisArg, item, i, this))
-                return i;
-        }
-        return -1;
-    }
-    /**
-     * Concatenate elements and/or containers.
-     * @param items - Elements or other containers.
-     * @returns New container with combined elements (`this` type).
-     * @remarks Time O(sum(length)), Space O(sum(length))
-     */
-    concat(...items) {
-        const newList = this.clone();
-        for (const item of items) {
-            if (item instanceof LinearBase) {
-                newList.pushMany(item);
-            }
-            else {
-                newList.push(item);
-            }
-        }
-        return newList;
-    }
-    /**
-     * In-place stable order via array sort semantics.
-     * @param compareFn - Comparator `(a, b) => number`.
-     * @returns This container.
-     * @remarks Time O(n log n), Space O(n) (materializes to array temporarily)
-     */
-    sort(compareFn) {
-        const arr = this.toArray();
-        arr.sort(compareFn);
-        this.clear();
-        for (const item of arr)
-            this.push(item);
-        return this;
-    }
-    /**
-     * Remove and/or insert elements at a position (array-compatible).
-     * @param start - Start index (supports negative index).
-     * @param deleteCount - How many to remove.
-     * @param items - Elements to insert.
-     * @returns Removed elements as a new list (`this` type).
-     * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`
-     */
-    splice(start, deleteCount = 0, ...items) {
-        const removedList = this._createInstance();
-        start = start < 0 ? this.length + start : start;
-        start = Math.max(0, Math.min(start, this.length));
-        deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
-        for (let i = 0; i < deleteCount; i++) {
-            const removed = this.deleteAt(start);
-            if (removed !== undefined) {
-                removedList.push(removed);
-            }
-        }
-        for (let i = 0; i < items.length; i++) {
-            this.addAt(start + i, items[i]);
-        }
-        return removedList;
-    }
-    /**
-     * Join all elements into a string.
-     * @param separator - Separator string.
-     * @returns Concatenated string.
-     * @remarks Time O(n), Space O(n)
-     */
-    join(separator = ',') {
-        return this.toArray().join(separator);
-    }
-    /**
-     * Snapshot elements into a reversed array.
-     * @returns New reversed array.
-     * @remarks Time O(n), Space O(n)
-     */
-    toReversedArray() {
-        const array = [];
-        for (let i = this.length - 1; i >= 0; i--) {
-            array.push(this.at(i));
-        }
-        return array;
-    }
-    reduceRight(callbackfn, initialValue) {
-        let accumulator = initialValue !== null && initialValue !== void 0 ? initialValue : 0;
-        for (let i = this.length - 1; i >= 0; i--) {
-            accumulator = callbackfn(accumulator, this.at(i), i, this);
-        }
-        return accumulator;
-    }
-    /**
-     * Create a shallow copy of a subrange.
-     * @param start - Inclusive start (supports negative index).
-     * @param end - Exclusive end (supports negative index).
-     * @returns New list with the range (`this` type).
-     * @remarks Time O(n), Space O(n)
-     */
-    slice(start = 0, end = this.length) {
-        start = start < 0 ? this.length + start : start;
-        end = end < 0 ? this.length + end : end;
-        const newList = this._createInstance();
-        for (let i = start; i < end; i++) {
-            newList.push(this.at(i));
-        }
-        return newList;
-    }
-    /**
-     * Fill a range with a value.
-     * @param value - Value to set.
-     * @param start - Inclusive start.
-     * @param end - Exclusive end.
-     * @returns This list.
-     * @remarks Time O(n), Space O(1)
-     */
-    fill(value, start = 0, end = this.length) {
-        start = start < 0 ? this.length + start : start;
-        end = end < 0 ? this.length + end : end;
-        if (start < 0)
-            start = 0;
-        if (end > this.length)
-            end = this.length;
-        if (start >= end)
-            return this;
-        for (let i = start; i < end; i++) {
-            this.setAt(i, value);
-        }
-        return this;
-    }
-}
-exports.LinearBase = LinearBase;
-/**
- * Linked-list specialized linear container.
- * @template E - Element type.
- * @template R - Return type for mapped/derived views.
- * @template NODE - Linked node type.
- * @remarks Time O(1), Space O(1)
- */
-class LinearLinkedBase extends LinearBase {
-    constructor(options) {
-        super(options);
-        if (options) {
-            const { maxLen } = options;
-            if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0)
-                this._maxLen = maxLen;
-        }
-    }
-    /**
-     * Linked-list optimized `indexOf` (forwards scan).
-     * @param searchElement - Value to match.
-     * @param fromIndex - Start position.
-     * @returns Index or `-1`.
-     * @remarks Time O(n), Space O(1)
-     */
-    indexOf(searchElement, fromIndex = 0) {
-        const iterator = this._getIterator();
-        let current = iterator.next();
-        let index = 0;
-        while (index < fromIndex) {
-            current = iterator.next();
-            index++;
-        }
-        while (!current.done) {
-            if (current.value === searchElement)
-                return index;
-            current = iterator.next();
-            index++;
-        }
-        return -1;
-    }
-    /**
-     * Linked-list optimized `lastIndexOf` (reverse scan).
-     * @param searchElement - Value to match.
-     * @param fromIndex - Start position.
-     * @returns Index or `-1`.
-     * @remarks Time O(n), Space O(1)
-     */
-    lastIndexOf(searchElement, fromIndex = this.length - 1) {
-        const iterator = this._getReverseIterator();
-        let current = iterator.next();
-        let index = this.length - 1;
-        while (index > fromIndex) {
-            current = iterator.next();
-            index--;
-        }
-        while (!current.done) {
-            if (current.value === searchElement)
-                return index;
-            current = iterator.next();
-            index--;
-        }
-        return -1;
-    }
-    concat(...items) {
-        const newList = this.clone();
-        for (const item of items) {
-            if (item instanceof LinearBase) {
-                newList.pushMany(item);
-            }
-            else {
-                newList.push(item);
-            }
-        }
-        return newList;
-    }
-    /**
-     * Slice via forward iteration (no random access required).
-     * @param start - Inclusive start (supports negative index).
-     * @param end - Exclusive end (supports negative index).
-     * @returns New list (`this` type).
-     * @remarks Time O(n), Space O(n)
-     */
-    slice(start = 0, end = this.length) {
-        start = start < 0 ? this.length + start : start;
-        end = end < 0 ? this.length + end : end;
-        const newList = this._createInstance();
-        const iterator = this._getIterator();
-        let current = iterator.next();
-        let c = 0;
-        while (c < start) {
-            current = iterator.next();
-            c++;
-        }
-        for (let i = start; i < end; i++) {
-            newList.push(current.value);
-            current = iterator.next();
-        }
-        return newList;
-    }
-    /**
-     * Splice by walking node iterators from the start index.
-     * @param start - Start index.
-     * @param deleteCount - How many elements to remove.
-     * @param items - Elements to insert after the splice point.
-     * @returns Removed elements as a new list (`this` type).
-     * @remarks Time O(n + m), Space O(min(n, m)) where `m = items.length`
-     */
-    splice(start, deleteCount = 0, ...items) {
-        const removedList = this._createInstance();
-        start = start < 0 ? this.length + start : start;
-        start = Math.max(0, Math.min(start, this.length));
-        deleteCount = Math.max(0, deleteCount);
-        let currentIndex = 0;
-        let currentNode = undefined;
-        let previousNode = undefined;
-        const iterator = this._getNodeIterator();
-        for (const node of iterator) {
-            if (currentIndex === start) {
-                currentNode = node;
-                break;
-            }
-            previousNode = node;
-            currentIndex++;
-        }
-        for (let i = 0; i < deleteCount && currentNode; i++) {
-            removedList.push(currentNode.value);
-            const nextNode = currentNode.next;
-            this.delete(currentNode);
-            currentNode = nextNode;
-        }
-        for (let i = 0; i < items.length; i++) {
-            if (previousNode) {
-                this.addAfter(previousNode, items[i]);
-                previousNode = previousNode.next;
-            }
-            else {
-                this.addAt(0, items[i]);
-                previousNode = this._getNodeIterator().next().value;
-            }
-        }
-        return removedList;
-    }
-    reduceRight(callbackfn, initialValue) {
-        let accumulator = initialValue !== null && initialValue !== void 0 ? initialValue : 0;
-        let index = this.length - 1;
-        for (const item of this._getReverseIterator()) {
-            accumulator = callbackfn(accumulator, item, index--, this);
-        }
-        return accumulator;
-    }
-}
-exports.LinearLinkedBase = LinearLinkedBase;

package/dist/data-structures/binary-tree/avl-tree-counter.d.ts

@@ -1,182 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import type { AVLTreeCounterOptions, BinaryTreeDeleteResult, BinaryTreeOptions, BSTNOptKeyOrNode, EntryCallback, IterationType } from '../../types';
-import { IBinaryTree } from '../../interfaces';
-import { AVLTree, AVLTreeNode } from './avl-tree';
-/**
- * AVL node with an extra 'count' field; keeps parent/child links.
- * @remarks Time O(1), Space O(1)
- * @template K
- * @template V
- */
-export declare class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
-    parent?: AVLTreeCounterNode<K, V>;
-    /**
-     * Create an AVL counter node.
-     * @remarks Time O(1), Space O(1)
-     * @param key - Key of the node.
-     * @param [value] - Associated value (ignored in map mode).
-     * @param [count] - Initial count for this node (default 1).
-     * @returns New AVLTreeCounterNode instance.
-     */
-    constructor(key: K, value?: V, count?: number);
-    _left?: AVLTreeCounterNode<K, V> | null | undefined;
-    /**
-     * Get the left child pointer.
-     * @remarks Time O(1), Space O(1)
-     * @returns Left child node, or null/undefined.
-     */
-    get left(): AVLTreeCounterNode<K, V> | null | undefined;
-    /**
-     * Set the left child and update its parent pointer.
-     * @remarks Time O(1), Space O(1)
-     * @param v - New left child node, or null/undefined.
-     * @returns void
-     */
-    set left(v: AVLTreeCounterNode<K, V> | null | undefined);
-    _right?: AVLTreeCounterNode<K, V> | null | undefined;
-    /**
-     * Get the right child pointer.
-     * @remarks Time O(1), Space O(1)
-     * @returns Right child node, or null/undefined.
-     */
-    get right(): AVLTreeCounterNode<K, V> | null | undefined;
-    /**
-     * Set the right child and update its parent pointer.
-     * @remarks Time O(1), Space O(1)
-     * @param v - New right child node, or null/undefined.
-     * @returns void
-     */
-    set right(v: AVLTreeCounterNode<K, V> | null | undefined);
-}
-/**
- * AVL tree that tracks an aggregate 'count' across nodes; supports balanced insert/delete and map-like mode.
- * @remarks Time O(1), Space O(1)
- * @template K
- * @template V
- * @template R
- */
-export declare class AVLTreeCounter<K = any, V = any, R extends object = object> extends AVLTree<K, V, R> implements IBinaryTree<K, V, R> {
-    /**
-     * Create a AVLTreeCounter instance
-     * @remarks Time O(n), Space O(n)
-     * @param keysNodesEntriesOrRaws
-     * @param options
-     * @returns New AVLTreeCounterNode instance.
-     */
-    constructor(keysNodesEntriesOrRaws?: Iterable<K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R>, options?: AVLTreeCounterOptions<K, V, R>);
-    protected _count: number;
-    get count(): number;
-    /**
-     * Compute the total count by traversing the tree (sums node.count).
-     * @remarks Time O(N), Space O(H)
-     * @returns Total count recomputed from nodes.
-     */
-    getComputedCount(): number;
-    _createNode(key: K, value?: V, count?: number): AVLTreeCounterNode<K, V>;
-    /**
-     * Type guard: check whether the input is an AVLTreeCounterNode.
-     * @remarks Time O(1), Space O(1)
-     * @returns True if the value is an AVLTreeCounterNode.
-     */
-    isNode(keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): keyNodeOrEntry is AVLTreeCounterNode<K, V>;
-    /**
-     * Insert or increment a node and update aggregate count.
-     * @remarks Time O(log N), Space O(1)
-     * @param keyNodeOrEntry - Key, node, or [key, value] entry to insert.
-     * @param [value] - Value when a bare key is provided (ignored in map mode).
-     * @param [count] - How much to increase the node's count (default 1).
-     * @returns True if inserted/updated; false if ignored.
-     */
-    add(keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): boolean;
-    /**
-     * Delete a node (or decrement its count) and rebalance if needed.
-     * @remarks Time O(log N), Space O(1)
-     * @param keyNodeOrEntry - Key, node, or [key, value] entry identifying the node.
-     * @param [ignoreCount] - If true, remove the node regardless of its count.
-     * @returns Array of deletion results including deleted node and a rebalance hint when present.
-     */
-    delete(keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, ignoreCount?: boolean): BinaryTreeDeleteResult<AVLTreeCounterNode<K, V>>[];
-    /**
-     * Remove all nodes and reset aggregate counters.
-     * @remarks Time O(N), Space O(1)
-     * @returns void
-     */
-    clear(): void;
-    /**
-     * Rebuild the tree into a perfectly balanced form using in-order nodes.
-     * @remarks Time O(N), Space O(N)
-     * @param [iterationType] - Traversal style to use when constructing the balanced tree.
-     * @returns True if rebalancing succeeded (tree not empty).
-     */
-    perfectlyBalance(iterationType?: IterationType): boolean;
-    /**
-     * Deep copy this tree, preserving map mode and aggregate counts.
-     * @remarks Time O(N), Space O(N)
-     * @returns A deep copy of this tree.
-     */
-    clone(): this;
-    /**
-     * Create a new AVLTreeCounter by mapping each [key, value] entry.
-     * @remarks Time O(N log N), Space O(N)
-     * @template MK
-     * @template MV
-     * @template MR
-     * @param callback - Function mapping (key, value, index, tree) → [newKey, newValue].
-     * @param [options] - Options for the output tree.
-     * @param [thisArg] - Value for `this` inside the callback.
-     * @returns A new AVLTreeCounter with mapped entries.
-     */
-    map<MK = K, MV = V, MR extends object = object>(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: Partial<BinaryTreeOptions<MK, MV, MR>>, thisArg?: unknown): AVLTreeCounter<MK, MV, MR>;
-    /**
-     * (Protected) Create an empty instance of the same concrete class.
-     * @remarks Time O(1), Space O(1)
-     * @template TK
-     * @template TV
-     * @template TR
-     * @param [options] - Optional constructor options for the like-kind instance.
-     * @returns An empty like-kind instance.
-     */
-    protected _createInstance<TK = K, TV = V, TR extends object = R>(options?: Partial<AVLTreeCounterOptions<TK, TV, TR>>): this;
-    /**
-     * (Protected) Create a like-kind instance and seed it from an iterable.
-     * @remarks Time O(N log N), Space O(N)
-     * @template TK
-     * @template TV
-     * @template TR
-     * @param iter - Iterable used to seed the new tree.
-     * @param [options] - Options merged with the current snapshot.
-     * @returns A like-kind AVLTreeCounter built from the iterable.
-     */
-    protected _createLike<TK = K, TV = V, TR extends object = R>(iter?: Iterable<TK | AVLTreeCounterNode<TK, TV> | [TK | null | undefined, TV | undefined] | null | undefined | TR>, options?: Partial<AVLTreeCounterOptions<TK, TV, TR>>): AVLTreeCounter<TK, TV, TR>;
-    /**
-     * (Protected) Normalize input into a node plus its effective value and count.
-     * @remarks Time O(1), Space O(1)
-     * @param keyNodeOrEntry - Key, node, or [key, value] entry.
-     * @param [value] - Value used when a bare key is provided.
-     * @param [count] - Count increment to apply (default 1).
-     * @returns Tuple [node, value] where node may be undefined.
-     */
-    protected _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined, value?: V, count?: number): [AVLTreeCounterNode<K, V> | undefined, V | undefined];
-    /**
-     * (Protected) Swap keys/values/counters between the source and destination nodes.
-     * @remarks Time O(1), Space O(1)
-     * @param srcNode - Source node (or key) whose properties will be moved.
-     * @param destNode - Destination node (or key) to receive properties.
-     * @returns Destination node after swap, or undefined.
-     */
-    protected _swapProperties(srcNode: BSTNOptKeyOrNode<K, AVLTreeCounterNode<K, V>>, destNode: BSTNOptKeyOrNode<K, AVLTreeCounterNode<K, V>>): AVLTreeCounterNode<K, V> | undefined;
-    /**
-     * (Protected) Replace one node by another and adjust counters accordingly.
-     * @remarks Time O(1), Space O(1)
-     * @param oldNode - Node being replaced.
-     * @param newNode - Replacement node.
-     * @returns The new node after replacement.
-     */
-    protected _replaceNode(oldNode: AVLTreeCounterNode<K, V>, newNode: AVLTreeCounterNode<K, V>): AVLTreeCounterNode<K, V>;
-}