creo 0.0.2 → 0.0.4-dev

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/data-structures/record/IsRecordLike.spec.ts

@@ -0,0 +1,29 @@
+import { expect, test } from "bun:test";
+import { isRecordLike } from "./IsRecordLike";
+
+test("Handles objects", () => {
+  expect(isRecordLike({})).toBe(true);
+  expect(isRecordLike({ foo: "bar" })).toBe(true);
+  expect(isRecordLike(new String())).toBe(true);
+});
+
+test("Handles arrays", () => {
+  expect(isRecordLike([])).toBe(true);
+});
+
+test("Fails nulls", () => {
+  expect(isRecordLike(null)).toBe(false);
+  expect(isRecordLike(undefined)).toBe(false);
+  expect(isRecordLike(NaN)).toBe(false);
+  expect(isRecordLike(0)).toBe(false);
+  expect(isRecordLike(false)).toBe(false);
+  expect(isRecordLike("")).toBe(false);
+});
+
+test("Fails primitives", () => {
+  expect(isRecordLike(1)).toBe(false);
+  expect(isRecordLike("foo")).toBe(false);
+  // @ts-ignore
+  expect(isRecordLike()).toBe(false);
+  expect(isRecordLike(Symbol.for("test"))).toBe(false);
+});

package/src/data-structures/record/IsRecordLike.ts

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

package/src/data-structures/record/Record.spec.ts

@@ -0,0 +1,240 @@
+import { expect, test, mock } from "bun:test";
+import { record, RecordOf, onDidUpdate, isRecord } from "./Record";
+
+test("Can define objects", () => {
+  const obj = record({
+    hello: "world",
+  });
+
+  // @ts-ignore
+  expect(obj).toEqual({ hello: "world" });
+});
+
+test("Refers to the same objects", () => {
+  const test = record({
+    foo: {
+      bar: "baz",
+    },
+  });
+
+  expect(test.foo).toBe(test.foo);
+});
+
+test("Updates fields correctly", () => {
+  const test: RecordOf<any> = record({
+    foo: {
+      bar: "baz",
+    },
+  });
+
+  expect(test.foo.bar).toBe("baz");
+
+  test.foo.bar = "123";
+
+  expect(test.foo.bar).toBe("123");
+
+  test.foo = { hello: "world" };
+  expect(test.foo.bar).toBe(undefined);
+  expect(test.foo.hello).toBe("world");
+});
+
+test("Notifies on object updates", async () => {
+  const obj = record({
+    hello: "world",
+  });
+
+  await expect(
+    new Promise((resolve) => {
+      onDidUpdate(obj, (updated) => resolve(updated));
+
+      obj.hello = "new world";
+    }),
+  ).resolves.toEqual({
+    hello: "new world",
+  });
+});
+
+test("Notifies on object updates even if the listener was set after the change", async () => {
+  const obj = record({
+    hello: "world",
+  });
+
+  obj.hello = "new world";
+
+  await expect(
+    new Promise((resolve) => {
+      onDidUpdate(obj, (updated) => resolve(updated));
+    }),
+  ).resolves.toEqual({
+    hello: "new world",
+  });
+});
+
+test("Implies updates immediately", async () => {
+  const obj = record({
+    hello: {
+      world: "foo",
+    },
+  });
+
+  // @ts-ignore
+  expect(obj).toEqual({
+    hello: {
+      world: "foo",
+    },
+  });
+
+  obj.hello.world = "new";
+
+  // @ts-ignore
+  expect(obj).toEqual({
+    hello: {
+      world: "new",
+    },
+  });
+});
+
+test("Handles nested object updates", async () => {
+  const obj = record({
+    hello: {
+      world: "foo",
+    },
+  });
+
+  obj.hello.world = "new";
+
+  await expect(
+    new Promise((resolve) => {
+      onDidUpdate(obj, (updated) => resolve(updated));
+    }),
+  ).resolves.toEqual({
+    hello: {
+      world: "new",
+    },
+  });
+});
+
+test("Can unsubscribe from updates", async () => {
+  const obj = record({
+    hello: {
+      world: "foo",
+    },
+  });
+
+  const unsubscribe = onDidUpdate(obj, (_updated) => {
+    throw Error("cannot get here");
+  });
+  // If you delete this line, the test gets broken:
+  unsubscribe();
+
+  obj.hello.world = "new";
+
+  await expect(
+    new Promise((resolve) => {
+      onDidUpdate(obj, (updated) => resolve(updated));
+    }),
+  ).resolves.toEqual({
+    hello: {
+      world: "new",
+    },
+  });
+});
+
+test("Supports arrays", async () => {
+  const obj = record({
+    hello: {
+      world: ["this", "is", "array"],
+    },
+  });
+
+  obj.hello.world.sort();
+
+  await expect(
+    new Promise((resolve) => {
+      onDidUpdate(obj, (updated) => resolve(JSON.stringify(updated)));
+    }),
+  ).resolves.toEqual('{"hello":{"world":["array","is","this"]}}');
+
+  obj.hello.world.push("123");
+
+  await expect(
+    new Promise((resolve) => {
+      onDidUpdate(obj, (updated) => resolve(JSON.stringify(updated)));
+    }),
+  ).resolves.toEqual('{"hello":{"world":["array","is","this","123"]}}');
+});
+
+test("Supports iterable", async () => {
+  const obj = record(["hello", "world"]);
+
+  function iterate(...args: string[]) {
+    const [a, b] = args;
+    expect(a).toBe("hello");
+    expect(b).toBe("world");
+  }
+
+  iterate(...obj);
+});
+
+test("`has` works with records", async () => {
+  const originalObject = {
+    foo: "bar",
+    baz: "test",
+    nested: {
+      support: "exist",
+    },
+  };
+  const wrapped = record(originalObject);
+
+  expect(isRecord(originalObject)).toBe(false);
+  expect(isRecord(wrapped)).toBe(true);
+  expect("foo" in wrapped).toBe(true);
+  expect("test" in wrapped).toBe(false);
+  expect("support" in wrapped.nested).toBe(true);
+  expect("foo" in wrapped.nested).toBe(false);
+});
+
+test("Double tracked on nested object works correctly", async () => {
+  const originalObject = {
+    foo: "bar",
+    baz: "test",
+    nested: {
+      support: "exist",
+    },
+  };
+
+  // This object is not tracked under the same parent, but might be considered in future to allow better objects and record composition.
+  // It would require objects to have multiple parents (so essentially many<=>many concept.)
+  const additionalObject = {
+    nested: originalObject.nested,
+    foo: "123",
+    hello: "234",
+  };
+
+  const originalWrappped = record(originalObject);
+
+  const additionalWrapped = record(additionalObject);
+
+  const recordedNested = record(originalWrappped.nested);
+
+  const mockFn = mock();
+
+  onDidUpdate(originalWrappped, () => {
+    mockFn();
+    expect(originalObject.nested).toEqual(originalWrappped.nested);
+  });
+  onDidUpdate(additionalWrapped, () => {
+    // We should never hit that path
+    expect(1).toBe(0);
+    mockFn();
+  });
+  onDidUpdate(recordedNested, () => {
+    mockFn();
+    // @ts-ignore
+    expect(recordedNested).toEqual({ support: "updated" });
+  });
+  originalWrappped.nested.support = "updated";
+  // Updates are propagated in microtick queue, so we wait single tick
+  await Promise.resolve();
+  expect(mockFn).toHaveBeenCalledTimes(2);
+});