@adviser/cement 0.2.27 → 0.2.29

package/src/option.ts

@@ -0,0 +1,60 @@
+export abstract class Option<T> {
+  static Some<T>(t: T): Option<T> {
+    return new Some(t);
+  }
+
+  static None<T>(): Option<T> {
+    return new None();
+  }
+
+  static Is<T>(t: unknown): t is Option<T> {
+    return t instanceof Option;
+  }
+
+  IsNone(): boolean {
+    return this.is_none();
+  }
+
+  IsSome(): boolean {
+    return this.is_some();
+  }
+  Unwrap(): T {
+    return this.unwrap();
+  }
+
+  abstract is_none(): boolean;
+  abstract is_some(): boolean;
+  abstract unwrap(): T;
+}
+
+export class Some<T> extends Option<T> {
+  private _t: T;
+  constructor(_t: T) {
+    super();
+    this._t = _t;
+  }
+
+  is_none(): boolean {
+    return false;
+  }
+  is_some(): boolean {
+    return true;
+  }
+  unwrap(): T {
+    return this._t;
+  }
+}
+
+export class None<T> extends Option<T> {
+  is_none(): boolean {
+    return true;
+  }
+  is_some(): boolean {
+    return false;
+  }
+  unwrap(): T {
+    throw new Error("None.unwrap");
+  }
+}
+
+export type WithoutOption<T> = T extends Option<infer U> ? U : T;

package/src/resolve-once.test.ts

@@ -0,0 +1,321 @@
+import { KeyedResolvOnce, ResolveOnce, ResolveSeq } from "@adviser/cement";
+
+describe("resolve-once", () => {
+  it("sequence", async () => {
+    const once = new ResolveOnce<number>();
+
+    const reallyOnce = vi.fn(async () => {
+      return new Promise<number>((resolve) => {
+        setTimeout(() => {
+          resolve(42);
+        }, 100);
+      });
+    });
+    const start = Date.now();
+    const fn = (): Promise<number> => once.once(async () => reallyOnce());
+    expect(reallyOnce).toHaveBeenCalledTimes(0);
+    expect(await fn()).toBe(42);
+    expect(reallyOnce).toHaveBeenCalledTimes(1);
+    expect(await fn()).toBe(42);
+    expect(reallyOnce).toHaveBeenCalledTimes(1);
+    expect(await fn()).toBe(42);
+    expect(reallyOnce).toHaveBeenCalledTimes(1);
+    const diff = Date.now() - start;
+    expect(diff).toBeGreaterThanOrEqual(99);
+    expect(diff).toBeLessThan(150);
+  });
+  it("parallel", async () => {
+    const once = new ResolveOnce<number>();
+    const reallyOnce = vi.fn(async () => {
+      return new Promise<number>((resolve) => {
+        setTimeout(() => {
+          resolve(42);
+        }, 100);
+      });
+    });
+    const fn = (): Promise<number> => once.once(async () => reallyOnce());
+    const start = Date.now();
+    expect(
+      await Promise.all(
+        Array(100)
+          .fill(fn)
+          .map((fn) => fn()),
+      ),
+    ).toEqual(Array(100).fill(42));
+    expect(reallyOnce).toHaveBeenCalledTimes(1);
+    const diff = Date.now() - start;
+    expect(diff).toBeGreaterThanOrEqual(99);
+    expect(diff).toBeLessThan(150);
+  });
+
+  it("works with void", async () => {
+    const once = new ResolveOnce<void>();
+    const reallyOnce = vi.fn(async () => {
+      return new Promise<void>((resolve) => {
+        setTimeout(() => {
+          resolve();
+        }, 100);
+      });
+    });
+    const fn = (): Promise<void> => once.once(async () => reallyOnce());
+    const start = Date.now();
+    expect(
+      await Promise.all(
+        Array(100)
+          .fill(fn)
+          .map((fn) => fn()),
+      ),
+    ).toEqual(Array(100).fill(undefined));
+    expect(reallyOnce).toHaveBeenCalledTimes(1);
+    const diff = Date.now() - start;
+    expect(diff).toBeGreaterThanOrEqual(99);
+    expect(diff).toBeLessThan(150);
+  });
+
+  it("throws", async () => {
+    const once = new ResolveOnce<number>();
+    const reallyOnce = vi.fn(async () => {
+      return new Promise<number>((rs, rj) => {
+        setTimeout(() => {
+          rj(new Error("nope"));
+        }, 100);
+      });
+    });
+    const fn = (): Promise<number> => once.once(async () => reallyOnce());
+    const start = Date.now();
+    await new Promise((rs) => {
+      for (let i = 0; i < 100; i++) {
+        fn()
+          .then(() => {
+            assert.fail("should not happen");
+          })
+          .catch((e) => {
+            expect(e).toEqual(new Error("nope"));
+            expect(reallyOnce).toHaveBeenCalledTimes(1);
+            if (i === 99) {
+              rs(undefined);
+            }
+          });
+      }
+    });
+    const diff = Date.now() - start;
+    expect(diff).toBeGreaterThanOrEqual(99);
+    expect(diff).toBeLessThan(150);
+  });
+
+  it("preserves order", async () => {
+    const once = new ResolveOnce<number>();
+    const reallyOnce = vi.fn(async () => {
+      return new Promise<number>((resolve) => {
+        setTimeout(() => {
+          resolve(42);
+        }, 100);
+      });
+    });
+    let order = 0;
+    const fn = async (): Promise<string> => {
+      const o = order++;
+      const ret = await once.once(async () => reallyOnce());
+      return `${o}:${ret}`;
+    };
+    const start = Date.now();
+    expect(
+      await Promise.all(
+        Array(100)
+          .fill(fn)
+          .map((fn) => fn()),
+      ),
+    ).toEqual(
+      Array(100)
+        .fill(undefined)
+        .map((_, i) => `${i}:42`),
+    );
+    expect(reallyOnce).toHaveBeenCalledTimes(1);
+    const diff = Date.now() - start;
+    expect(diff).toBeGreaterThanOrEqual(99);
+    expect(diff).toBeLessThan(150);
+  });
+
+  it("preserves call order to resolv order", async () => {
+    const once = new ResolveOnce<number>();
+    const reallyOnce = vi.fn(async () => {
+      return new Promise<number>((resolve) => {
+        setTimeout(() => {
+          resolve(42);
+        }, 100);
+      });
+    });
+    const start = Date.now();
+    const orderFn = vi.fn();
+    const fns = Array(100)
+      .fill(0)
+      .map((_, i) => {
+        return once
+          .once(() => reallyOnce())
+          .then((once) => {
+            orderFn(i, once);
+            // expect(i).toBe(order++);
+            return `${i}:${once}`;
+          });
+      });
+    expect(await Promise.all(fns)).toEqual(
+      Array(100)
+        .fill(undefined)
+        .map((_, i) => `${i}:42`),
+    );
+    expect(reallyOnce).toHaveBeenCalledTimes(1);
+    const diff = Date.now() - start;
+    expect(diff).toBeGreaterThanOrEqual(99);
+    expect(diff).toBeLessThan(150);
+    expect(orderFn).toHaveBeenCalledTimes(100);
+    expect(orderFn.mock.calls.map(([i]) => i)).toEqual(
+      Array(100)
+        .fill(0)
+        .map((_, i) => i),
+    );
+  });
+
+  it("reset", async () => {
+    const once = new ResolveOnce<number>();
+    const orderFn = vi.fn(async () => 42);
+    once.once(orderFn);
+    once.once(orderFn);
+    once.once(orderFn);
+    once.reset();
+    once.once(orderFn);
+    once.once(orderFn);
+    once.reset();
+    once.once(orderFn);
+    once.once(orderFn);
+    once.reset();
+    expect(orderFn).toHaveBeenCalledTimes(3);
+  });
+
+  it("keyed", async () => {
+    const keyed = new KeyedResolvOnce<number>();
+    const a_orderFn = vi.fn(async () => 42);
+    const b_orderFn = vi.fn(async () => 42);
+    for (let i = 0; i < 5; i++) {
+      keyed.get("a").once(a_orderFn);
+      keyed.get(() => "a").once(a_orderFn);
+      keyed.get("b").once(b_orderFn);
+      keyed.get(() => "b").once(b_orderFn);
+      expect(a_orderFn).toHaveBeenCalledTimes(i + 1);
+      expect(b_orderFn).toHaveBeenCalledTimes(i + 1);
+      keyed.reset();
+    }
+  });
+
+  it("keyed with pass ctx", async () => {
+    const keyed = new KeyedResolvOnce<number>();
+    const a_orderFn = vi.fn(async (key) => key);
+    const b_orderFn = vi.fn(async (key) => key);
+    await Promise.all([
+      keyed.get("a").once(a_orderFn),
+      keyed.get(() => "a").once(a_orderFn),
+      keyed.get("b").once(b_orderFn),
+      keyed.get(() => "b").once(b_orderFn),
+    ]);
+    expect(a_orderFn).toHaveBeenCalledTimes(1);
+    expect(a_orderFn).toHaveBeenCalledWith("a");
+    expect(b_orderFn).toHaveBeenCalledTimes(1);
+    expect(b_orderFn).toHaveBeenCalledWith("b");
+  });
+
+  it("keyed asyncGet", async () => {
+    const keyed = new KeyedResolvOnce<number>();
+    const a_orderFn = vi.fn(async (key) => key);
+    const b_orderFn = vi.fn(async (key) => key);
+    await Promise.all([
+      keyed
+        .asyncGet(async () => {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          return "a";
+        })
+        .then((resolveOnce) => {
+          resolveOnce.once(a_orderFn);
+        }),
+      keyed
+        .asyncGet(async () => {
+          await new Promise((resolve) => setTimeout(resolve, 50));
+          return "b";
+        })
+        .then((resolveOnce) => {
+          resolveOnce.once(b_orderFn);
+        }),
+    ]);
+    expect(a_orderFn).toHaveBeenCalledTimes(1);
+    expect(a_orderFn).toHaveBeenCalledWith("a");
+    expect(b_orderFn).toHaveBeenCalledTimes(1);
+    expect(b_orderFn).toHaveBeenCalledWith("b");
+  });
+
+  function shuffle<T>(array: T[]): T[] {
+    let currentIndex = array.length;
+
+    // While there remain elements to shuffle...
+    while (currentIndex != 0) {
+      // Pick a remaining element...
+      const randomIndex = Math.floor(Math.random() * currentIndex);
+      currentIndex--;
+
+      // And swap it with the current element.
+      [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+    }
+    return array;
+  }
+
+  it("ResolveSeq", async () => {
+    const seq = new ResolveSeq<number>();
+    let enter = 0;
+    let leave = 0;
+    const actions = Array(10)
+      .fill(0)
+      .map((_, i) => {
+        return seq.add(async () => {
+          expect(enter++).toBe(i);
+          await new Promise((resolve) => setTimeout(resolve, i * 3));
+          await new Promise((resolve) => setTimeout(resolve, i * 2));
+          expect(leave++).toBe(i);
+          expect(leave).toBe(enter);
+          return i;
+        }, i);
+      });
+    const ret = await Promise.all(shuffle(actions));
+    expect(ret.length).toBe(10);
+    expect(enter).toBe(10);
+    expect(leave).toBe(10);
+  });
+
+  it("with promise", async () => {
+    const once = new ResolveOnce<number>();
+    let val = 42;
+    const fn = async (): Promise<number> => {
+      return new Promise<number>((resolve) => {
+        setTimeout(() => {
+          resolve(val++);
+        }, 10);
+      });
+    };
+    expect(await once.once(fn)).toBe(42);
+    expect(await once.once(fn)).toBe(42);
+  });
+
+  it("without promise", () => {
+    const once = new ResolveOnce<number>();
+    let val = 42;
+    const fn = (): number => val++;
+    expect(once.once(fn)).toBe(42);
+    expect(once.once(fn)).toBe(42);
+  });
+
+  it("without promise but exception", () => {
+    const once = new ResolveOnce<number>();
+    let val = 42;
+    const fn = (): Promise<number> => {
+      throw new Error(`nope ${val++}`);
+    };
+    expect(() => once.once(fn)).toThrowError("nope 42");
+    expect(() => once.once(fn)).toThrowError("nope 42");
+  });
+});

package/src/resolve-once.ts

@@ -0,0 +1,179 @@
+import { Future } from "./future.js";
+
+interface ResolveSeqItem<T, C> {
+  readonly future: Future<T>;
+  readonly fn: (c: C) => Promise<T>;
+  readonly id?: number;
+}
+
+export class ResolveSeq<T, C = void> {
+  readonly ctx: C;
+  constructor(ctx?: C) {
+    this.ctx = ctx as C;
+  }
+  reset(): void {
+    /* noop */
+  }
+  async _step(item?: ResolveSeqItem<T, C> | undefined): Promise<void> {
+    if (!item) {
+      // done
+      return;
+    }
+    item
+      .fn(this.ctx)
+      .then((value) => item.future.resolve(value))
+      .catch((e) => item.future.reject(e as Error))
+      .finally(() => {
+        this._seqFutures.shift();
+        this._step(this._seqFutures[0]);
+      });
+  }
+  readonly _seqFutures: ResolveSeqItem<T, C>[] = [];
+  async add(fn: (c: C) => Promise<T>, id?: number): Promise<T> {
+    const future = new Future<T>();
+    this._seqFutures.push({ future, fn, id });
+    if (this._seqFutures.length === 1) {
+      this._step(this._seqFutures[0]);
+    }
+    return future.asPromise();
+  }
+}
+
+export class ResolveOnce<T, CTX = void> {
+  _onceDone = false;
+  readonly _onceFutures: Future<T>[] = [];
+  _onceOk = false;
+  _onceValue?: T;
+  _onceError?: Error;
+  _isPromise = false;
+
+  readonly ctx: CTX;
+
+  constructor(ctx?: CTX) {
+    this.ctx = ctx as CTX;
+  }
+
+  get ready(): boolean {
+    return this._onceDone;
+  }
+
+  reset(): void {
+    this._onceDone = false;
+    this._onceOk = false;
+    this._onceValue = undefined;
+    this._onceError = undefined;
+    this._onceFutures.length = 0;
+  }
+
+  // T extends Option<infer U> ? U : T
+  once<R>(fn: (c: CTX) => R): R {
+    if (this._onceDone) {
+      if (this._onceError) {
+        if (this._isPromise) {
+          return Promise.reject(this._onceError) as unknown as R;
+        } else {
+          throw this._onceError;
+        }
+      }
+      if (this._onceOk) {
+        if (this._isPromise) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          return Promise.resolve(this._onceValue!) as unknown as R;
+        } else {
+          return this._onceValue as unknown as R;
+        }
+      }
+      throw new Error("ResolveOnce.once impossible");
+    }
+    const future = new Future<T>();
+    this._onceFutures.push(future);
+    if (this._onceFutures.length === 1) {
+      const okFn = (value: T): void => {
+        this._onceValue = value;
+        this._onceOk = true;
+        this._onceDone = true;
+        if (this._isPromise) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          this._onceFutures.forEach((f) => f.resolve(this._onceValue!));
+        }
+        this._onceFutures.length = 0;
+      };
+      const catchFn = (e: Error): void => {
+        this._onceError = e as Error;
+        this._onceOk = false;
+        this._onceValue = undefined;
+        this._onceDone = true;
+        if (this._isPromise) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          this._onceFutures.forEach((f) => f.reject(this._onceError!));
+        }
+        this._onceFutures.length = 0;
+      };
+      try {
+        const ret = fn(this.ctx);
+        if (typeof (ret as Promise<T>).then === "function") {
+          this._isPromise = true;
+          (ret as Promise<T>).then(okFn).catch(catchFn);
+        } else {
+          okFn(ret as unknown as T);
+        }
+      } catch (e) {
+        catchFn(e as Error);
+      }
+    }
+    if (this._isPromise) {
+      return future.asPromise() as unknown as R;
+    } else {
+      // abit funky but i don't want to impl the return just once
+      return this.once(fn);
+    }
+  }
+}
+
+export class Keyed<T extends { reset: () => void }, K = string> {
+  private readonly _map = new Map<K, T>();
+
+  readonly factory: (key: K) => T;
+  constructor(factory: (key: K) => T) {
+    this.factory = factory;
+  }
+
+  async asyncGet(key: () => Promise<K>): Promise<T> {
+    return this.get(await key());
+  }
+
+  get(key: K | (() => K)): T {
+    if (typeof key === "function") {
+      key = (key as () => K)();
+    }
+    let keyed = this._map.get(key);
+    if (!keyed) {
+      keyed = this.factory(key);
+      this._map.set(key, keyed);
+    }
+    return keyed;
+  }
+
+  unget(key: K): void {
+    const keyed = this._map.get(key);
+    keyed?.reset();
+    this._map.delete(key);
+  }
+
+  reset(): void {
+    this._map.forEach((keyed) => keyed.reset());
+    this._map.clear();
+  }
+}
+
+export class KeyedResolvOnce<T, K = string> extends Keyed<ResolveOnce<T, K>, K> {
+  constructor() {
+    super((key) => new ResolveOnce<T, K>(key));
+  }
+}
+
+export class KeyedResolvSeq<T, K = string> extends Keyed<ResolveSeq<T, K>, K> {
+  constructor() {
+    super((key) => new ResolveSeq<T, K>(key));
+  }
+}

package/src/result.test.ts

@@ -0,0 +1,102 @@
+import { exception2Result, Result, WithoutResult } from "@adviser/cement";
+// import { it } from "vitest/globals";
+
+it("ResultOk", () => {
+  const result = Result.Ok(1);
+  expect(result.isOk()).toBe(true);
+  expect(result.is_ok()).toBe(true);
+  expect(result.Ok()).toBe(1);
+  expect(result.unwrap()).toBe(1);
+
+  expect(result.isErr()).toBe(false);
+  expect(result.is_err()).toBe(false);
+  expect(() => result.Err()).toThrow();
+  expect(() => result.unwrap_err()).toThrow();
+});
+
+it("ResultErr", () => {
+  const result = Result.Err("xxx");
+  expect(result.isOk()).toBe(false);
+  expect(result.is_ok()).toBe(false);
+  expect(result.Err().message).toEqual("xxx");
+  expect(result.unwrap_err().message).toBe("xxx");
+
+  expect(result.isErr()).toBe(true);
+  expect(result.is_err()).toBe(true);
+  expect(() => result.Ok()).toThrow();
+  expect(() => result.unwrap()).toThrow();
+});
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class xResult {}
+class fakeResult {
+  is_ok(): boolean {
+    return true;
+  }
+  is_err(): boolean {
+    return false;
+  }
+  unwrap(): number {
+    return 1;
+  }
+  unwrap_err(): Error {
+    throw new Error("Result is Ok");
+  }
+}
+it("is Result", () => {
+  expect(Result.Is(Result.Ok(1))).toBe(true);
+  expect(Result.Is(Result.Err("xxx"))).toEqual(true);
+  expect(Result.Is(new fakeResult())).toBe(true);
+  expect(Result.Is(new xResult())).toBe(false);
+});
+
+it("WithoutResult", () => {
+  const result = Result.Ok({ a: 1 });
+  const a1: Partial<WithoutResult<typeof result>> = {};
+  a1.a = 1;
+  expect(a1.a).toEqual(1);
+  expect(result.Ok().a).toEqual(1);
+});
+
+it("sync exception2Result ok", () => {
+  expect(exception2Result(() => 1)).toEqual(Result.Ok(1));
+});
+
+it("sync exception2Result throw", () => {
+  expect(
+    exception2Result(() => {
+      throw new Error("x");
+    }),
+  ).toEqual(Result.Err("x"));
+});
+
+it("async exception2Result ok", async () => {
+  expect(await exception2Result(async () => 1)).toEqual(Result.Ok(1));
+});
+
+it("async exception2Result throw", async () => {
+  expect(
+    await exception2Result(async () => {
+      throw new Error("x");
+    }),
+  ).toEqual(Result.Err("x"));
+});
+
+it("result typ", () => {
+  function ok(): Result<number> {
+    return Result.Ok(1);
+  }
+  function err(): Result<number> {
+    return Result.Err("x");
+  }
+  expect(ok().Ok()).toBe(1);
+  expect(err().Err().message).toBe("x");
+});
+
+// it("Result.OK with void", () => {
+//   const result = Result.Ok();
+//   expect(result.isOk()).toBe(true);
+//   expect(result.is_ok()).toBe(true);
+//   expect(result.isErr()).toBe(false);
+//   expect(result.is_err()).toBe(false);
+// }