@ambarltd/core 0.1.17

package/dist/tree-map.js

@@ -0,0 +1,169 @@
+// Handle sorted-btree's inconsistent default export across ESM/CJS
+import sortedBtreeModule from "sorted-btree";
+const BTree = sortedBtreeModule.default || sortedBtreeModule;
+import { Just, Nothing } from "./maybe";
+const stringMap = () => TreeMap.new((x, y) => x > y ? 1
+    : x < y ? -1
+        : 0);
+/**
+ * Shared base for {@link TreeMap} and {@link ImmutableTreeMap}.
+ *
+ * Holds the BTree state, all read methods, and every bulk transformation.
+ * The only thing each subclass supplies is mutation methods and a `wrap`
+ * factory that lifts a fresh BTree back into its own kind.
+ */
+class TreeMapCore {
+    // @ts-expect-error Unused field to prevent instantiation by casting.
+    _ = null;
+    tree;
+    compare;
+    constructor(tree, compare) {
+        this.tree = tree;
+        this.compare = compare;
+    }
+    get(k) {
+        const found = this.tree.get(k);
+        return found !== undefined ? Just(found) : Nothing();
+    }
+    has(k) {
+        return this.tree.has(k);
+    }
+    keys() {
+        return this.tree.keys();
+    }
+    values() {
+        return this.tree.values();
+    }
+    entries() {
+        return this.tree.entries();
+    }
+    size() {
+        return this.tree.size;
+    }
+    clone() {
+        return this.wrap(this.tree.clone());
+    }
+    /** Create a new map with keys from both maps. */
+    unionWith(other, f) {
+        const t = this.tree.clone();
+        for (const [k, v] of other.entries()) {
+            const found = t.get(k);
+            t.set(k, found !== undefined ? f(found, v) : v);
+        }
+        return this.wrap(t);
+    }
+    /**
+     * Difference in the set of keys.
+     * `A.difference(B)` equals A minus all keys present in B.
+     */
+    difference(other) {
+        const t = this.tree.clone();
+        for (const k of other.keys())
+            t.delete(k);
+        return this.wrap(t);
+    }
+    /** Create a new map from keys common to two other maps. */
+    intersectionWith(other, f) {
+        const result = new BTree([], this.compare);
+        for (const [k, v] of this.entries()) {
+            const found = other.tree.get(k);
+            if (found !== undefined)
+                result.set(k, f(v, found));
+        }
+        return this.wrap(result);
+    }
+    mapWithKeys(f) {
+        return this.wrap(this.tree.mapValues((v, k) => f(k, v)));
+    }
+    map(f) {
+        return this.mapWithKeys((_, v) => f(v));
+    }
+}
+/**
+ * A mutable Map type that requires a comparison function.
+ *
+ * This is just a wrapper around BTree which requires the comparison function.
+ */
+class TreeMap extends TreeMapCore {
+    static new(compare) {
+        return new TreeMap(new BTree([], compare), compare);
+    }
+    static new_() {
+        const compare = (x, y) => x.compare(y);
+        return new TreeMap(new BTree([], compare), compare);
+    }
+    static from(compare, xs) {
+        return TreeMap.new(compare).setEntries(xs[Symbol.iterator]());
+    }
+    static from_(xs) {
+        return TreeMap.new_().setEntries(xs[Symbol.iterator]());
+    }
+    wrap(tree) {
+        return new TreeMap(tree, this.compare);
+    }
+    set(k, v) {
+        this.tree.set(k, v);
+        return this;
+    }
+    setWith(k, v, f) {
+        const found = this.tree.get(k);
+        this.tree.set(k, found !== undefined ? f(found, v) : v);
+        return this;
+    }
+    remove(k) {
+        this.tree.delete(k);
+        return this;
+    }
+    setEntries(it) {
+        for (const [k, v] of it)
+            this.tree.set(k, v);
+        return this;
+    }
+}
+/**
+ * An immutable Map type that requires a comparison function.
+ *
+ * Every update returns a new ImmutableTreeMap; the receiver is untouched.
+ * Each update clones the underlying BTree before mutating the copy.
+ */
+class ImmutableTreeMap extends TreeMapCore {
+    static new(compare) {
+        return new ImmutableTreeMap(new BTree([], compare), compare);
+    }
+    static new_() {
+        const compare = (x, y) => x.compare(y);
+        return new ImmutableTreeMap(new BTree([], compare), compare);
+    }
+    static from(compare, xs) {
+        return ImmutableTreeMap.new(compare).setEntries(xs[Symbol.iterator]());
+    }
+    static from_(xs) {
+        return ImmutableTreeMap.new_().setEntries(xs[Symbol.iterator]());
+    }
+    wrap(tree) {
+        return new ImmutableTreeMap(tree, this.compare);
+    }
+    set(k, v) {
+        const t = this.tree.clone();
+        t.set(k, v);
+        return new ImmutableTreeMap(t, this.compare);
+    }
+    setWith(k, v, f) {
+        const t = this.tree.clone();
+        const found = t.get(k);
+        t.set(k, found !== undefined ? f(found, v) : v);
+        return new ImmutableTreeMap(t, this.compare);
+    }
+    remove(k) {
+        const t = this.tree.clone();
+        t.delete(k);
+        return new ImmutableTreeMap(t, this.compare);
+    }
+    setEntries(it) {
+        const t = this.tree.clone();
+        for (const [k, v] of it)
+            t.set(k, v);
+        return new ImmutableTreeMap(t, this.compare);
+    }
+}
+export { TreeMap, ImmutableTreeMap, TreeMapCore, stringMap };

package/dist/tree-set.d.ts

@@ -0,0 +1,63 @@
+import { TreeMap, ImmutableTreeMap, TreeMapCore } from "./tree-map";
+interface Comparable<T> {
+    compare(other: T): number;
+}
+/**
+ * Shared base for {@link TreeSet} and {@link ImmutableTreeSet}.
+ *
+ * Holds a {@link TreeMapCore} keyed on the set's elements (with `null`
+ * values), all read methods, and every set-algebra method. Subclasses
+ * supply their mutation methods and a `wrap` factory that lifts a fresh
+ * underlying map back into their own kind.
+ */
+declare abstract class TreeSetCore<K> {
+    private readonly _;
+    protected tree: TreeMapCore<K, null>;
+    protected constructor(tree: TreeMapCore<K, null>);
+    /** Construct a new instance of the same subclass around a fresh map. */
+    protected abstract wrap(tree: TreeMapCore<K, null>): TreeSetCore<K>;
+    has(k: K): boolean;
+    values(): Array<K>;
+    size(): number;
+    union(other: TreeSetCore<K>): this;
+    difference(other: TreeSetCore<K>): this;
+    intersection(other: TreeSetCore<K>): this;
+}
+/**
+ * A mutable Set type that requires a comparison function.
+ *
+ * This is a wrapper around {@link TreeMap} keyed on the elements.
+ */
+declare class TreeSet<K> extends TreeSetCore<K> {
+    protected tree: TreeMap<K, null>;
+    static new<K>(compare: (l: K, r: K) => number): TreeSet<K>;
+    static new_<K extends Comparable<K>>(): TreeSet<K>;
+    /** Return a clone of the set. */
+    static from<K>(set: TreeSet<K>): TreeSet<K>;
+    static from_<K extends Comparable<K>>(xs: Array<K>): TreeSet<K>;
+    private constructor();
+    protected wrap(tree: TreeMapCore<K, null>): TreeSet<K>;
+    insert(k: K): this;
+    remove(k: K): this;
+    insertValues(it: Array<K>): this;
+}
+/**
+ * An immutable Set type that requires a comparison function.
+ *
+ * Every update returns a new ImmutableTreeSet; the receiver is untouched.
+ * Single-element updates use ImmutableTreeMap's structural-sharing primitives,
+ * so they don't copy the entire tree.
+ */
+declare class ImmutableTreeSet<K> extends TreeSetCore<K> {
+    protected tree: ImmutableTreeMap<K, null>;
+    static new<K>(compare: (l: K, r: K) => number): ImmutableTreeSet<K>;
+    static new_<K extends Comparable<K>>(): ImmutableTreeSet<K>;
+    static from<K>(compare: (l: K, r: K) => number, xs: Array<K>): ImmutableTreeSet<K>;
+    static from_<K extends Comparable<K>>(xs: Array<K>): ImmutableTreeSet<K>;
+    private constructor();
+    protected wrap(tree: TreeMapCore<K, null>): ImmutableTreeSet<K>;
+    insert(k: K): ImmutableTreeSet<K>;
+    remove(k: K): ImmutableTreeSet<K>;
+    insertValues(xs: Array<K>): ImmutableTreeSet<K>;
+}
+export { TreeSet, ImmutableTreeSet };

package/dist/tree-set.js

@@ -0,0 +1,114 @@
+import { TreeMap, ImmutableTreeMap } from "./tree-map";
+/**
+ * Shared base for {@link TreeSet} and {@link ImmutableTreeSet}.
+ *
+ * Holds a {@link TreeMapCore} keyed on the set's elements (with `null`
+ * values), all read methods, and every set-algebra method. Subclasses
+ * supply their mutation methods and a `wrap` factory that lifts a fresh
+ * underlying map back into their own kind.
+ */
+class TreeSetCore {
+    // @ts-expect-error Unused field to prevent instantiation by casting.
+    _ = null;
+    tree;
+    constructor(tree) {
+        this.tree = tree;
+    }
+    has(k) {
+        return this.tree.has(k);
+    }
+    values() {
+        return Array.from(this.tree.keys());
+    }
+    size() {
+        return this.tree.size();
+    }
+    union(other) {
+        return this.wrap(this.tree.unionWith(other.tree, (l, _) => l));
+    }
+    difference(other) {
+        return this.wrap(this.tree.difference(other.tree));
+    }
+    intersection(other) {
+        return this.wrap(this.tree.intersectionWith(other.tree, (v, _) => v));
+    }
+}
+/**
+ * A mutable Set type that requires a comparison function.
+ *
+ * This is a wrapper around {@link TreeMap} keyed on the elements.
+ */
+class TreeSet extends TreeSetCore {
+    static new(compare) {
+        return new TreeSet(TreeMap.new(compare));
+    }
+    static new_() {
+        const compare = (x, y) => x.compare(y);
+        return new TreeSet(TreeMap.new(compare));
+    }
+    /** Return a clone of the set. */
+    static from(set) {
+        return new TreeSet(set.tree.clone());
+    }
+    static from_(xs) {
+        return TreeSet.new_().insertValues(xs);
+    }
+    constructor(tree) {
+        super(tree);
+    }
+    wrap(tree) {
+        return new TreeSet(tree);
+    }
+    insert(k) {
+        this.tree.set(k, null);
+        return this;
+    }
+    remove(k) {
+        this.tree.remove(k);
+        return this;
+    }
+    insertValues(it) {
+        for (const k of it)
+            this.tree.set(k, null);
+        return this;
+    }
+}
+/**
+ * An immutable Set type that requires a comparison function.
+ *
+ * Every update returns a new ImmutableTreeSet; the receiver is untouched.
+ * Single-element updates use ImmutableTreeMap's structural-sharing primitives,
+ * so they don't copy the entire tree.
+ */
+class ImmutableTreeSet extends TreeSetCore {
+    static new(compare) {
+        return new ImmutableTreeSet(ImmutableTreeMap.new(compare));
+    }
+    static new_() {
+        const compare = (x, y) => x.compare(y);
+        return new ImmutableTreeSet(ImmutableTreeMap.new(compare));
+    }
+    static from(compare, xs) {
+        return new ImmutableTreeSet(ImmutableTreeMap.from(compare, xs.map(k => [k, null])));
+    }
+    static from_(xs) {
+        const compare = (x, y) => x.compare(y);
+        return new ImmutableTreeSet(ImmutableTreeMap.from(compare, xs.map(k => [k, null])));
+    }
+    constructor(tree) {
+        super(tree);
+    }
+    wrap(tree) {
+        return new ImmutableTreeSet(tree);
+    }
+    insert(k) {
+        return new ImmutableTreeSet(this.tree.set(k, null));
+    }
+    remove(k) {
+        return new ImmutableTreeSet(this.tree.remove(k));
+    }
+    insertValues(xs) {
+        return new ImmutableTreeSet(this.tree.setEntries(xs.map(k => [k, null])[Symbol.iterator]()));
+    }
+}
+export { TreeSet, ImmutableTreeSet };

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export { type UnionPick };
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type UnionToOvlds<U> = UnionToIntersection<U extends any ? (f: U) => void : never>;
+type PopUnion<U> = UnionToOvlds<U> extends (a: infer A) => void ? A : never;
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+/**
+ * Convert a union to a tuple.
+ *
+ * ```ts
+ * UnionToTuple<A | B> == [A, B]
+ * ```
+ */
+type UnionToTuple<T, A extends unknown[] = []> = IsUnion<T> extends true ? UnionToTuple<Exclude<T, PopUnion<T>>, [PopUnion<T>, ...A]> : [T, ...A];
+/**
+ * Pick an option from a union.
+ *
+ * ```ts
+ * UnionPick<A | B | C, 0> == A
+ * ```
+ */
+type UnionPick<T, N extends keyof UnionToTuple<T>> = UnionToTuple<T>[N];

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@ambarltd/core",
+  "version": "0.1.17",
+  "license": "UNLICENSED",
+  "type": "module",
+  "repository": "https://github.com/ambarltd/typescript-libs.git",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "tsx tests/main.ts",
+    "typecheck": "tsc --noEmit",
+    "typecheck:watch": "tsc --noEmit --watch",
+    "prepack": "pnpm build"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/context-async-hooks": "^2.7.1",
+    "@opentelemetry/resources": "^2.7.1",
+    "@opentelemetry/sdk-trace-base": "^2.7.1",
+    "@opentelemetry/sdk-trace-node": "^2.7.1",
+    "@opentelemetry/semantic-conventions": "^1.41.1",
+    "@optique/core": "^0.6.2",
+    "@optique/run": "^0.6.2",
+    "fluture": "^14.0.0",
+    "luxon": "^3.7.2",
+    "sorted-btree": "^1.8.1"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/luxon": "^3.7.1",
+    "@types/node": "^24.3.0",
+    "fast-check": "^4.3.0",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.0.0"
+  }
+}