creo 0.0.2 → 0.0.4-dev

package/src/data-structures/indexed-map/IndexedMap.ts

@@ -0,0 +1,281 @@
+import { Maybe } from "../maybe/Maybe";
+
+type LinkNode<T, K> = {
+  value: T;
+  cachedIndexValues: Map<keyof T, T[keyof T]>;
+  prev: Maybe<LinkNode<T, K>>;
+  next: Maybe<LinkNode<T, K>>;
+};
+
+// Notifies when item gets added to a particular index
+type IndexAddedSubscriber<T> = (val: T[keyof T]) => void;
+
+export class IndexedMap<T extends object, K extends keyof T>
+  implements Iterable<T>
+{
+  private head: Maybe<LinkNode<T, K>>;
+  private tail: Maybe<LinkNode<T, K>>;
+  private mapSize = 0;
+  private pk: K;
+  private map = new Map<T[K], LinkNode<T, K>>();
+  private indexes: Map<keyof T, Map<T[keyof T], Set<LinkNode<T, K>>>> =
+    new Map();
+  private indexAddedSubscribers: Map<keyof T, Set<IndexAddedSubscriber<T>>> =
+    new Map();
+
+  constructor(pk: K, indexFields: Array<keyof T> = []) {
+    this.pk = pk;
+    for (const field of indexFields) {
+      if (field === pk) continue;
+      this.indexes.set(field, new Map());
+    }
+  }
+
+  // Puts item to the end
+  // Removes previous item, if PK is matched
+  put(item: T): void {
+    const key = item[this.pk];
+    // Delete previous, if any
+    this.delete(key);
+
+    const node: LinkNode<T, K> = {
+      value: item,
+      cachedIndexValues: new Map(),
+      prev: this.tail,
+      next: null,
+    };
+    if (!this.head) {
+      this.head = node;
+    }
+    if (this.tail) {
+      this.tail.next = node;
+    }
+    this.tail = node;
+    this.map.set(key, node);
+    this.mapSize++;
+
+    // update secondary indexes
+    this.indexNewNode(node);
+  }
+
+  putBefore(targetKey: T[K], item: T): void {
+    const target = this.map.get(targetKey);
+    if (target == null) {
+      throw new Error(`Key not found: ${String(targetKey)}`);
+    }
+    const key = item[this.pk];
+    if (targetKey === key) {
+      return;
+    }
+    this.delete(key);
+
+    const node: LinkNode<T, K> = {
+      value: item,
+      cachedIndexValues: new Map(),
+      prev: target.prev,
+      next: target,
+    };
+    if (target.prev) {
+      target.prev.next = node;
+    } else {
+      this.head = node;
+    }
+    target.prev = node;
+
+    this.map.set(key, node);
+    this.mapSize++;
+    this.indexNewNode(node);
+  }
+
+  // TODO: need to make it in background, instead of making eng to call it manually
+  updateIndex(item: T) {
+    const node = this.map.get(item[this.pk]);
+    if (node == null) {
+      return;
+    }
+    for (const [field, map] of this.indexes) {
+      const newVal = node.value[field];
+      const oldVal = node.cachedIndexValues.get(field);
+      if (oldVal !== newVal) {
+        const oldSet = this.indexes
+          .get(field)
+          // We know for sure, it's okay to index on that value
+          ?.get(oldVal as T[keyof T]);
+
+        oldSet?.delete(node);
+        let set = this.indexes.get(field)?.get(newVal);
+        if (!set) {
+          set = new Set();
+          map.set(newVal, set);
+        }
+        set.add(node);
+        node.cachedIndexValues.set(field, newVal);
+        this.notifySubscribers(field, newVal);
+      }
+    }
+  }
+
+  private indexNewNode(node: LinkNode<T, K>) {
+    for (const [field, map] of this.indexes) {
+      const val = node.value[field];
+      node.cachedIndexValues.set(field, val);
+      let set = map.get(val);
+      if (!set) {
+        set = new Set();
+        map.set(val, set);
+      }
+      set.add(node);
+      this.notifySubscribers(field, val);
+    }
+  }
+
+  private notifySubscribers(field: keyof T, val: T[keyof T] | undefined) {
+    if (val === undefined) {
+      return;
+    }
+    const listeners = this.indexAddedSubscribers.get(field);
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(val);
+    }
+  }
+
+  subscribeToIndexChange(
+    field: keyof T,
+    listener: IndexAddedSubscriber<T>,
+  ): () => void {
+    if (!this.indexes.has(field)) {
+      throw new Error(
+        `Cannot subscribe to non-indexed field "${String(field)}"`,
+      );
+    }
+    let listeners = this.indexAddedSubscribers.get(field);
+    if (!listeners) {
+      listeners = new Set();
+      this.indexAddedSubscribers.set(field, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+
+  putAfter(targetKey: T[K], item: T): void {
+    const target = this.map.get(targetKey);
+    if (target == null) {
+      throw new Error(`Key not found: ${String(targetKey)}`);
+    }
+    const key = item[this.pk];
+    if (targetKey === key) {
+      return;
+    }
+
+    const node: LinkNode<T, K> = {
+      value: item,
+      cachedIndexValues: new Map(),
+      prev: target,
+      next: target.next,
+    };
+    if (target.next) {
+      target.next.prev = node;
+    } else {
+      this.tail = node;
+    }
+    target.next = node;
+
+    this.map.set(key, node);
+    this.mapSize++;
+    this.indexNewNode(node);
+  }
+
+  delete(key: T[K]): boolean {
+    const node = this.map.get(key);
+    if (node == null) {
+      return false;
+    }
+
+    // unlink from list
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+
+    // remove from indexes
+    this.map.delete(key);
+    for (const [field, map] of this.indexes) {
+      const indexValue = node.value[field];
+      const set = map.get(indexValue);
+      if (set != null) {
+        set.delete(node);
+      }
+    }
+
+    this.mapSize--;
+    return true;
+  }
+
+  at(n: number): Maybe<T> {
+    let current: Maybe<LinkNode<T, K>>;
+    if (n >= 0) {
+      current = this.head;
+      for (let i = 0; i < n && current != null; i++) {
+        current = current.next;
+      }
+    } else {
+      current = this.tail;
+      for (let i = n; i < -1 && current != null; i++) {
+        current = current.prev;
+      }
+    }
+    return current?.value;
+  }
+
+  get(key: T[K]): Maybe<T> {
+    return this.map.get(key)?.value;
+  }
+
+  getByIndex<K extends keyof T>(field: K, val: T[keyof T]): Array<T> {
+    const map = this.indexes.get(field);
+    if (!map) {
+      throw new Error(`No index defined for field "${String(field)}"`);
+    }
+    const set = map.get(val);
+    return set ? Array.from(set.values(), (node) => node.value) : [];
+  }
+
+  // Get next item in insertion order
+  getNext(item: T): Maybe<T> {
+    return this.map.get(item[this.pk])?.next?.value;
+  }
+
+  // Get previous item in insertion order
+  getPrev(item: T): Maybe<T> {
+    return this.map.get(item[this.pk])?.prev?.value;
+  }
+
+  size(): number {
+    return this.mapSize;
+  }
+
+  [Symbol.iterator](): Iterator<T> {
+    let curr = this.head;
+    return {
+      next(): IteratorResult<T> {
+        if (!curr) {
+          return { done: true, value: undefined! };
+        }
+        const value = curr.value;
+        curr = curr.next;
+        return { done: false, value };
+      },
+    };
+  }
+}

package/src/data-structures/linked-map/LinkedMap.spec.ts

@@ -0,0 +1,67 @@
+import { expect, test } from "bun:test";
+import { LinkedMap } from "./LinkedMap";
+
+type Entry = { key: string; value: number };
+
+test("put adds items to the end", () => {
+  const map = new LinkedMap<Entry, "key">("key");
+  map.put({ key: "foo", value: 1 });
+  map.put({ key: "bar", value: 2 });
+  map.put({ key: "baz", value: 94 });
+
+  expect([...map].map((e) => [e.key, e.value])).toEqual([
+    ["foo", 1],
+    ["bar", 2],
+    ["baz", 94],
+  ]);
+});
+
+test("putBefore and putAfter work correctly", () => {
+  const map = new LinkedMap<Entry, "key">("key");
+  map.put({ key: "foo", value: 1 });
+  map.put({ key: "bar", value: 2 });
+  map.put({ key: "baz", value: 94 });
+
+  map.putBefore("bar", { key: "hey", value: 13 }); // insert before "bar"
+
+  expect([...map].map((e) => [e.key, e.value])).toEqual([
+    ["foo", 1],
+    ["hey", 13],
+    ["bar", 2],
+    ["baz", 94],
+  ]);
+
+  map.putAfter("baz", { key: "zap", value: 42 }); // insert after "baz"
+
+  expect([...map].map((e) => [e.key, e.value])).toEqual([
+    ["foo", 1],
+    ["hey", 13],
+    ["bar", 2],
+    ["baz", 94],
+    ["zap", 42],
+  ]);
+});
+
+test("map has access by key", () => {
+  const map = new LinkedMap<Entry, "key">("key");
+  map.put({ key: "foo", value: 1 });
+  map.put({ key: "bar", value: 2 });
+  map.put({ key: "hey", value: 13 });
+  map.put({ key: "baz", value: 94 });
+
+  expect(map.get("baz")?.value).toEqual(94);
+  expect(map.get("bar")?.value).toEqual(2);
+  expect(map.get("hey")?.value).toEqual(13);
+});
+
+test("map has access by index", () => {
+  const map = new LinkedMap<Entry, "key">("key");
+  map.put({ key: "foo", value: 1 });
+  map.put({ key: "bar", value: 2 });
+  map.put({ key: "hey", value: 13 });
+  map.put({ key: "baz", value: 94 });
+
+  expect(map.at(-1)?.value).toEqual(94);
+  expect(map.at(2)?.value).toEqual(13);
+  expect(map.at(0)?.value).toEqual(1);
+});

package/src/data-structures/linked-map/LinkedMap.ts

@@ -0,0 +1,198 @@
+import { Maybe } from "../maybe/Maybe";
+
+type LinkNode<T, K> = {
+  value: T;
+  cachedIndexValues: Map<keyof T, T[keyof T]>;
+  prev: Maybe<LinkNode<T, K>>;
+  next: Maybe<LinkNode<T, K>>;
+};
+
+export class LinkedMap<T extends object, K extends keyof T>
+  implements Iterable<T>
+{
+  private head: Maybe<LinkNode<T, K>>;
+  private tail: Maybe<LinkNode<T, K>>;
+  private mapSize = 0;
+  private pk: K;
+  private map = new Map<T[K], LinkNode<T, K>>();
+
+  constructor(pk: K) {
+    this.pk = pk;
+  }
+
+  putFirst(item: T): void {
+    const key = item[this.pk];
+    // Delete previous, if any
+    this.delete(key);
+
+    const node: LinkNode<T, K> = {
+      value: item,
+      cachedIndexValues: new Map(),
+      prev: this.tail,
+      next: null,
+    };
+    if (!this.tail) {
+      this.tail = node;
+    }
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    this.map.set(key, node);
+    this.mapSize++;
+  }
+  // Puts item to the end
+  // Removes previous item, if PK is matched
+  put(item: T): void {
+    const key = item[this.pk];
+    // Delete previous, if any
+    this.delete(key);
+
+    const node: LinkNode<T, K> = {
+      value: item,
+      cachedIndexValues: new Map(),
+      prev: this.tail,
+      next: null,
+    };
+    if (!this.head) {
+      this.head = node;
+    }
+    if (this.tail) {
+      this.tail.next = node;
+    }
+    this.tail = node;
+    this.map.set(key, node);
+    this.mapSize++;
+  }
+
+  putBefore(targetKey: T[K], item: T): void {
+    const target = this.map.get(targetKey);
+    if (target == null) {
+      throw new Error(`Key not found: ${String(targetKey)}`);
+    }
+    const key = item[this.pk];
+    if (targetKey === key) {
+      return;
+    }
+    this.delete(key);
+
+    const node: LinkNode<T, K> = {
+      value: item,
+      cachedIndexValues: new Map(),
+      prev: target.prev,
+      next: target,
+    };
+    if (target.prev) {
+      target.prev.next = node;
+    } else {
+      this.head = node;
+    }
+    target.prev = node;
+
+    this.map.set(key, node);
+    this.mapSize++;
+  }
+
+  putAfter(targetKey: T[K], item: T): void {
+    const target = this.map.get(targetKey);
+    if (target == null) {
+      throw new Error(`Key not found: ${String(targetKey)}`);
+    }
+    const key = item[this.pk];
+    if (targetKey === key) {
+      return;
+    }
+
+    const node: LinkNode<T, K> = {
+      value: item,
+      cachedIndexValues: new Map(),
+      prev: target,
+      next: target.next,
+    };
+    if (target.next) {
+      target.next.prev = node;
+    } else {
+      this.tail = node;
+    }
+    target.next = node;
+
+    this.map.set(key, node);
+    this.mapSize++;
+  }
+
+  delete(key: T[K]): boolean {
+    const node = this.map.get(key);
+    if (node == null) {
+      return false;
+    }
+
+    // unlink from list
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+
+    // remove from indexes
+    this.map.delete(key);
+    this.mapSize--;
+    return true;
+  }
+
+  at(n: number): Maybe<T> {
+    let current: Maybe<LinkNode<T, K>>;
+    if (n >= 0) {
+      current = this.head;
+      for (let i = 0; i < n && current != null; i++) {
+        current = current.next;
+      }
+    } else {
+      current = this.tail;
+      for (let i = n; i < -1 && current != null; i++) {
+        current = current.prev;
+      }
+    }
+    return current?.value;
+  }
+
+  get(key: T[K]): Maybe<T> {
+    return this.map.get(key)?.value;
+  }
+
+  has(item: T): boolean {
+    return this.map.get(item[this.pk])?.value === item;
+  }
+
+  // Get next item in insertion order
+  getNext(item: T): Maybe<T> {
+    return this.map.get(item[this.pk])?.next?.value;
+  }
+
+  // Get previous item in insertion order
+  getPrev(item: T): Maybe<T> {
+    return this.map.get(item[this.pk])?.prev?.value;
+  }
+
+  size(): number {
+    return this.mapSize;
+  }
+
+  [Symbol.iterator](): Iterator<T> {
+    let curr = this.head;
+    return {
+      next(): IteratorResult<T> {
+        if (!curr) {
+          return { done: true, value: undefined! };
+        }
+        const value = curr.value;
+        curr = curr.next;
+        return { done: false, value };
+      },
+    };
+  }
+}