creo 0.0.3-dev → 0.0.4-dev

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 };
+      },
+    };
+  }
+}

package/src/data-structures/list/List.spec.ts

@@ -0,0 +1,181 @@
+import { expect, test } from "bun:test";
+import { List, ListNode } from "./List";
+import { assertJust } from "../assert/assert";
+
+test("addToEnd adds items to the end", () => {
+  const listInstance = List();
+  listInstance.addToEnd('1');
+  listInstance.addToEnd('2');
+  listInstance.addToEnd('3');
+  listInstance.addToEnd('4');
+  listInstance.addToEnd('5');
+  listInstance.addToEnd('6');
+
+  expect(listInstance.at(0)?.value).toBe('1');
+  expect(listInstance.at(1)?.value).toBe('2');
+  expect(listInstance.at(3)?.value).toBe('4');
+  expect(listInstance.at(5)?.value).toBe('6');
+});
+
+test("at works with negative values", () => {
+  const l = List();
+  l.addToEnd('1');
+  l.addToEnd('2');
+  l.addToEnd('3');
+  l.addToEnd('4');
+  l.addToEnd('5');
+  l.addToEnd('6');
+
+  expect(l.at(-1)?.value).toBe('6');
+  expect(l.at(-5)?.value).toBe('2');
+});
+
+test("if at exceeds the length, null to be returned", () => {
+  const listInstance = List();
+  listInstance.addToEnd('1');
+  listInstance.addToEnd('2');
+  listInstance.addToEnd('3');
+  listInstance.addToEnd('4');
+  listInstance.addToEnd('5');
+  listInstance.addToEnd('6');
+
+  expect(listInstance.at(-10)).toBe(null);
+  expect(listInstance.at(10)).toBe(null);
+});
+
+test("Add to start", () => {
+  const listInstance = List();
+  listInstance.addToStart('1');
+  listInstance.addToStart('2');
+  listInstance.addToStart('3');
+  listInstance.addToStart('4');
+  listInstance.addToStart('5');
+  listInstance.addToStart('6');
+
+  expect(listInstance.at(0)?.value).toBe('6');
+  expect(listInstance.at(1)?.value).toBe('5');
+  expect(listInstance.at(2)?.value).toBe('4');
+  expect(listInstance.at(-3)?.value).toBe('3');
+  expect(listInstance.at(-2)?.value).toBe('2');
+  expect(listInstance.at(-1)?.value).toBe('1');
+});
+
+test("from is a static method which builds a list from an array", () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  expect(listInstance.at(-1)?.value).toBe('6');
+  expect(listInstance.at(-2)?.value).toBe('5');
+  expect(listInstance.at(-3)?.value).toBe('4');
+  expect(listInstance.at(2)?.value).toBe('3');
+  expect(listInstance.at(1)?.value).toBe('2');
+  expect(listInstance.at(0)?.value).toBe('1');
+});
+
+test("Iterable", () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  let resultString = ''
+  for (const item of listInstance) {
+    resultString += item;
+  }
+
+  expect(resultString).toBe('123456');
+});
+
+test("Mutating ListNode directly keeps List in correct state", () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  const listNode: ListNode<string> = listInstance.at(2)!;
+
+  expect(listNode.value).toBe('3');
+
+  listNode.prev = '10';
+
+  expect(listInstance.at(2)?.value).toBe('10');
+  expect(listInstance.at(3)?.value).toBe('3');
+});
+
+test("Mutating ListNode.prev directly keeps List in correct state", () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  const listNode: ListNode<string> = listInstance.at(2)!;
+
+  expect(listNode.value).toBe('3');
+
+  listNode.prev = '10';
+
+  expect(Array.from(listInstance).join('')).toBe('12103456');
+});
+
+test("Mutating ListNode.next directly keeps List in correct state", () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  const listNode: ListNode<string> = listInstance.at(2)!;
+
+  expect(listNode.value).toBe('3');
+
+  listNode.next = '10';
+
+  expect(Array.from(listInstance).join('')).toBe('12310456');
+  expect(listInstance.at(-3)?.value).toBe('4');
+  expect(listInstance.at(-4)?.value).toBe('10');
+  expect(listInstance.at(-5)?.value).toBe('3');
+});
+
+test("Mutating the first item using ListNode directly keeps List in correct state", () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  listInstance.at(0)!.prev = 'test'
+
+  expect(Array.from(listInstance).join('')).toBe('test123456');
+});
+
+test("Mutating the last item using ListNode directly keeps List in correct state", () => {
+  const listInstance: List<string> = List.from(['1','2','3','4','5','6']);  
+
+  listInstance.at(-1)!.next = 'test'
+
+  expect(Array.from(listInstance).join('')).toBe('123456test');
+  expect(listInstance.at(-1)?.value).toBe('test');
+  expect(listInstance.at(-2)?.value).toBe('6');
+});
+
+test('Mutating item in a middle keeps the list correct', () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  listInstance.at(-4)!.next = 'test'
+
+  expect(Array.from(listInstance).join('')).toBe('123test456');
+  expect(listInstance.at(-2)?.value).toBe('5');
+  expect(listInstance.at(-4)?.value).toBe('test');
+  expect(listInstance.at(-5)?.value).toBe('3');
+  expect(listInstance.at(5)?.value).toBe('5');
+})
+
+test('First item deletion works correctly', () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  listInstance.at(0)!.delete();
+
+  expect(Array.from(listInstance).join('')).toBe('23456');
+  expect(listInstance.at(0)?.value).toBe('2');
+  expect(listInstance.at(1)?.value).toBe('3');
+
+})
+
+test('addTo returns node', () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+
+  expect(listInstance.addToEnd('test')).toBe(listInstance.at(-1));
+  expect(listInstance.addToStart('test2')).toBe(listInstance.at(0));
+})
+
+test('Adding item in the middle of the list', () => {
+  const listInstance = List.from(['1','2','3','4','5','6']);  
+  const node = listInstance.at(2);
+  assertJust(node);
+  expect(node.value).toBe('3');
+  node.next = '123';
+
+  expect([...listInstance]).toEqual(['1','2','3', '123','4','5','6'])
+})

package/src/data-structures/list/List.ts

@@ -0,0 +1,195 @@
+/**
+ * Linked list impl
+ * 
+ * ideas:
+ * [-] Shall we use Record for list as well? 
+ * [x] Support iterator
+ * [-] Make prev and next to receive ListNode
+ * [ ] Size support
+ */
+
+import { Maybe } from "../maybe/Maybe";
+
+// #region List's Node
+export class ListNode<T> {
+  #list: Maybe<WeakRef<ListClass<T>>>;
+  #next: Maybe<ListNode<T>>;
+  #prev: Maybe<ListNode<T>>;
+  public node: T;  
+
+  constructor(node: T, prev: Maybe<ListNode<T>> = null, next: Maybe<ListNode<T>> = null, list: Maybe<WeakRef<ListClass<T>>>) {
+    this.#prev = prev;
+    this.#next = next;
+    this.node = node;
+    this.#list = list;
+  }
+
+  // #region Delete Node from LinkedList
+  delete() {
+    const maybeParent = this.#list?.deref();
+    if (this.#prev != null) {
+      this.#prev.#next = this.#next;
+    } else {
+      maybeParent?.updateHead_UNSAFE(this.#next);
+    }
+    if (this.#next != null) {
+      this.#next.#prev = this.#prev;
+    } else {
+      maybeParent?.updateTail_UNSAFE(this.#prev);
+    }
+    this.#next = null;
+    this.#prev = null;
+  }
+
+  // #region Getters/setters
+  set next(value: T) {
+    const oldNext = this.#next;
+    this.#next = new ListNode(value, this, this.#next, this.#list);    
+  
+    if (oldNext == null) {
+      const maybeParent = this.#list?.deref();
+      if (!maybeParent) {
+        return;
+      }
+      maybeParent.updateTail_UNSAFE(this.#next);
+    } else {
+      oldNext.#prev = this.#next;
+    }
+  }
+
+  set prev(value: T) {
+    const oldPrev = this.#prev;
+    this.#prev = new ListNode(value, this.#prev, this, this.#list);      
+  
+    if (oldPrev == null) {
+      const maybeParent = this.#list?.deref();
+      if (!maybeParent) {
+        return;
+      }
+      maybeParent.updateHead_UNSAFE(this.#prev);
+    } else {
+      oldPrev.#next = this.#prev;
+    }
+  }
+  
+  get value(): T {
+    return this.node;
+  }
+
+  get next(): Maybe<ListNode<T>> {
+    return this.#next;
+  }
+
+  get prev(): Maybe<ListNode<T>> {
+    return this.#prev;
+  }
+
+  // #region Getter of List
+  get list() {
+    return this.#list?.deref();
+  }
+}
+
+// #region IList public interface
+export interface List<T> extends Iterable<T> {
+  addToStart(value: T): ListNode<T>;
+  delete(n: number): boolean;
+  at(n: number): Maybe<ListNode<T>>;
+  addToEnd(value: T): ListNode<T>;
+  [Symbol.iterator](): IterableIterator<T>;
+}
+
+
+// #region List class
+class ListClass<T> implements List<T>{
+  #head: Maybe<ListNode<T>>;
+  #tail: Maybe<ListNode<T>>;
+
+  // #region internal methods
+  updateHead_UNSAFE(maybeNewHead: Maybe<ListNode<T>>) {
+    this.#head = maybeNewHead;
+  }
+
+  updateTail_UNSAFE(maybeNewTail: Maybe<ListNode<T>>) {
+    this.#tail = maybeNewTail;
+  }
+
+  // #region Public methods
+  addToStart(value: T) {
+    if (this.#head != null) {
+      this.#head.prev = value;      
+    } else {
+      const node = new ListNode(value, null, null, new WeakRef(this));
+      this.#head = node;
+      this.#tail = node;
+    }
+    return this.#head
+  }
+
+  delete(n: number): boolean {
+    const node = this.at(n);    
+    if (node == null) {
+      // Cannot delete non-existed item
+      return false;
+    }
+
+    // Corner case: delete the first item
+    if (node === this.#head) {
+      this.#head = this.at(1);
+    }
+    if (node === this.#tail) {
+      this.#tail = this.at(-2);
+    }
+    node.delete();
+    return true;
+  }
+
+  at(n: number): Maybe<ListNode<T>> {
+    let current: Maybe<ListNode<T>>;
+    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;    
+  }
+
+  addToEnd(value: T) {
+    if (this.#tail != null) {
+      this.#tail.next = value;      
+    } else {
+      const node = new ListNode(value, null, null, new WeakRef(this));
+      this.#head = node;
+      this.#tail = node;
+    }
+    return this.#tail;
+  }
+
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+
+  static from<T>(arrayLike: Iterable<T>): List<T> {
+    const list = new ListClass<T>;
+    for (const item of arrayLike) {
+      list.addToEnd(item);
+    }
+    return list;
+  }
+}
+// #region Exports
+export function List<T>(): List<T> {
+  return new ListClass<T>();
+}
+
+List.from = ListClass.from;

package/src/data-structures/maybe/Maybe.ts

@@ -0,0 +1,25 @@
+export type None = null | undefined;
+export type Just<T> = T;
+export type Maybe<T> = Just<T> | None;
+
+export function isJust<T>(v: Maybe<T>): v is Just<T> {
+  return v != null;
+}
+
+export function isNone<T>(v: Maybe<T>): v is None {
+  return v == null;
+}
+
+export function unwrap<T>(v: Maybe<T>): Just<T> {
+  if (isJust(v)) {
+    return v;
+  }
+  throw new TypeError("Optional is none");
+}
+
+export function orDefault<T, K>(v: Maybe<T>, alternative: K) {
+  if (isJust(v)) {
+    return v;
+  }
+  return alternative;
+}

package/src/data-structures/null/null.ts

@@ -0,0 +1,3 @@
+export const _ = undefined;
+
+export function emptyFn() {}

package/src/{tools/isRecordLike.spec.ts → data-structures/record/IsRecordLike.spec.ts}

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test";
-import { isRecordLike } from "./isRecordLike";
+import { isRecordLike } from "./IsRecordLike";
 
 test("Handles objects", () => {
   expect(isRecordLike({})).toBe(true);

package/src/{tools/isRecordLike.ts → data-structures/record/IsRecordLike.ts}

@@ -1,3 +1,3 @@
 export function isRecordLike<T, K extends object>(value: T | K): value is K {
   return (typeof value === "object" || Array.isArray(value)) && value != null;
-}
+}