@thi.ng/sorted-map 1.1.42 → 1.2.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2025-06-09T17:24:08Z
+- **Last updated**: 2025-07-10T14:20:23Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -11,6 +11,19 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [1.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/sorted-map@1.2.0) (2025-07-10)
+
+#### 🚀 Features
+
+- add `Symbol.dispose` support ([7583094](https://github.com/thi-ng/umbrella/commit/7583094))
+  - update all `SortedMap` & `SortedSet` impls
+
+#### ♻️ Refactoring
+
+- update all Map/Set private state and `toString()` impls ([#505](https://github.com/thi-ng/umbrella/issues/505)) ([ce2e43a](https://github.com/thi-ng/umbrella/commit/ce2e43a))
+  - use private class properties instead of WeakMap to strore internal state
+  - replace `__inspectable` with `__tostringMixin`
+
 ### [1.1.29](https://github.com/thi-ng/umbrella/tree/@thi.ng/sorted-map@1.1.29) (2025-03-10)
 
 #### 🩹 Bug fixes

package/README.md

@@ -153,7 +153,7 @@ For Node.js REPL:
 const sm = await import("@thi.ng/sorted-map");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.70 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.91 KB
 
 ## Dependencies
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/sorted-map",
-  "version": "1.1.42",
+  "version": "1.2.1",
   "description": "Skiplist-based sorted map & set implementation",
   "type": "module",
   "module": "./index.js",
@@ -39,16 +39,16 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.11.29",
-    "@thi.ng/associative": "^7.0.41",
-    "@thi.ng/checks": "^3.7.9",
-    "@thi.ng/compare": "^2.4.21",
-    "@thi.ng/random": "^4.1.20",
-    "@thi.ng/transducers": "^9.5.0"
+    "@thi.ng/api": "^8.11.30",
+    "@thi.ng/associative": "^7.1.1",
+    "@thi.ng/checks": "^3.7.10",
+    "@thi.ng/compare": "^2.4.22",
+    "@thi.ng/random": "^4.1.21",
+    "@thi.ng/transducers": "^9.6.0"
   },
   "devDependencies": {
-    "esbuild": "^0.25.5",
-    "typedoc": "^0.28.5",
+    "esbuild": "^0.25.6",
+    "typedoc": "^0.28.7",
     "typescript": "^5.8.3"
   },
   "keywords": [
@@ -97,5 +97,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "e657c2d66574c18343a6797aef4585945729093e\n"
+  "gitHead": "a81765bd79046980463c56a8bd187f9aaa88dd65\n"
 }

package/sorted-map.d.ts

@@ -25,10 +25,13 @@ declare class Node<K, V> {
  * - https://www.educba.com/skip-list-java/
  */
 export declare class SortedMap<K, V> extends Map<K, V> {
+    #private;
     constructor(pairs?: Iterable<Pair<K, V>> | null, opts?: Partial<SortedMapOpts<K>>);
     get size(): number;
     get [Symbol.species](): typeof SortedMap;
-    [Symbol.iterator](): IterableIterator<Pair<K, V>>;
+    get [Symbol.toStringTag](): string;
+    [Symbol.iterator](): MapIterator<Pair<K, V>>;
+    [Symbol.dispose](): void;
     /**
      * Yields iterator of sorted `[key, value]` pairs, optionally taking given
      * `key` and `max` flag into account.
@@ -44,21 +47,21 @@ export declare class SortedMap<K, V> extends Map<K, V> {
      * @param key
      * @param max
      */
-    entries(key?: K, max?: boolean): IterableIterator<Pair<K, V>>;
+    entries(key?: K, max?: boolean): MapIterator<Pair<K, V>>;
     /**
      * Similar to {@link SortedMap.entries}, but only yield sequence of keys.
      *
      * @param key
      * @param max
      */
-    keys(key?: K, max?: boolean): IterableIterator<K>;
+    keys(key?: K, max?: boolean): MapIterator<K>;
     /**
      * Similar to {@link SortedMap.entries}, but only yield sequence of values.
      *
      * @param key
      * @param max
      */
-    values(key?: K, max?: boolean): IterableIterator<V>;
+    values(key?: K, max?: boolean): MapIterator<V>;
     clear(): void;
     empty(): SortedMap<K, V>;
     copy(): SortedMap<K, V>;

package/sorted-map.js

@@ -1,5 +1,8 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -8,14 +11,27 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _head, _cmp, _p, _rnd, _size;
 import { dissoc } from "@thi.ng/associative/dissoc";
+import { __disposableEntries } from "@thi.ng/associative/internal/dispose";
 import { __equivMap } from "@thi.ng/associative/internal/equiv";
-import { __inspectable } from "@thi.ng/associative/internal/inspect";
+import { __tostringMixin } from "@thi.ng/associative/internal/tostring";
 import { into } from "@thi.ng/associative/into";
 import { isPlainObject } from "@thi.ng/checks/is-plain-object";
 import { compare } from "@thi.ng/compare/compare";
 import { SYSTEM } from "@thi.ng/random/system";
-import { map } from "@thi.ng/transducers/map";
 import { isReduced } from "@thi.ng/transducers/reduced";
 class Node {
   constructor(k, v, level = 0) {
@@ -28,27 +44,32 @@ class Node {
   up;
   down;
 }
-const __private = /* @__PURE__ */ new WeakMap();
 let SortedMap = class extends Map {
   constructor(pairs, opts = {}) {
     super();
-    __private.set(this, {
-      head: new Node(),
-      cmp: opts.compare || compare,
-      rnd: opts.rnd || SYSTEM,
-      p: opts.probability || 1 / Math.E,
-      size: 0
-    });
+    __privateAdd(this, _head);
+    __privateAdd(this, _cmp);
+    __privateAdd(this, _p);
+    __privateAdd(this, _rnd);
+    __privateAdd(this, _size);
+    __privateSet(this, _head, new Node());
+    __privateSet(this, _cmp, opts.compare || compare);
+    __privateSet(this, _rnd, opts.rnd || SYSTEM);
+    __privateSet(this, _p, opts.probability || 1 / Math.E);
+    __privateSet(this, _size, 0);
     if (pairs) {
       this.into(pairs);
     }
   }
   get size() {
-    return __private.get(this).size;
+    return __privateGet(this, _size);
   }
   get [Symbol.species]() {
     return SortedMap;
   }
+  get [Symbol.toStringTag]() {
+    return "SortedMap";
+  }
   *[Symbol.iterator]() {
     let node = this.firstNode();
     while (node?.k !== void 0) {
@@ -56,6 +77,9 @@ let SortedMap = class extends Map {
       node = node.next;
     }
   }
+  // mixin
+  [Symbol.dispose]() {
+  }
   /**
    * Yields iterator of sorted `[key, value]` pairs, optionally taking given
    * `key` and `max` flag into account.
@@ -76,8 +100,8 @@ let SortedMap = class extends Map {
       yield* this;
       return;
     }
-    const { cmp, size } = __private.get(this);
-    if (!size) return;
+    if (!__privateGet(this, _size)) return;
+    const cmp = __privateGet(this, _cmp);
     if (max) {
       let node = this.firstNode();
       while (node?.k !== void 0 && cmp(node.k, key) <= 0) {
@@ -101,8 +125,10 @@ let SortedMap = class extends Map {
    * @param key
    * @param max
    */
-  keys(key, max = false) {
-    return map((p) => p[0], this.entries(key, max));
+  *keys(key, max = false) {
+    for (let p of this.entries(key, max)) {
+      yield p[0];
+    }
   }
   /**
    * Similar to {@link SortedMap.entries}, but only yield sequence of values.
@@ -110,13 +136,14 @@ let SortedMap = class extends Map {
    * @param key
    * @param max
    */
-  values(key, max = false) {
-    return map((p) => p[1], this.entries(key, max));
+  *values(key, max = false) {
+    for (let p of this.entries(key, max)) {
+      yield p[1];
+    }
   }
   clear() {
-    const $this = __private.get(this);
-    $this.head = new Node();
-    $this.size = 0;
+    __privateSet(this, _head, new Node());
+    __privateSet(this, _size, 0);
   }
   empty() {
     return new SortedMap(null, this.opts());
@@ -148,20 +175,16 @@ let SortedMap = class extends Map {
     return node?.k !== void 0 ? [node.k, node.v] : void 0;
   }
   get(key, notFound) {
-    const $this = __private.get(this);
     const node = this.findNode(key);
-    return node.k !== void 0 && $this.cmp(node.k, key) === 0 ? node.v : notFound;
+    return node.k !== void 0 && __privateGet(this, _cmp).call(this, node.k, key) === 0 ? node.v : notFound;
   }
   has(key) {
-    const { cmp } = __private.get(this);
     const node = this.findNode(key);
-    return node.k !== void 0 && cmp(node.k, key) === 0;
+    return node.k !== void 0 && __privateGet(this, _cmp).call(this, node.k, key) === 0;
   }
   set(key, val) {
-    const $this = __private.get(this);
-    const { cmp, p, rnd } = $this;
     let node = this.findNode(key);
-    if (node.k !== void 0 && cmp(node.k, key) === 0) {
+    if (node.k !== void 0 && __privateGet(this, _cmp).call(this, node.k, key) === 0) {
       node.v = val;
       while (node.down) {
         node = node.down;
@@ -172,7 +195,9 @@ let SortedMap = class extends Map {
     let newNode = new Node(key, val, node.level);
     this.insertInLane(node, newNode);
     let currLevel = node.level;
-    let headLevel = $this.head.level;
+    let headLevel = __privateGet(this, _head).level;
+    const rnd = __privateGet(this, _rnd);
+    const p = __privateGet(this, _p);
     while (rnd.probability(p)) {
       if (currLevel >= headLevel) {
         const newHead = new Node(
@@ -180,8 +205,8 @@ let SortedMap = class extends Map {
           void 0,
           headLevel + 1
         );
-        this.linkLanes(newHead, $this.head);
-        $this.head = newHead;
+        this.linkLanes(newHead, __privateGet(this, _head));
+        __privateSet(this, _head, newHead);
         headLevel++;
       }
       while (!node.up) node = node.prev;
@@ -192,13 +217,12 @@ let SortedMap = class extends Map {
       newNode = tmp;
       currLevel++;
     }
-    $this.size++;
+    __privateWrapper(this, _size)._++;
     return this;
   }
   delete(key) {
-    const $this = __private.get(this);
     let node = this.findNode(key);
-    if (node.k === void 0 || $this.cmp(node.k, key) !== 0) return false;
+    if (node.k === void 0 || __privateGet(this, _cmp).call(this, node.k, key) !== 0) return false;
     while (node.down) node = node.down;
     let prev;
     let next;
@@ -209,11 +233,11 @@ let SortedMap = class extends Map {
       if (next) next.prev = prev;
       node = node.up;
     }
-    while (!$this.head.next && $this.head.down) {
-      $this.head = $this.head.down;
-      $this.head.up = void 0;
+    while (!__privateGet(this, _head).next && __privateGet(this, _head).down) {
+      __privateSet(this, _head, __privateGet(this, _head).down);
+      __privateGet(this, _head).up = void 0;
     }
-    $this.size--;
+    __privateWrapper(this, _size)._--;
     return true;
   }
   into(pairs) {
@@ -244,11 +268,10 @@ let SortedMap = class extends Map {
     return acc;
   }
   opts() {
-    const $this = __private.get(this);
     return {
-      compare: $this.cmp,
-      probability: $this.p,
-      rnd: $this.rnd
+      compare: __privateGet(this, _cmp),
+      probability: __privateGet(this, _p),
+      rnd: __privateGet(this, _rnd)
     };
   }
   /**
@@ -278,8 +301,7 @@ let SortedMap = class extends Map {
    * will be the first data node (with the smallest key).
    */
   firstNode() {
-    const { head } = __private.get(this);
-    let node = head;
+    let node = __privateGet(this, _head);
     while (node.down) node = node.down;
     while (node.prev) node = node.prev;
     if (node.next) node = node.next;
@@ -292,8 +314,8 @@ let SortedMap = class extends Map {
    * @param key
    */
   findNode(key) {
-    let { cmp, head } = __private.get(this);
-    let node = head;
+    const cmp = __privateGet(this, _cmp);
+    let node = __privateGet(this, _head);
     let next;
     let down;
     let nodeKey;
@@ -312,8 +334,14 @@ let SortedMap = class extends Map {
     return node;
   }
 };
+_head = new WeakMap();
+_cmp = new WeakMap();
+_p = new WeakMap();
+_rnd = new WeakMap();
+_size = new WeakMap();
 SortedMap = __decorateClass([
-  __inspectable
+  __disposableEntries,
+  __tostringMixin
 ], SortedMap);
 function defSortedMap(src, opts) {
   return isPlainObject(src) ? new SortedMap(Object.entries(src), opts) : new SortedMap(src, opts);

package/sorted-set.d.ts

@@ -24,6 +24,7 @@ import type { SortedSetOpts } from "./api.js";
  * resizing characteristics.
  */
 export declare class SortedSet<T> extends Set<T> implements IEquivSet<T>, ICompare<Set<T>>, IReducible<T, any> {
+    #private;
     /**
      * Creates new instance with optional given values and/or
      * implementation options. The options are the same as used by
@@ -33,7 +34,8 @@ export declare class SortedSet<T> extends Set<T> implements IEquivSet<T>, ICompa
      * @param opts - config options
      */
     constructor(values?: Iterable<T> | null, opts?: Partial<SortedSetOpts<T>>);
-    [Symbol.iterator](): IterableIterator<T>;
+    [Symbol.iterator](): SetIterator<T>;
+    [Symbol.dispose](): void;
     get [Symbol.species](): typeof SortedSet;
     get [Symbol.toStringTag](): string;
     get size(): number;
@@ -42,9 +44,9 @@ export declare class SortedSet<T> extends Set<T> implements IEquivSet<T>, ICompa
     compare(o: Set<T>): number;
     equiv(o: any): boolean;
     $reduce<R>(rfn: ReductionFn<T, any>, acc: R | Reduced<R>): R | Reduced<R>;
-    entries(key?: T, max?: boolean): IterableIterator<Pair<T, T>>;
-    keys(key?: T, max?: boolean): IterableIterator<T>;
-    values(key?: T, max?: boolean): IterableIterator<T>;
+    entries(key?: T, max?: boolean): SetIterator<Pair<T, T>>;
+    keys(key?: T, max?: boolean): SetIterator<T>;
+    values(key?: T, max?: boolean): SetIterator<T>;
     add(key: T): this;
     into(keys: Iterable<T>): this;
     clear(): void;

package/sorted-set.js

@@ -1,5 +1,8 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -8,14 +11,19 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _map;
 import { dissoc } from "@thi.ng/associative/dissoc";
+import { __disposableValues } from "@thi.ng/associative/internal/dispose";
 import { __equivSet } from "@thi.ng/associative/internal/equiv";
-import { __inspectable } from "@thi.ng/associative/internal/inspect";
+import { __tostringMixin } from "@thi.ng/associative/internal/tostring";
 import { into } from "@thi.ng/associative/into";
 import { compare } from "@thi.ng/compare/compare";
 import { map } from "@thi.ng/transducers/map";
 import { SortedMap } from "./sorted-map.js";
-const __private = /* @__PURE__ */ new WeakMap();
 let SortedSet = class extends Set {
   /**
    * Creates new instance with optional given values and/or
@@ -27,17 +35,18 @@ let SortedSet = class extends Set {
    */
   constructor(values, opts) {
     super();
-    __private.set(
-      this,
-      new SortedMap(
-        values ? map((x) => [x, x], values) : null,
-        opts
-      )
-    );
+    __privateAdd(this, _map);
+    __privateSet(this, _map, new SortedMap(
+      values ? map((x) => [x, x], values) : null,
+      opts
+    ));
   }
   [Symbol.iterator]() {
     return this.keys();
   }
+  // mixin
+  [Symbol.dispose]() {
+  }
   get [Symbol.species]() {
     return SortedSet;
   }
@@ -45,7 +54,7 @@ let SortedSet = class extends Set {
     return "SortedSet";
   }
   get size() {
-    return __private.get(this).size;
+    return __privateGet(this, _map).size;
   }
   copy() {
     return new SortedSet(this.keys(), this.opts());
@@ -73,33 +82,33 @@ let SortedSet = class extends Set {
     return __equivSet(this, o);
   }
   $reduce(rfn, acc) {
-    return __private.get(this).$reduce((_acc, x) => rfn(_acc, x[0]), acc);
+    return __privateGet(this, _map).$reduce((_acc, x) => rfn(_acc, x[0]), acc);
   }
   entries(key, max = false) {
-    return __private.get(this).entries(key, max);
+    return __privateGet(this, _map).entries(key, max);
   }
   keys(key, max = false) {
-    return __private.get(this).keys(key, max);
+    return __privateGet(this, _map).keys(key, max);
   }
   values(key, max = false) {
-    return __private.get(this).values(key, max);
+    return __privateGet(this, _map).values(key, max);
   }
   add(key) {
-    __private.get(this).set(key, key);
+    __privateGet(this, _map).set(key, key);
     return this;
   }
   into(keys) {
     return into(this, keys);
   }
   clear() {
-    __private.get(this).clear();
+    __privateGet(this, _map).clear();
   }
   first() {
-    const first = __private.get(this).first();
+    const first = __privateGet(this, _map).first();
     return first ? first[0] : void 0;
   }
   delete(key) {
-    return __private.get(this).delete(key);
+    return __privateGet(this, _map).delete(key);
   }
   disj(keys) {
     return dissoc(this, keys);
@@ -110,17 +119,19 @@ let SortedSet = class extends Set {
     }
   }
   has(key) {
-    return __private.get(this).has(key);
+    return __privateGet(this, _map).has(key);
   }
   get(key, notFound) {
-    return __private.get(this).get(key, notFound);
+    return __privateGet(this, _map).get(key, notFound);
   }
   opts() {
-    return __private.get(this).opts();
+    return __privateGet(this, _map).opts();
   }
 };
+_map = new WeakMap();
 SortedSet = __decorateClass([
-  __inspectable
+  __disposableValues,
+  __tostringMixin
 ], SortedSet);
 const defSortedSet = (vals, opts) => new SortedSet(vals, opts);
 export {