binary-tree-typed 2.4.5 → 2.5.1

package/dist/types/data-structures/trie/trie.d.ts

@@ -77,32 +77,6 @@ export declare class TrieNode {
  * 10. IP Routing: Used in certain types of IP routing algorithms.
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data.
  * @example
- * // basic Trie creation and add words
- *  // Create a simple Trie with initial words
- *     const trie = new Trie(['apple', 'app', 'apply']);
- *
- *     // Verify size
- *     console.log(trie.size); // 3;
- *
- *     // Check if words exist
- *     console.log(trie.has('apple')); // true;
- *     console.log(trie.has('app')); // true;
- *
- *     // Add a new word
- *     trie.add('application');
- *     console.log(trie.size); // 4;
- * @example
- * // Trie getWords and prefix search
- *  const trie = new Trie(['apple', 'app', 'apply', 'application', 'apricot']);
- *
- *     // Get all words with prefix 'app'
- *     const appWords = trie.getWords('app');
- *     console.log(appWords); // contains 'app';
- *     console.log(appWords); // contains 'apple';
- *     console.log(appWords); // contains 'apply';
- *     console.log(appWords); // contains 'application';
- *     expect(appWords).not.toContain('apricot');
- * @example
  * // Trie isPrefix and isAbsolutePrefix checks
  *  const trie = new Trie(['tree', 'trial', 'trick', 'trip', 'trie']);
  *
@@ -118,23 +92,6 @@ export declare class TrieNode {
  *     // Verify size
  *     console.log(trie.size); // 5;
  * @example
- * // Trie delete and iteration
- *  const trie = new Trie(['car', 'card', 'care', 'careful', 'can', 'cat']);
- *
- *     // Delete a word
- *     trie.delete('card');
- *     console.log(trie.has('card')); // false;
- *
- *     // Word with same prefix still exists
- *     console.log(trie.has('care')); // true;
- *
- *     // Size decreased
- *     console.log(trie.size); // 5;
- *
- *     // Iterate through all words
- *     const allWords = [...trie];
- *     console.log(allWords.length); // 5;
- * @example
  * // Trie for autocomplete search index
  *  // Trie is perfect for autocomplete: O(m + k) where m is prefix length, k is results
  *     const searchIndex = new Trie(['typescript', 'javascript', 'python', 'java', 'rust', 'ruby', 'golang', 'kotlin']);
@@ -261,6 +218,53 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @remarks Time O(L), Space O(L)
      * @param word - Word to insert.
      * @returns True if the word was newly added.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // basic Trie creation and add words
+   *  // Create a simple Trie with initial words
+   *     const trie = new Trie(['apple', 'app', 'apply']);
+   *
+   *     // Verify size
+   *     console.log(trie.size); // 3;
+   *
+   *     // Check if words exist
+   *     console.log(trie.has('apple')); // true;
+   *     console.log(trie.has('app')); // true;
+   *
+   *     // Add a new word
+   *     trie.add('application');
+   *     console.log(trie.size); // 4;
      */
     add(word: string): boolean;
     /**
@@ -268,6 +272,42 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @remarks Time O(ΣL), Space O(ΣL)
      * @param words - Iterable of strings (or raw records if toElementFn is provided).
      * @returns Array of per-word 'added' flags.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Add multiple words
+   *  const trie = new Trie();
+   *     trie.addMany(['cat', 'car', 'card']);
+   *     console.log(trie.has('cat')); // true;
+   *     console.log(trie.has('car')); // true;
+   *     console.log(trie.size); // 3;
      */
     addMany(words: Iterable<string> | Iterable<R>): boolean[];
     /**
@@ -275,18 +315,126 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @remarks Time O(L), Space O(1)
      * @param word - Word to search for.
      * @returns True if present.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check if a word exists
+   *  const dict = new Trie(['apple', 'app', 'application']);
+   *
+   *     console.log(dict.has('app')); // true;
+   *     console.log(dict.has('apple')); // true;
+   *     console.log(dict.has('ap')); // false;
      */
     has(word: string): boolean;
     /**
      * Check whether the trie is empty.
      * @remarks Time O(1), Space O(1)
      * @returns True if size is 0.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check if empty
+   *  const trie = new Trie();
+   *     console.log(trie.isEmpty()); // true;
+   *     trie.add('word');
+   *     console.log(trie.isEmpty()); // false;
      */
     isEmpty(): boolean;
     /**
      * Remove all words and reset to a fresh root.
      * @remarks Time O(1), Space O(1)
      * @returns void
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove all words
+   *  const trie = new Trie(['a', 'b', 'c']);
+   *     trie.clear();
+   *     console.log(trie.isEmpty()); // true;
      */
     clear(): void;
     /**
@@ -294,6 +442,55 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @remarks Time O(L), Space O(1)
      * @param word - Word to delete.
      * @returns True if a word was removed.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Trie delete and iteration
+   *  const trie = new Trie(['car', 'card', 'care', 'careful', 'can', 'cat']);
+   *
+   *     // Delete a word
+   *     trie.delete('card');
+   *     console.log(trie.has('card')); // false;
+   *
+   *     // Word with same prefix still exists
+   *     console.log(trie.has('care')); // true;
+   *
+   *     // Size decreased
+   *     console.log(trie.size); // 5;
+   *
+   *     // Iterate through all words
+   *     const allWords = [...trie];
+   *     console.log(allWords.length); // 5;
      */
     delete(word: string): boolean;
     /**
@@ -314,6 +511,45 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @remarks Time O(L), Space O(1)
      * @param input - String to test as prefix.
      * @returns True if input matches a path from root.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check if a prefix exists
+   *  const trie = new Trie(['hello', 'help', 'world']);
+   *
+   *     console.log(trie.hasPrefix('hel')); // true;
+   *     console.log(trie.hasPrefix('wor')); // true;
+   *     console.log(trie.hasPrefix('xyz')); // false;
      */
     hasPrefix(input: string): boolean;
     /**
@@ -327,6 +563,43 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * Return the longest common prefix among all words.
      * @remarks Time O(H), Space O(1)
      * @returns The longest common prefix string.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Find shared prefix
+   *  const trie = new Trie(['flower', 'flow', 'flight']);
+   *
+   *     console.log(trie.getLongestCommonPrefix()); // 'fl';
      */
     getLongestCommonPrefix(): string;
     /**
@@ -336,12 +609,90 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @param [max] - Maximum number of words to return; default is Number.MAX_SAFE_INTEGER.
      * @param [isAllWhenEmptyPrefix] - When true, collect from root even if prefix is empty.
      * @returns Array of collected words (at most max).
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Trie getWords and prefix search
+   *  const trie = new Trie(['apple', 'app', 'apply', 'application', 'apricot']);
+   *
+   *     // Get all words with prefix 'app'
+   *     const appWords = trie.getWords('app');
+   *     console.log(appWords); // contains 'app';
+   *     console.log(appWords); // contains 'apple';
+   *     console.log(appWords); // contains 'apply';
+   *     console.log(appWords); // contains 'application';
+   *     expect(appWords).not.toContain('apricot');
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
     /**
      * Deep clone this trie by iterating and inserting all words.
      * @remarks Time O(ΣL), Space O(ΣL)
      * @returns A new trie with the same words and options.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Create independent copy
+   *  const trie = new Trie(['hello', 'world']);
+   *     const copy = trie.clone();
+   *     copy.delete('hello');
+   *     console.log(trie.has('hello')); // true;
      */
     clone(): this;
     /**
@@ -350,9 +701,80 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @param predicate - Predicate (word, index, trie) → boolean to keep word.
      * @param [thisArg] - Value for `this` inside the predicate.
      * @returns A new trie containing words that satisfy the predicate.
-     */
-    filter(predicate: ElementCallback<string, R, boolean>, thisArg?: any): this;
-    map<RM>(callback: ElementCallback<string, R, string>, options?: TrieOptions<RM>, thisArg?: any): Trie<RM>;
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Filter words
+   *  const trie = new Trie(['cat', 'car', 'dog', 'card']);
+   *     const result = trie.filter(w => w.startsWith('ca'));
+   *     console.log(result.size); // 3;
+     */
+    filter(predicate: ElementCallback<string, R, boolean>, thisArg?: unknown): this;
+    /**
+   * Transform words
+  
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Transform words
+ *  const trie = new Trie(['hello', 'world']);
+ *     const upper = trie.map(w => w.toUpperCase());
+ *     console.log(upper.has('HELLO')); // true;
+   */
+    map<RM>(callback: ElementCallback<string, R, string>, options?: TrieOptions<RM>, thisArg?: unknown): Trie<RM>;
     /**
      * Map words into a new trie (possibly different record type).
      * @remarks Time O(ΣL), Space O(ΣL)
@@ -363,7 +785,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new Trie constructed from mapped words.
      */
-    map<EM, RM>(callback: ElementCallback<string, R, EM>, options?: TrieOptions<RM>, thisArg?: any): IterableElementBase<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<string, R, EM>, options?: TrieOptions<RM>, thisArg?: unknown): IterableElementBase<EM, RM>;
     /**
      * Map words into a new trie of the same element type.
      * @remarks Time O(ΣL), Space O(ΣL)
@@ -371,7 +793,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R> {
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new trie with mapped words.
      */
-    mapSame(callback: ElementCallback<string, R, string>, thisArg?: any): this;
+    mapSame(callback: ElementCallback<string, R, string>, thisArg?: unknown): this;
     /**
      * (Protected) Create an empty instance of the same concrete class.
      * @remarks Time O(1), Space O(1)

package/dist/types/interfaces/graph.d.ts

@@ -17,5 +17,5 @@ export interface IGraph<V, E, VO, EO> {
     isEmpty(): boolean;
     clear(): void;
     clone(): this;
-    filter(...args: any[]): this;
+    filter(...args: unknown[]): this;
 }

package/dist/types/types/common.d.ts

@@ -5,10 +5,10 @@ export type Comparator<K> = (a: K, b: K) => number;
 export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 export type NodeDisplayLayout = [string[], number, number, number];
 export interface IterableWithSize<T> extends Iterable<T> {
-    size: number | ((...args: any[]) => number);
+    size: number | ((...args: unknown[]) => number);
 }
 export interface IterableWithLength<T> extends Iterable<T> {
-    length: number | ((...args: any[]) => number);
+    length: number | ((...args: unknown[]) => number);
 }
 export type OptValue<V> = V | undefined;
 export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;

package/dist/types/types/data-structures/binary-tree/segment-tree.d.ts

@@ -1 +1 @@
-export type SegmentTreeNodeVal = number;
+export {};

package/dist/types/types/data-structures/heap/heap.d.ts

@@ -1,5 +1,6 @@
 import { Comparator } from '../../common';
 import { IterableElementBaseOptions } from '../base';
+/** Configuration options for Heap and PriorityQueue. */
 export type HeapOptions<E, R> = IterableElementBaseOptions<E, R> & {
     comparator?: Comparator<E>;
 };

package/dist/types/types/data-structures/linked-list/skip-linked-list.d.ts

@@ -1,4 +1 @@
-export type SkipLinkedListOptions = {
-    maxLevel?: number;
-    probability?: number;
-};
+export {};

package/dist/types/types/data-structures/priority-queue/priority-queue.d.ts

@@ -1,2 +1,3 @@
 import { HeapOptions } from '../heap';
+/** Configuration options for PriorityQueue, same as {@link HeapOptions}. */
 export type PriorityQueueOptions<E, R> = HeapOptions<E, R>;

package/dist/types/types/utils/validate-type.d.ts

@@ -1,18 +1,18 @@
 export type KeyValueObject = {
-    [key: string]: any;
+    [key: string]: unknown;
 };
 export type KeyValueObjectWithKey = {
-    [key: string]: any;
+    [key: string]: unknown;
     key: string | number | symbol;
 };
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 export type ObjectWithoutKey = Omit<KeyValueObject, 'key'>;
 export type ObjectWithNonNumberKey = {
-    [key: string]: any;
+    [key: string]: unknown;
     key: string | boolean | symbol | null | object | undefined;
 };
 export type ObjectWithNumberKey = {
-    [key: string]: any;
+    [key: string]: unknown;
     key: number;
 };
 export type RestrictValByKey = NonNumberNonObjectButDefined | ObjectWithoutKey | ObjectWithNonNumberKey | ObjectWithNumberKey;