@adviser/cement 0.2.28 → 0.2.30

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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,133 @@
+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/node/index.ts

@@ -0,0 +1,4 @@
+export * from "./node-file-service.js";
+export * from "./node-sys-abstraction.js";
+export * from "./deno-sys-abstraction.js";
+export * from "./mock-file-service.js";

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

@@ -0,0 +1,45 @@
+import { NamedWritableStream } from "../file-service.js";
+import { NodeFileService } from "./node-file-service.js";
+
+export interface FileCollector {
+  readonly name: string;
+  content: string;
+}
+
+export class MockFileService extends NodeFileService {
+  readonly files = {} as Record<string, FileCollector>;
+
+  // override abs(fname: string): string {
+  //   return this.join("/mock/", fname);
+  // }
+
+  override async create(fname: string): Promise<NamedWritableStream> {
+    let oName = fname;
+    if (!this.isAbsolute(fname)) {
+      oName = await this.abs(fname);
+    }
+
+    const fc = {
+      name: oName,
+      content: "",
+    };
+    this.files[oName] = fc;
+    this.files[fname] = fc;
+    const decoder = new TextDecoder();
+
+    return {
+      name: oName,
+      stream: new WritableStream<Uint8Array>({
+        write(chunk): void {
+          fc.content = fc.content + decoder.decode(chunk);
+        },
+        close(): void {
+          // do nothing
+        },
+        abort(): void {
+          throw new Error("not implemented");
+        },
+      }),
+    };
+  }
+}

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

@@ -0,0 +1,91 @@
+import path from "node:path";
+import fs from "node:fs";
+import process from "node:process";
+import { FileService, NamedWritableStream } from "../file-service.js";
+import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class NodeFileService implements FileService {
+  readonly baseDir: string;
+  constructor(baseDir: string = process.cwd()) {
+    this.baseDir = this.abs(baseDir);
+  }
+
+  // nodeImport(fname: string): string {
+  //   // console.log('nodeImport:'+ fname);
+  //   if (path.isAbsolute(fname)) {
+  //     return fname;
+  //   } else {
+  //     return "./" + path.normalize(fname);
+  //   }
+  // }
+
+  readFileString(fname: string): Promise<string> {
+    return fs.promises.readFile(fname, { encoding: "utf-8" });
+  }
+
+  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 = process.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 = process.cwd();
+      return path.resolve(cwd, fname);
+    }
+  }
+
+  isAbsolute(fname: string): boolean {
+    return path.isAbsolute(fname);
+  }
+
+  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = 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 fs.promises.mkdir(base, { recursive: true });
+    const out = fs.createWriteStream(oName);
+    return {
+      name: oName,
+      stream: new WritableStream<Uint8Array>({
+        write(chunk): void {
+          out.write(chunk);
+        },
+        close(): void {
+          out.close();
+        },
+        abort(): void {
+          throw new Error("not implemented");
+        },
+      }),
+    };
+  }
+}

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

@@ -0,0 +1,121 @@
+import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
+import {
+  BaseSysAbstraction,
+  ExitHandler,
+  ExitService,
+  WrapperSysAbstraction,
+  WrapperSysAbstractionParams,
+} from "../base-sys-abstraction.js";
+import { NodeFileService } from "./node-file-service.js";
+import { Env, envFactory } from "../sys-env.js";
+import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import process from "node:process";
+
+export class NodeExitServiceImpl implements ExitService {
+  constructor() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    process.on("unhandledRejection", (reason: string, p: Promise<unknown>) => {
+      this.exit(19);
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    process.on("uncaughtException", (error: Error) => {
+      this.exit(18);
+    });
+    process.on("close", () => {
+      this.exit(0);
+    });
+    process.on("exit", () => {
+      this.exit(0);
+    });
+    process.on("SIGQUIT", () => {
+      this.exit(3);
+    });
+    process.on("SIGINT", () => {
+      this.exit(2);
+    });
+    process.on("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(() => {
+        process.exit(code);
+      })
+      .catch((err) => {
+        // eslint-disable-next-line no-console
+        console.error("ExitService: failed to handle exit", err);
+        process.exit(code);
+      });
+  }
+}
+
+export class NodeSystemService implements SystemService {
+  static readonly _exitHandlers: ExitHandler[] = [];
+  readonly _exitService: ExitService = new NodeExitServiceImpl();
+  constructor() {
+    this._exitService.injectExitHandlers(NodeSystemService._exitHandlers);
+  }
+
+  Env(): Env {
+    return envFactory();
+  }
+
+  Args(): string[] {
+    return process.argv;
+  }
+
+  OnExit(hdl: VoidFunc): VoidFunc {
+    const id = crypto.randomUUID();
+    NodeSystemService._exitHandlers.push({ hdl, id });
+    return () => {
+      const idx = NodeSystemService._exitHandlers.findIndex((h) => h.id === id);
+      if (idx >= 0) {
+        NodeSystemService._exitHandlers.splice(idx, 1);
+      }
+    };
+  }
+
+  Exit(code: number): void {
+    this._exitService.exit(code);
+  }
+}
+
+let my: BaseSysAbstraction | undefined = undefined;
+export function NodeSysAbstraction(param?: WrapperSysAbstractionParams): SysAbstraction {
+  if (!my) {
+    my = new BaseSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || Utf8EnDecoderSingleton(),
+      FileSystem: new NodeFileService(),
+      SystemService: new NodeSystemService(),
+    });
+  }
+  return new WrapperSysAbstraction(my, param);
+}

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/refcounted.ts

@@ -0,0 +1,23 @@
+type Refcounted<T, M extends string> = T & {
+  __refcounted: number;
+  __unrefcounted: () => void;
+} & Record<M, () => void>;
+
+export function wrapRefcounted<T, M extends string>(t: T, method: M): T {
+  const my = t as Refcounted<T, M>;
+  my.__refcounted = (my.__refcounted || 0) + 1;
+  if (my.__refcounted === 1) {
+    my.__unrefcounted = my[method];
+    const mRec = my as Record<string, () => void>;
+    mRec[method] = function (this: Refcounted<T, M>): void {
+      this.__refcounted--;
+      if (this.__refcounted === 0) {
+        this.__unrefcounted();
+      }
+      if (this.__refcounted < 0) {
+        throw new Error("already closed");
+      }
+    };
+  }
+  return t;
+}