@adviser/cement 0.2.29 → 0.2.31

package/src/resolve-once.test.ts

@@ -1,321 +0,0 @@
-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/result.test.ts

@@ -1,102 +0,0 @@
-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);
-// }

package/src/sys-env.test.ts

@@ -1,53 +0,0 @@
-import { BrowserEnvActions, EnvImpl, envFactory } from "@adviser/cement";
-
-describe("sys_env", () => {
-  let key: string;
-  const envImpl = envFactory();
-  beforeEach(() => {
-    key = `key-${Math.random()}`;
-  });
-  it("actions", () => {
-    expect(envImpl.get(key)).toBeUndefined();
-    envImpl.set(key, "value");
-    expect(envImpl.get(key)).toBe("value");
-    envImpl.set(key);
-    expect(envImpl.get(key)).toBe("value");
-    envImpl.delete(key);
-    expect(envImpl.get(key)).toBeUndefined();
-  });
-  it("preset", () => {
-    const env = new EnvImpl(new BrowserEnvActions({}), {
-      presetEnv: new Map([[key, "value"]]),
-    });
-    expect(env.get(key)).toBe("value");
-    env.delete(key);
-    expect(env.get(key)).toBeUndefined();
-  });
-  it("onSet wild card", () => {
-    const fn = vi.fn();
-    envImpl.onSet(fn);
-    expect(fn).toBeCalledTimes(envImpl.keys().length);
-    expect(fn.mock.calls.map((i) => i[0]).sort()).toEqual(envImpl.keys().sort());
-    expect(fn.mock.calls.map((i) => i[1]).sort()).toEqual(
-      envImpl
-        .keys()
-        .map((i) => envImpl.get(i))
-        .sort(),
-    );
-  });
-  it("onSet filter", () => {
-    const env = new EnvImpl(new BrowserEnvActions({}), {
-      presetEnv: new Map([[key, "value"]]),
-    });
-    const fn = vi.fn();
-    env.onSet(fn, key);
-    expect(fn).toBeCalledTimes(1);
-    expect(fn.mock.calls[0]).toEqual([key, "value"]);
-    env.set(key, "value2");
-    expect(fn).toBeCalledTimes(2);
-    expect(fn.mock.calls[1]).toEqual([key, "value2"]);
-    env.delete(key);
-    expect(fn).toBeCalledTimes(3);
-    expect(fn.mock.calls[2]).toEqual([key, undefined]);
-  });
-});