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

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

@@ -0,0 +1,131 @@
+import {
+  ExitService,
+  ExitHandler,
+  BaseSysAbstraction,
+  WrapperBasicSysAbstractionParams,
+  WrapperRuntimeSysAbstraction,
+} from "../base-sys-abstraction.js";
+import { ResolveOnce } from "../resolve-once.js";
+import { RuntimeSysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
+import { TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+import { DenoBasicSysAbstraction } from "./deno-basic-sys-abstraction.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;
+  args: string[];
+};
+
+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);
+  }
+
+  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);
+  }
+}
+
+const baseSysAbstraction = new ResolveOnce<BaseSysAbstraction>();
+export function DenoSysAbstraction(param?: WrapperBasicSysAbstractionParams): RuntimeSysAbstraction {
+  const my = baseSysAbstraction.once(
+    () =>
+      new BaseSysAbstraction({
+        TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+        FileSystem: new DenoFileService(),
+        SystemService: new DenoSystemService(),
+      }),
+  );
+  return new WrapperRuntimeSysAbstraction(my, {
+    basicRuntimeService: DenoBasicSysAbstraction(param),
+    ...param,
+  });
+}

package/src/deno/index.ts

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

package/src/http_header.ts

@@ -0,0 +1,209 @@
+export class HeadersImpl implements Headers {
+  // readonly _headers: Map<string, string>;
+  readonly impl: Headers = new Headers();
+
+  constructor(init: Map<string, string | string[]>) {
+    // super();
+    for (const [k, v] of init) {
+      this.append(k, v);
+    }
+  }
+  // toKey(key: string): string {
+  //   return key.toLowerCase();
+  // }
+
+  forEach(callbackfn: (value: string, key: string, parent: this) => void): void {
+    this.impl.forEach((v, k) => {
+      callbackfn(v, k, this);
+    });
+  }
+
+  delete(name: string): void {
+    this.impl.delete(name);
+  }
+  get(name: string): string | null {
+    return this.impl.get(name);
+  }
+  getSetCookie(): string[] {
+    return this.impl.getSetCookie();
+  }
+  has(name: string): boolean {
+    return this.impl.has(name);
+  }
+  set(name: string, value: string): void {
+    this.impl.set(name, value);
+  }
+
+  *[Symbol.iterator](): IterableIterator<[string, string]> {
+    const keys: [string, string][] = [];
+    this.impl.forEach((v, k) => {
+      keys.push([k, v]);
+    });
+    for (const k of keys) {
+      yield k;
+    }
+  }
+
+  entries(): IterableIterator<[string, string]> {
+    return this[Symbol.iterator]();
+  }
+  *keys(): IterableIterator<string> {
+    const keys: string[] = [];
+    this.impl.forEach((_, k) => {
+      keys.push(k);
+    });
+    for (const k of keys) {
+      yield k;
+    }
+  }
+  *values(): IterableIterator<string> {
+    for (const k of this.keys()) {
+      const v = this.impl.get(k);
+      if (!v) {
+        continue;
+      }
+      yield v;
+    }
+  }
+
+  append(key: string, value?: string | string[]): HeadersImpl {
+    if (!(typeof value === "string" || Array.isArray(value))) {
+      return this;
+    }
+    const existingValues = this.impl.get(key) || "";
+    const newValues = Array.isArray(value) ? value : [value];
+    const allValues = existingValues ? [...existingValues.split(", ").map((v) => v.trim()), ...newValues] : newValues;
+    // Remove empty strings and duplicates while preserving order
+    const uniqueValues = [...new Set(allValues.filter((v) => v !== ""))];
+    this.impl.set(key, uniqueValues.join(", "));
+    return this;
+  }
+}
+
+export class HttpHeader {
+  readonly _headers: Map<string, string[]> = new Map<string, string[]>();
+
+  static from(headers?: HeadersInit | Headers | HttpHeader): HttpHeader {
+    if (headers instanceof HttpHeader) {
+      return headers.Clone();
+    }
+    const h = new HttpHeader();
+    if (headers) {
+      if (Array.isArray(headers)) {
+        for (const [k, v] of headers) {
+          if (v) {
+            h.Add(k, v);
+          }
+        }
+      } else if (headers instanceof Headers) {
+        headers.forEach((v, k) => {
+          if (v) {
+            h.Add(
+              k,
+              v.split(",").map((v) => v.trim()),
+            );
+          }
+        });
+      } else {
+        for (const k in headers) {
+          const v = (headers as Record<string, string | string[]>)[k];
+          (Array.isArray(v) ? v : [v]).forEach((v) => {
+            h.Add(k, v);
+          });
+        }
+      }
+    }
+    return h;
+  }
+
+  _asStringString(): Map<string, string> {
+    const ret = new Map<string, string>();
+    for (const [key, values] of this._headers) {
+      ret.set(key, values.join(", "));
+    }
+    return ret;
+  }
+
+  _key(key: string): string {
+    return key.toLowerCase();
+  }
+  Values(key: string): string[] {
+    const values = this._headers.get(this._key(key));
+    return values || [];
+  }
+  Get(key: string): string | undefined {
+    const values = this._headers.get(this._key(key));
+    if (values === undefined || values.length === 0) {
+      return undefined;
+    }
+    return values[0];
+  }
+  Set(key: string, valueOr: string | string[]): HttpHeader {
+    const value = Array.isArray(valueOr) ? valueOr : [valueOr];
+    this._headers.set(this._key(key), value);
+    return this;
+  }
+  Add(key: string, value: string | string[] | undefined): HttpHeader {
+    if (typeof value === "undefined") {
+      return this;
+    }
+    const vs = Array.isArray(value) ? value : [value];
+    const values = this._headers.get(this._key(key));
+    if (values === undefined) {
+      this._headers.set(this._key(key), vs);
+    } else {
+      values.push(...vs);
+    }
+    return this;
+  }
+  Del(ey: string): HttpHeader {
+    this._headers.delete(this._key(ey));
+    return this;
+  }
+  Items(): [string, string[]][] {
+    return Array.from(this._headers).filter(([_, vs]) => vs.length > 0);
+  }
+  SortItems(): [string, string[]][] {
+    return this.Items().sort(([[a]], [[b]]) => a.localeCompare(b));
+  }
+  Clone(): HttpHeader {
+    const clone = new HttpHeader();
+    for (const [key, values] of this._headers.entries()) {
+      clone._headers.set(key, values.slice());
+    }
+    return clone;
+  }
+  AsRecordStringStringArray(): Record<string, string[]> {
+    const obj: Record<string, string[]> = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = [...values];
+    }
+    return obj;
+  }
+  AsRecordStringString(): Record<string, string> {
+    const obj: Record<string, string> = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values.join(", ");
+    }
+    return obj;
+  }
+  AsHeaderInit(): HeadersInit {
+    const obj: HeadersInit = {};
+    for (const [key, values] of this._headers.entries()) {
+      obj[key] = values[0];
+    }
+    return obj;
+  }
+  AsHeaders(): HeadersImpl {
+    return new HeadersImpl(this._asStringString());
+  }
+  Merge(other?: HttpHeader): HttpHeader {
+    const ret = this.Clone();
+    if (other) {
+      for (const [key, values] of other.Items()) {
+        ret.Add(key, values);
+      }
+    }
+    return ret;
+  }
+}

package/src/index.ts

@@ -4,8 +4,7 @@ export * from "./logger.js";
 export * from "./sys-abstraction.js";
 export * from "./sys-env.js";
 export * from "./time.js";
-export * from "./test/log-write-stream.js";
-export * from "./test/mock-logger.js";
+export * from "./test/index.js";
 export * from "./txt-en-decoder.js";
 export * from "./log-level-impl.js";
 export * from "./result.js";
@@ -19,4 +18,17 @@ export * from "./crypto.js";
 export * from "./base-sys-abstraction.js";
 export * from "./bin2text.js";
 export * from "./version.js";
+export * from "./http_header.js";
+export * from "./path-ops.js";
+export * from "./json-en-decoder.js";
+export * from "./types.js";
+export * from "./lru-map-set.js";
+export * from "./coerce-binary.js";
+export * from "./is-promise.js";
+export * from "./app-context.js";
+
+// ugly
 export * as utils from "./utils/index.js";
+// import * as utils from "./utils/index.js";
+
+// export const param = utils.param;

package/src/is-json.ts

@@ -0,0 +1,20 @@
+const possibleJSONre = new RegExp(
+  '^\\s*(?:\\{.*\\}|\\[.*\\]|"(?:[^"\\\\]|\\\\.)*"|true|false|null|-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)\\s*$',
+);
+
+export interface IsJSONResult<T> {
+  readonly isJSON: boolean;
+  readonly parsed?: T;
+}
+
+export function isJSON<T = unknown>(str: string): IsJSONResult<T> {
+  if (possibleJSONre.test(str)) {
+    try {
+      const parsed = JSON.parse(str) as T;
+      return { isJSON: true, parsed };
+    } catch {
+      /* noop */
+    }
+  }
+  return { isJSON: false };
+}

package/src/is-promise.ts

@@ -0,0 +1,18 @@
+export type UnPromisify<T> = T extends Promise<infer U> ? U : T;
+export type WithoutPromise<T> = UnPromisify<T>;
+
+export type Promisable<T> = T | Promise<T>;
+
+export function isPromise<T>(a: T): a is T extends Promise<unknown> ? T : never {
+  const mayBe = a as unknown as { then: () => void; catch: () => void; finally: () => void };
+  return (
+    mayBe instanceof Promise ||
+    !!(
+      mayBe &&
+      mayBe !== null &&
+      typeof mayBe.then === "function" &&
+      typeof mayBe.catch === "function" &&
+      typeof mayBe.finally === "function"
+    )
+  );
+}

package/src/json-en-decoder.ts

@@ -0,0 +1,83 @@
+import { exception2Result, Result } from "./result.js";
+import { AsyncToEnDecoder, ToEnDecoder, TxtEnDecoder, TxtEnDecoderSingleton as TxtEnDecoderSingleton } from "./txt-en-decoder.js";
+
+export interface JSONEnDecoder {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stringify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+  asyncStringify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<string>;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  uint8ify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): Uint8Array;
+  asyncUint8ify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<Uint8Array>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse<T>(input: ToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Result<T>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  asyncParse<T>(input: AsyncToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Promise<Result<T>>;
+}
+
+class JSONOps implements JSONEnDecoder {
+  readonly txtOps: TxtEnDecoder;
+  constructor(txtOps: TxtEnDecoder) {
+    this.txtOps = txtOps;
+  }
+  async asyncStringify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<string> {
+    const resolved = await input;
+    return this.stringify(resolved, replacer, space);
+  }
+  async asyncUint8ify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<Uint8Array> {
+    const resolved = await input;
+    return this.uint8ify(resolved, replacer, space);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async asyncParse<T>(input: AsyncToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Promise<Result<T>> {
+    return this.parse(await this.txtOps.asyncDecode(input), reviver);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stringify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string {
+    return JSON.stringify(Result.Is(input) ? input.unwrap() : input, replacer, space);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  uint8ify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): Uint8Array {
+    return this.txtOps.encode(this.stringify(input, replacer, space));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse<T>(input: ToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Result<T> {
+    return exception2Result(() => JSON.parse(this.txtOps.decode(input), reviver) as T) as Result<T>;
+  }
+}
+
+let jsonEnDecoder: JSONEnDecoder;
+export function JSONEnDecoderSingleton(txtEnde?: TxtEnDecoder): JSONEnDecoder {
+  let needNew = false;
+  if (txtEnde && txtEnde !== TxtEnDecoderSingleton()) {
+    needNew = !!txtEnde;
+    txtEnde = txtEnde ?? TxtEnDecoderSingleton();
+  }
+  if (needNew && txtEnde) {
+    return new JSONOps(txtEnde);
+  }
+  jsonEnDecoder = jsonEnDecoder ?? new JSONOps(TxtEnDecoderSingleton());
+  return jsonEnDecoder;
+}

package/src/log-level-impl.ts

@@ -1,8 +1,13 @@
 import { LevelHandler, Level } from "./logger.js";
+import { Option } from "./option.js";
 
 export class LevelHandlerImpl implements LevelHandler {
   readonly _globalLevels: Set<Level> = new Set<Level>([Level.INFO, Level.ERROR, Level.WARN]);
   readonly _modules: Map<string, Set<Level>> = new Map<string, Set<Level>>();
+
+  readonly _timer: Map<string, Date> = new Map<string, Date>();
+
+  ignoreAttr: Option<RegExp> = Option.Some(/^_/);
   isStackExposed = false;
   enableLevel(level: Level, ...modules: string[]): void {
     if (modules.length == 0) {
@@ -35,6 +40,10 @@ export class LevelHandlerImpl implements LevelHandler {
     this.isStackExposed = !!enable;
   }
 
+  setIgnoreAttr(re?: RegExp): void {
+    this.ignoreAttr = Option.From(re);
+  }
+
   forModules(level: Level, fnAction: (p: string) => void, ...modules: (string | string[])[]): void {
     for (const m of modules.flat()) {
       if (typeof m !== "string") {
@@ -78,6 +87,23 @@ export class LevelHandlerImpl implements LevelHandler {
     }
     return this._globalLevels.has(level);
   }
+
+  timerStart(key: string): Date {
+    const now = new Date();
+    this._timer.set(key, now);
+    return now;
+  }
+
+  timerEnd(key: string): { now: Date; duration: number } {
+    const now = new Date();
+    const start = this._timer.get(key);
+    if (!start) {
+      return { now, duration: 0 };
+    }
+    const duration = now.getTime() - start.getTime(); // duration in milliseconds
+    this._timer.delete(key);
+    return { now, duration };
+  }
 }
 
 const levelSingleton = new LevelHandlerImpl();

package/src/log-writer-impl.ts

@@ -2,19 +2,25 @@ export class LogWriterStream {
   readonly _out: WritableStream<Uint8Array>;
   readonly _toFlush: (() => Promise<void>)[] = [];
 
+  readonly _id: number;
+
   constructor(out: WritableStream<Uint8Array>) {
     this._out = out;
+    this._id = Math.random();
+    // console.log(">>>My:constructor:", this._id);
   }
 
   write(encoded: Uint8Array): void {
     const my = async (): Promise<void> => {
       // const val = Math.random();
-      // console.log(">>>My:", val)
+      // console.log(">>>My:", encoded)
       try {
+        // console.log(">>>My:getWriter:get:", this._id);
         const writer = this._out.getWriter();
         await writer.ready;
         await writer.write(encoded);
-        await writer.releaseLock();
+        writer.releaseLock();
+        // console.log(">>>My:getWriter:release", this._id);
       } catch (err) {
         // eslint-disable-next-line no-console
         console.error("Chunk error:", err);
@@ -50,9 +56,14 @@ export class LogWriterStream {
 
     // console.log(">>>Msg:", this._toFlush.length)
     const my = this._toFlush.shift();
-    my?.().finally(() => {
-      // console.log("<<<Msg:", this._toFlush.length)
-      this._flush(this._toFlush);
-    });
+    my?.()
+      .catch((e) => {
+        // eslint-disable-next-line no-console
+        console.error("Flush error:", e);
+      })
+      .finally(() => {
+        // console.log("<<<Msg:", this._toFlush.length)
+        this._flush(this._toFlush);
+      });
   }
 }