@rhombus-toolkit/collections 0.0.0-placeholder.0 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 rhombus-toolkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bundle/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Extending answers a new list sharing everything already there, so whoever holds one reads
+ * exactly what it held however much is added or removed afterwards.
+ *
+ * @remarks
+ * Both ends are known. {@link push} adds at the head and shares the whole list after it, which
+ * leaves the tail the same link it already was — so a list knows what it ends with without ever
+ * walking to find out. {@link tailToHead} is settled once per list and answered from then on, which
+ * is what lets a list be read from its tail as often as wanted without paying to reverse it.
+ */
+declare class ImmutableLinkedList<T> implements Iterable<T> {
+    #private;
+    /** How many values the list holds. */
+    readonly size: number;
+    private constructor();
+    /** A list of `T` with nothing in it. */
+    static empty<T>(): ImmutableLinkedList<T>;
+    /** The value at the head, absent where the list holds nothing. */
+    get head(): T | undefined;
+    /** The value at the tail, absent where the list holds nothing. */
+    get tail(): T | undefined;
+    /** This list with `value` at the head, everything already here shared. */
+    push(value: T): ImmutableLinkedList<T>;
+    /**
+     * This list without the first value `matches` answers for, everything after it shared; the list
+     * itself where nothing matches.
+     */
+    remove(matches: (value: T) => boolean): ImmutableLinkedList<T>;
+    /** The values from the head to the tail. */
+    [Symbol.iterator](): Iterator<T>;
+    /** The values from the tail to the head. */
+    tailToHead(): readonly T[];
+}
+
+declare class KindaWeakMap<K, V extends object> {
+    #private;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    clear(): void;
+    forEach(callbackfn: (value: V, key: K, map: this) => void, thisArg?: any): void;
+    get size(): number;
+    entries(): MapIterator<[K, V]>;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V | undefined>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    readonly [Symbol.toStringTag]: "KindaWeakMap";
+}
+
+export { ImmutableLinkedList, KindaWeakMap };

package/dist/bundle/index.js

@@ -0,0 +1,118 @@
+// src/ImmutableLinkedList.ts
+class ImmutableLinkedList {
+  static #nothing = new ImmutableLinkedList(undefined, undefined, 0);
+  #head;
+  #tail;
+  #reversed;
+  size;
+  constructor(head, tail, size) {
+    this.#head = head;
+    this.#tail = tail;
+    this.size = size;
+  }
+  static empty() {
+    return ImmutableLinkedList.#nothing;
+  }
+  get head() {
+    return this.#head?.value;
+  }
+  get tail() {
+    return this.#tail?.value;
+  }
+  push(value) {
+    const head = { value, next: this.#head };
+    return new ImmutableLinkedList(head, this.#tail ?? head, this.size + 1);
+  }
+  remove(matches) {
+    const head = removed(this.#head, matches);
+    if (head === this.#head) {
+      return this;
+    }
+    return new ImmutableLinkedList(head, tailOf(head), this.size - 1);
+  }
+  *[Symbol.iterator]() {
+    for (let link = this.#head;link !== undefined; link = link.next) {
+      yield link.value;
+    }
+  }
+  tailToHead() {
+    this.#reversed ??= [...this].reverse();
+    return this.#reversed;
+  }
+}
+function removed(link, matches) {
+  if (link === undefined) {
+    return;
+  }
+  if (matches(link.value)) {
+    return link.next;
+  }
+  const next = removed(link.next, matches);
+  return next === link.next ? link : { value: link.value, next };
+}
+function tailOf(link) {
+  let tail = link;
+  while (tail?.next !== undefined) {
+    tail = tail.next;
+  }
+  return tail;
+}
+// src/KindaWeakMap.ts
+class KindaWeakMap {
+  #map = new Map;
+  #registry = new FinalizationRegistry((key) => {
+    if (this.#map.get(key)?.deref() === undefined) {
+      this.#map.delete(key);
+    }
+  });
+  set(key, value) {
+    if (this.has(key)) {
+      this.delete(key);
+    }
+    this.#registry.register(value, key, value);
+    this.#map.set(key, new WeakRef(value));
+    return this;
+  }
+  delete(key) {
+    const val = this.get(key);
+    if (val !== undefined) {
+      this.#registry.unregister(val);
+    }
+    return this.#map.delete(key);
+  }
+  get(key) {
+    return this.#map.get(key)?.deref();
+  }
+  has(key) {
+    return this.#map.has(key);
+  }
+  clear() {
+    this.values().filter(Boolean).forEach((p) => this.#registry.unregister(p));
+    this.#map.clear();
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [key, value] of this) {
+      callbackfn.call(thisArg, value, key, this);
+    }
+  }
+  get size() {
+    return this.#map.size;
+  }
+  entries() {
+    return this.#map.entries().map(([key, ref]) => [key, ref.deref()]);
+  }
+  keys() {
+    return this.#map.keys();
+  }
+  values() {
+    return this.#map.values().map((ref) => ref.deref());
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  [Symbol.toStringTag] = "KindaWeakMap";
+}
+export {
+  ImmutableLinkedList,
+  KindaWeakMap
+};

package/package.json

@@ -1,16 +1,35 @@
 {
   "name": "@rhombus-toolkit/collections",
-  "version": "0.0.0-placeholder.0",
-  "description": "Placeholder reserving the name; the real package follows.",
+  "version": "2.0.0",
+  "description": "Collection data structures: ImmutableLinkedList (persistent, both ends known), KindaWeakMap (strong keys, weak values).",
   "repository": {
     "type": "git",
     "url": "https://github.com/rhombus-toolkit/ts.git",
     "directory": "libraries/collections"
   },
   "type": "module",
+  "sideEffects": false,
+  "main": "./dist/bundle/index.js",
+  "types": "./dist/bundle/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/bundle/index.d.ts",
+      "import": "./dist/bundle/index.js",
+      "default": "./dist/bundle/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
   "author": "Thomas Butler",
-  "license": "MIT",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build-lib.ts",
+    "lint": "bun x tsc --noEmit -p tsconfig.ci.json",
+    "test": "bun test --pass-with-no-tests"
   }
-}
+}

package/README.md

@@ -1 +0,0 @@
-Placeholder reserving `@rhombus-toolkit/collections`. The real package follows.