@adviser/cement 0.0.0-jsr-t1 → 0.0.0-smoke-ci

package/src/node/deno-file-service.ts

@@ -1,92 +0,0 @@
-import { FileService, NamedWritableStream } from "../file-service.js";
-import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
-import * as path from "node:path";
-
-const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {
-  cwd(): string;
-  readFile(fname: string): Promise<Uint8Array>;
-  mkdir(base: string, options: { recursive: boolean }): Promise<void>;
-  open(fname: string, options: { write: boolean; create: boolean; truncate: boolean }): Promise<WritableStream>;
-};
-
-export class DenoFileService implements FileService {
-  readonly baseDir: string;
-  readonly txtEnde: TxtEnDecoder;
-  constructor(baseDir: string = Deno.cwd(), txtEnde: TxtEnDecoder = Utf8EnDecoderSingleton()) {
-    this.baseDir = this.abs(baseDir);
-    this.txtEnde = txtEnde;
-  }
-
-  // nodeImport(fname: string): string {
-  //   // console.log('nodeImport:'+ fname);
-  //   if (path.isAbsolute(fname)) {
-  //     return fname;
-  //   } else {
-  //     return "./" + path.normalize(fname);
-  //   }
-  // }
-
-  async readFileString(fname: string): Promise<string> {
-    return this.txtEnde.decode(await Deno.readFile(fname));
-  }
-
-  dirname(fname: string): string {
-    return path.dirname(fname);
-  }
-  basename(fname: string): string {
-    return path.basename(fname);
-  }
-
-  join(...paths: string[]): string {
-    return path.join(...paths);
-  }
-
-  relative(from: string, to?: string): string {
-    if (to === undefined) {
-      to = from;
-      from = Deno.cwd();
-    }
-    const ret = path.relative(from, to);
-    // console.log('relative:'+ from + " -> " + to +   "= " + ret);
-    return ret;
-  }
-
-  abs(fname: string): string {
-    if (path.isAbsolute(fname)) {
-      return fname;
-    } else {
-      const cwd = Deno.cwd();
-      return path.resolve(cwd, fname);
-    }
-  }
-
-  isAbsolute(fname: string): boolean {
-    return path.isAbsolute(fname);
-  }
-
-  async writeFileString(fname: string, content: string, ende = Utf8EnDecoderSingleton()): Promise<void> {
-    const o = await this.create(fname);
-    const wr = o.stream.getWriter();
-    await wr.write(ende.encode(content));
-    await wr.close();
-  }
-
-  async create(fname: string): Promise<NamedWritableStream> {
-    let oName = fname;
-    if (!path.isAbsolute(fname)) {
-      oName = this.abs(fname);
-    }
-
-    const base = path.dirname(oName);
-    await Deno.mkdir(base, { recursive: true });
-    const out = await Deno.open(oName, {
-      write: true,
-      create: true,
-      truncate: true,
-    });
-    return {
-      name: oName,
-      stream: out,
-    };
-  }
-}

package/src/node/deno-sys-abstraction.ts

@@ -1,133 +0,0 @@
-import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import {
-  BaseSysAbstraction,
-  ExitHandler,
-  ExitService,
-  WrapperSysAbstraction,
-  WrapperSysAbstractionParams,
-} from "../base-sys-abstraction.js";
-import { Env, envFactory } from "../sys-env.js";
-import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
-import * as process from "node:process";
-import { DenoFileService } from "./deno-file-service.js";
-
-const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {
-  addSignalListener(sig: string, hdl: () => void): void;
-  exit(code?: number): void;
-};
-
-export class DenoExitServiceImpl implements ExitService {
-  constructor() {
-    globalThis.addEventListener("unhandledrejection", (e) => {
-      e.preventDefault();
-      this.exit(19);
-    });
-    globalThis.addEventListener("error", () => {
-      this.exit(19);
-    });
-    globalThis.addEventListener("uncaughtException", () => {
-      this.exit(19);
-    });
-
-    // process.on("close", () => {
-    //   this.exit(0);
-    // });
-    globalThis.addEventListener("unload", () => {
-      this.exit(0);
-      // console.log('goodbye!');
-    });
-
-    // process.on("exit", () => {
-    // });
-    Deno.addSignalListener("SIGQUIT", () => {
-      this.exit(3);
-    });
-    Deno.addSignalListener("SIGINT", () => {
-      this.exit(2);
-    });
-    Deno.addSignalListener("SIGTERM", () => {
-      this.exit(9);
-    });
-  }
-  _exitHandlers: ExitHandler[] = [];
-  injectExitHandlers(hdls: ExitHandler[]): void {
-    // console.log("ExitService: injecting exit handlers", hdls)
-    this._exitHandlers = hdls;
-  }
-  invoked = false;
-  readonly _handleExit = async (): Promise<void> => {
-    if (this.invoked) {
-      // console.error("ExitService: already invoked");
-      return;
-    }
-    this.invoked = true;
-    for (const h of this._exitHandlers) {
-      try {
-        // console.log(`ExitService: calling handler ${h.id}`)
-        const ret = h.hdl();
-        // console.log(`ExitService: called handler ${h.id}`, ret)
-        if (typeof (ret as Promise<void>).then === "function") {
-          await ret;
-        }
-      } finally {
-        // ignore
-      }
-    }
-  };
-
-  exit(code: number): void {
-    // console.log("ExitService: exit called", code)
-    this._handleExit()
-      .then(() => {
-        Deno.exit(code);
-      })
-      .catch((err) => {
-        // eslint-disable-next-line no-console
-        console.error("ExitService: failed to handle exit", err);
-        Deno.exit(code);
-      });
-  }
-}
-
-export class DenoSystemService implements SystemService {
-  static readonly _exitHandlers: ExitHandler[] = [];
-  readonly _exitService: ExitService = new DenoExitServiceImpl();
-  constructor() {
-    this._exitService.injectExitHandlers(DenoSystemService._exitHandlers);
-  }
-
-  Env(): Env {
-    return envFactory();
-  }
-
-  Args(): string[] {
-    return process.argv;
-  }
-
-  OnExit(hdl: VoidFunc): VoidFunc {
-    const id = crypto.randomUUID();
-    DenoSystemService._exitHandlers.push({ hdl, id });
-    return () => {
-      const idx = DenoSystemService._exitHandlers.findIndex((h) => h.id === id);
-      if (idx >= 0) {
-        DenoSystemService._exitHandlers.splice(idx, 1);
-      }
-    };
-  }
-
-  Exit(code: number): void {
-    this._exitService.exit(code);
-  }
-}
-
-let my: BaseSysAbstraction | undefined = undefined;
-export function DenoSysAbstraction(param?: WrapperSysAbstractionParams): SysAbstraction {
-  if (!my) {
-    my = new BaseSysAbstraction({
-      TxtEnDecoder: param?.TxtEnDecoder || Utf8EnDecoderSingleton(),
-      FileSystem: new DenoFileService(),
-      SystemService: new DenoSystemService(),
-    });
-  }
-  return new WrapperSysAbstraction(my, param);
-}

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]);
-  });
-});