@adviser/cement 0.2.28 → 0.2.30

package/src/future.ts

@@ -0,0 +1,27 @@
+export class Future<T> {
+  readonly #promise: Promise<T>;
+  #resolveFn: (value: T) => void = () => {
+    throw new Error("This Promise is not working as expected.");
+  };
+  #rejectFn: (reason: unknown) => void = () => {
+    throw new Error("This Promise is not working as expected.");
+  };
+
+  constructor() {
+    this.#promise = new Promise<T>((resolve, reject) => {
+      this.#resolveFn = resolve;
+      this.#rejectFn = reject;
+    });
+  }
+
+  async asPromise(): Promise<T> {
+    return this.#promise;
+  }
+
+  resolve(value: T): void {
+    this.#resolveFn(value);
+  }
+  reject(reason: unknown): void {
+    this.#rejectFn(reason);
+  }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+export * from "./file-service.js";
+export * from "./logger-impl.js";
+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 "./txt-en-decoder.js";
+export * from "./log-level-impl.js";
+export * from "./result.js";
+export * from "./option.js";
+export * from "./future.js";
+export * from "./tracer.js";
+export * from "./resolve-once.js";
+export * from "./runtime.js";
+export * from "./uri.js";
+export * from "./crypto.js";
+export * from "./base-sys-abstraction.js";
+export * from "./bin2text.js";
+export * from "./version.js";
+export * from "./refcounted.js";
+export * as utils from "./utils/index.js";

package/src/jsr.json

@@ -0,0 +1,22 @@
+{
+  "name": "@adviser/cement",
+  "version": "0.2.30",
+  "exports": {
+    ".": "./index.ts",
+    "./web": "./web/index.ts",
+    "./node": "./node/index.ts",
+    "./deno": "./node/index.ts"
+  },
+  "imports": {
+    "yaml": "npm:yaml@^2.5.1",
+    "ts-essentials": "npm:ts-essentials@^10.0.2"
+  },
+  "license": "AFL-2.0",
+  "publish": {
+    "include": [
+      "**/*.ts",
+      "README.md",
+      "LICENSE"
+    ]
+  }
+}

package/src/log-level-impl.ts

@@ -0,0 +1,87 @@
+import { LevelHandler, Level } from "./logger.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>>();
+  isStackExposed = false;
+  enableLevel(level: Level, ...modules: string[]): void {
+    if (modules.length == 0) {
+      this._globalLevels.add(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.set(p, new Set([...this._globalLevels, level]));
+      },
+      ...modules,
+    );
+  }
+  disableLevel(level: Level, ...modules: string[]): void {
+    if (modules.length == 0) {
+      this._globalLevels.delete(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.delete(p);
+      },
+      ...modules,
+    );
+  }
+
+  setExposeStack(enable?: boolean): void {
+    this.isStackExposed = !!enable;
+  }
+
+  forModules(level: Level, fnAction: (p: string) => void, ...modules: (string | string[])[]): void {
+    for (const m of modules.flat()) {
+      if (typeof m !== "string") {
+        continue;
+      }
+      const parts = m
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length);
+      for (const p of parts) {
+        fnAction(p);
+      }
+    }
+  }
+  setDebug(...modules: (string | string[])[]): void {
+    this.forModules(
+      Level.DEBUG,
+      (p) => {
+        this._modules.set(p, new Set([...this._globalLevels, Level.DEBUG]));
+      },
+      ...modules,
+    );
+  }
+  isEnabled(ilevel: unknown, module: unknown): boolean {
+    const level = ilevel as Level; // what if it's not a level?
+    if (typeof module === "string") {
+      const levels = this._modules.get(module);
+      if (levels && levels.has(level)) {
+        return true;
+      }
+    }
+    const wlevel = this._modules.get("*");
+    if (wlevel && typeof level === "string") {
+      if (wlevel.has(level)) {
+        return true;
+      }
+    }
+    if (typeof level !== "string") {
+      // this is a plain log
+      return true;
+    }
+    return this._globalLevels.has(level);
+  }
+}
+
+const levelSingleton = new LevelHandlerImpl();
+
+export function LevelHandlerSingleton(): LevelHandler {
+  return levelSingleton;
+}

package/src/log-writer-impl.ts

@@ -0,0 +1,58 @@
+export class LogWriterStream {
+  readonly _out: WritableStream<Uint8Array>;
+  readonly _toFlush: (() => Promise<void>)[] = [];
+
+  constructor(out: WritableStream<Uint8Array>) {
+    this._out = out;
+  }
+
+  write(encoded: Uint8Array): void {
+    const my = async (): Promise<void> => {
+      // const val = Math.random();
+      // console.log(">>>My:", val)
+      try {
+        const writer = this._out.getWriter();
+        await writer.ready;
+        await writer.write(encoded);
+        await writer.releaseLock();
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error("Chunk error:", err);
+      }
+      // console.log("<<<My:", val)
+    };
+    this._toFlush.push(my);
+    this._flush();
+  }
+
+  _flushIsRunning = false;
+  _flushDoneFns: (() => void)[] = [];
+  _flush(toFlush: (() => Promise<void>)[] | undefined = undefined, done?: () => void): void {
+    if (done) {
+      this._flushDoneFns.push(done);
+    }
+
+    if (this._toFlush.length == 0) {
+      // console.log("Flush is stopped", this._toFlush.length)
+      this._flushIsRunning = false;
+      this._flushDoneFns.forEach((fn) => fn());
+      this._flushDoneFns = [];
+      return;
+    }
+
+    if (!toFlush && this._toFlush.length == 1 && !this._flushIsRunning) {
+      this._flushIsRunning = true;
+      // console.log("Flush is started", this._toFlush.length)
+    } else if (!toFlush) {
+      // console.log("flush queue check but is running", this._toFlush.length)
+      return;
+    }
+
+    // console.log(">>>Msg:", this._toFlush.length)
+    const my = this._toFlush.shift();
+    my?.().finally(() => {
+      // console.log("<<<Msg:", this._toFlush.length)
+      this._flush(this._toFlush);
+    });
+  }
+}