data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,5 +1,5 @@
 import type { Comparator } from '../../common';
-export interface TreeSetOptions<K> {
+export interface TreeSetOptions<K, R = K> {
     comparator?: Comparator<K>;
     /**
      * Pass-through to the underlying RedBlackTree/BST `isMapMode` option.
@@ -8,6 +8,11 @@ export interface TreeSetOptions<K> {
      * - `false`: store values on tree nodes (Node Mode).
      */
     isMapMode?: boolean;
+    /**
+     * Transform raw elements into keys.
+     * When provided, the constructor accepts `Iterable<R>` instead of `Iterable<K>`.
+     */
+    toElementFn?: (rawElement: R) => K;
 }
 export type TreeSetRangeOptions = {
     lowInclusive?: boolean;

package/dist/umd/data-structure-typed.js

@@ -11840,10 +11840,19 @@ var dataStructureTyped = (() => {
   var _core, _isDefaultComparator, _userComparator;
   var _TreeSet = class _TreeSet {
     /**
-     * Create a TreeSet from an iterable of keys.
+     * Create a TreeSet from an iterable of keys or raw elements.
      *
+     * @param elements - Iterable of keys, or raw elements if `toElementFn` is provided.
+     * @param options - Configuration options including optional `toElementFn` to transform raw elements.
      * @throws {TypeError} When using the default comparator and encountering unsupported key types,
      * or invalid keys (e.g. `NaN`, invalid `Date`).
+     * @example
+     * // Standard usage with keys
+     * const set = new TreeSet([3, 1, 2]);
+     *
+     * // Using toElementFn to transform raw objects
+     * const users = [{ id: 3, name: 'Alice' }, { id: 1, name: 'Bob' }];
+     * const set = new TreeSet<number, User>(users, { toElementFn: u => u.id });
      */
     constructor(elements = [], options = {}) {
       __privateAdd(this, _core);
@@ -11851,10 +11860,14 @@ var dataStructureTyped = (() => {
       __privateAdd(this, _userComparator);
       var _a;
       __privateSet(this, _userComparator, options.comparator);
+      const toElementFn = options.toElementFn;
       const comparator = (_a = options.comparator) != null ? _a : _TreeSet.createDefaultComparator();
       __privateSet(this, _isDefaultComparator, options.comparator === void 0);
       __privateSet(this, _core, new RedBlackTree([], { comparator, isMapMode: options.isMapMode }));
-      for (const k of elements) this.add(k);
+      for (const item of elements) {
+        const k = toElementFn ? toElementFn(item) : item;
+        this.add(k);
+      }
     }
     /**
      * Create the strict default comparator.
@@ -12163,9 +12176,16 @@ var dataStructureTyped = (() => {
   var _TreeMultiMap = class _TreeMultiMap {
     /**
      * Creates a new TreeMultiMap.
-     * @param keysNodesEntriesOrRaws - Initial entries
-     * @param options - Configuration options
+     * @param keysNodesEntriesOrRaws - Initial entries, or raw elements if `toEntryFn` is provided.
+     * @param options - Configuration options including optional `toEntryFn` to transform raw elements.
      * @remarks Time O(m log m), Space O(m) where m is the number of initial entries
+     * @example
+     * // Standard usage with entries
+     * const mmap = new TreeMultiMap([['a', ['x', 'y']], ['b', ['z']]]);
+     *
+     * // Using toEntryFn to transform raw objects
+     * const players = [{ score: 100, items: ['sword'] }, { score: 200, items: ['shield', 'bow'] }];
+     * const mmap = new TreeMultiMap(players, { toEntryFn: p => [p.score, p.items] });
      */
     constructor(keysNodesEntriesOrRaws = [], options = {}) {
       __privateAdd(this, _core2);
@@ -12173,9 +12193,20 @@ var dataStructureTyped = (() => {
       var _a;
       const comparator = (_a = options.comparator) != null ? _a : TreeSet.createDefaultComparator();
       __privateSet(this, _isDefaultComparator2, options.comparator === void 0);
+      const toEntryFn = options.toEntryFn;
       __privateSet(this, _core2, new RedBlackTree([], { ...options, comparator, isMapMode: options.isMapMode }));
       for (const x of keysNodesEntriesOrRaws) {
         if (x === null || x === void 0) continue;
+        if (toEntryFn) {
+          const [k, bucket] = toEntryFn(x);
+          if (k === null || k === void 0) continue;
+          if (bucket !== void 0) {
+            __privateGet(this, _core2).set(k, Array.isArray(bucket) ? [...bucket] : [bucket]);
+          } else {
+            __privateGet(this, _core2).set(k, []);
+          }
+          continue;
+        }
         if (Array.isArray(x)) {
           const [k, bucket] = x;
           if (k === null || k === void 0) continue;
@@ -12511,8 +12542,8 @@ var dataStructureTyped = (() => {
      * Prints the internal tree structure (for debugging).
      * @remarks Time O(n), Space O(n)
      */
-    print(...args) {
-      return __privateGet(this, _core2).print(...args);
+    print() {
+      __privateGet(this, _core2).print();
     }
     /**
      * Executes a callback for each entry.
@@ -12563,7 +12594,7 @@ var dataStructureTyped = (() => {
     setMany(keysNodesEntriesOrRaws) {
       const results = [];
       for (const x of keysNodesEntriesOrRaws) {
-        results.push(this.set(x, void 0));
+        results.push(this.set(x));
       }
       return results;
     }
@@ -12571,22 +12602,22 @@ var dataStructureTyped = (() => {
      * Searches for entries within a key range.
      * @remarks Time O(log n + k), Space O(k) where k is result size
      */
-    rangeSearch(range, callback, isBalanced) {
-      return __privateGet(this, _core2).rangeSearch(range, callback, isBalanced);
+    rangeSearch(range, callback) {
+      return __privateGet(this, _core2).rangeSearch(range, callback);
     }
     /**
      * Creates a shallow clone of this map.
      * @remarks Time O(n log n), Space O(n)
      */
     clone() {
-      return new _TreeMultiMap(this, { comparator: this.comparator, isMapMode: __privateGet(this, _core2)._isMapMode });
+      return new _TreeMultiMap(this, { comparator: this.comparator, isMapMode: __privateGet(this, _core2).isMapMode });
     }
     /**
      * Expose comparator for advanced usage/testing (read-only).
      * @remarks Time O(1), Space O(1)
      */
     get comparator() {
-      return __privateGet(this, _core2)._comparator;
+      return __privateGet(this, _core2).comparator;
     }
   };
   _core2 = new WeakMap();
@@ -12597,10 +12628,19 @@ var dataStructureTyped = (() => {
   var _core3, _isDefaultComparator3, _userComparator2;
   var _TreeMap = class _TreeMap {
     /**
-     * Create a TreeMap from an iterable of `[key, value]` entries.
+     * Create a TreeMap from an iterable of `[key, value]` entries or raw elements.
+     *
+     * @param entries - Iterable of `[key, value]` tuples, or raw elements if `toEntryFn` is provided.
+     * @param options - Configuration options including optional `toEntryFn` to transform raw elements.
+     * @throws {TypeError} If any entry is not a 2-tuple-like value (when no toEntryFn), or when using
+     * the default comparator and encountering unsupported/invalid keys (e.g. `NaN`, invalid `Date`).
+     * @example
+     * // Standard usage with entries
+     * const map = new TreeMap([['a', 1], ['b', 2]]);
      *
-     * @throws {TypeError} If any entry is not a 2-tuple-like value, or when using the default comparator
-     * and encountering unsupported/invalid keys (e.g. `NaN`, invalid `Date`).
+     * // Using toEntryFn to transform raw objects
+     * const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+     * const map = new TreeMap<number, User, User>(users, { toEntryFn: u => [u.id, u] });
      */
     constructor(entries = [], options = {}) {
       __privateAdd(this, _core3);
@@ -12608,15 +12648,22 @@ var dataStructureTyped = (() => {
       __privateAdd(this, _userComparator2);
       var _a;
       __privateSet(this, _userComparator2, options.comparator);
+      const toEntryFn = options.toEntryFn;
       const comparator = (_a = options.comparator) != null ? _a : _TreeMap.createDefaultComparator();
       __privateSet(this, _isDefaultComparator3, options.comparator === void 0);
       __privateSet(this, _core3, new RedBlackTree([], { comparator, isMapMode: options.isMapMode }));
       for (const item of entries) {
-        if (!Array.isArray(item) || item.length < 2) {
-          throw new TypeError("TreeMap: each entry must be a [key, value] tuple");
+        let k;
+        let v;
+        if (toEntryFn) {
+          [k, v] = toEntryFn(item);
+        } else {
+          if (!Array.isArray(item) || item.length < 2) {
+            throw new TypeError("TreeMap: each entry must be a [key, value] tuple");
+          }
+          k = item[0];
+          v = item[1];
         }
-        const k = item[0];
-        const v = item[1];
         this.set(k, v);
       }
     }
@@ -12942,19 +12989,30 @@ var dataStructureTyped = (() => {
     // total occurrences (sumCounts)
     /**
      * Creates a new TreeMultiSet.
-     * @param elements - Initial elements to add
-     * @param options - Configuration options
+     * @param elements - Initial elements to add, or raw elements if `toElementFn` is provided.
+     * @param options - Configuration options including optional `toElementFn` to transform raw elements.
      * @remarks Time O(m log m), Space O(m) where m is the number of initial elements
+     * @example
+     * // Standard usage with elements
+     * const mset = new TreeMultiSet([1, 2, 2, 3]);
+     *
+     * // Using toElementFn to transform raw objects
+     * const items = [{ score: 100 }, { score: 200 }, { score: 100 }];
+     * const mset = new TreeMultiSet<number, Item>(items, { toElementFn: item => item.score });
      */
     constructor(elements = [], options = {}) {
       __privateAdd(this, _core4);
       __privateAdd(this, _isDefaultComparator4);
       __publicField(this, "_size", 0);
       var _a;
+      const toElementFn = options.toElementFn;
       const comparator = (_a = options.comparator) != null ? _a : TreeSet.createDefaultComparator();
       __privateSet(this, _isDefaultComparator4, options.comparator === void 0);
       __privateSet(this, _core4, new RedBlackTree([], { comparator, isMapMode: options.isMapMode }));
-      for (const k of elements) this.add(k);
+      for (const item of elements) {
+        const k = toElementFn ? toElementFn(item) : item;
+        this.add(k);
+      }
     }
     /**
      * Validates the key against the default comparator rules.
@@ -14278,19 +14336,17 @@ var dataStructureTyped = (() => {
       prefix = this._caseProcess(prefix);
       const words = [];
       let found = 0;
-      function dfs(node, word) {
-        for (const char of node.children.keys()) {
-          const charNode = node.children.get(char);
-          if (charNode !== void 0) {
-            dfs(charNode, word.concat(char));
-          }
+      const dfs = (node, word) => {
+        for (const [char, childNode] of node.children) {
+          if (found >= max) return;
+          dfs(childNode, word + char);
         }
         if (node.isEnd) {
-          if (found > max - 1) return;
+          if (found >= max) return;
           words.push(word);
           found++;
         }
-      }
+      };
       let startNode = this.root;
       if (prefix) {
         for (const c of prefix) {