@adviser/cement 0.2.15 → 0.2.17

package/index.cjs

@@ -77,6 +77,7 @@ __export(src_exports, {
   BrowserEnvActions: () => BrowserEnvActions,
   BuildURI: () => BuildURI,
   EnvImpl: () => EnvImpl,
+  FanoutWriter: () => FanoutWriter,
   Future: () => Future,
   IDMode: () => IDMode,
   IsLogger: () => IsLogger,
@@ -87,7 +88,8 @@ __export(src_exports, {
   LevelHandlerImpl: () => LevelHandlerImpl,
   LogCollector: () => LogCollector,
   LogValue: () => LogValue,
-  LogWriter: () => LogWriter,
+  LogWriterCollector: () => LogWriterCollector,
+  LogWriterStream: () => LogWriterStream,
   LoggerImpl: () => LoggerImpl,
   MockLogger: () => MockLogger,
   None: () => None,
@@ -1024,12 +1026,36 @@ var URI = class _URI {
   }
 };
 
+// src/runtime.ts
+function isSet(value, ref = globalThis) {
+  const [head, ...tail] = value.split(".");
+  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
+    if (tail.length <= 1) {
+      return true;
+    }
+    return isSet(tail.join("."), ref[head]);
+  }
+  return false;
+}
+function runtimeFn() {
+  const isReactNative = isSet("navigator.product") && globalThis.navigator.product === "ReactNative";
+  const isNodeIsh = isSet("process.versions.node") && !isReactNative;
+  const isDeno = isSet("Deno") && !isReactNative;
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno) && !isReactNative,
+    isDeno,
+    isReactNative
+  };
+}
+
 // src/logger_impl.ts
 var encoder = new TextEncoder();
 var LevelHandlerImpl = class {
   constructor() {
     this._globalLevels = /* @__PURE__ */ new Set(["info" /* INFO */, "error" /* ERROR */, "warn" /* WARN */]);
     this._modules = /* @__PURE__ */ new Map();
+    this.isStackExposed = false;
   }
   enableLevel(level, ...modules) {
     if (modules.length == 0) {
@@ -1057,6 +1083,9 @@ var LevelHandlerImpl = class {
       ...modules
     );
   }
+  setExposeStack(enable) {
+    this.isStackExposed = !!enable;
+  }
   forModules(level, fnAction, ...modules) {
     for (const m of modules.flat()) {
       if (typeof m !== "string") {
@@ -1098,7 +1127,7 @@ var LevelHandlerImpl = class {
   }
 };
 var levelSingleton = new LevelHandlerImpl();
-var LogWriter = class {
+var LogWriterStream = class {
   constructor(out) {
     this._toFlush = [];
     this._flushIsRunning = false;
@@ -1164,6 +1193,68 @@ function toLogValue(lop) {
   }
   return lop;
 }
+var ConsoleWriterStreamDefaultWriter = class {
+  constructor(stream) {
+    this.stream = stream;
+    this.desiredSize = null;
+    this.decoder = new TextDecoder();
+    this._stream = stream;
+    this.ready = Promise.resolve(void 0);
+    this.closed = Promise.resolve(void 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  abort(reason) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+  }
+  releaseLock() {
+    this._stream.locked = false;
+    this.ready = Promise.resolve(void 0);
+    this.closed = Promise.resolve(void 0);
+  }
+  async write(chunk) {
+    const str = this.decoder.decode(chunk).trimEnd();
+    let output = "log";
+    try {
+      const decode = JSON.parse(str);
+      output = decode.level;
+    } catch (e) {
+    }
+    switch (output) {
+      case "error":
+        console.error(str);
+        break;
+      case "warn":
+        console.warn(str);
+        break;
+      default:
+        console.log(str);
+    }
+  }
+};
+var ConsoleWriterStream = class {
+  constructor() {
+    this.locked = false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+  abort(reason) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+    return;
+  }
+  getWriter() {
+    if (this.locked) {
+      throw new Error("Stream is locked");
+    }
+    this.locked = true;
+    if (!this._writer) {
+      this._writer = new ConsoleWriterStreamDefaultWriter(this);
+    }
+    return this._writer;
+  }
+};
 var LoggerImpl = class _LoggerImpl {
   // readonly _id: string = "logger-" + Math.random().toString(36)
   constructor(params) {
@@ -1180,9 +1271,20 @@ var LoggerImpl = class _LoggerImpl {
       this._logWriter = params.logWriter;
     } else {
       if (!params.out) {
-        this._logWriter = new LogWriter(this._sys.Stdout());
+        const rt = runtimeFn();
+        let stream;
+        if (rt.isBrowser) {
+          stream = new ConsoleWriterStream();
+        } else {
+          if (rt.isNodeIsh || rt.isReactNative) {
+            stream = this._sys.Stdout();
+          } else {
+            throw new Error("No output defined for runtime");
+          }
+        }
+        this._logWriter = new LogWriterStream(stream);
       } else {
-        this._logWriter = new LogWriter(params.out);
+        this._logWriter = new LogWriterStream(params.out);
       }
     }
     if (!params.withAttributes) {
@@ -1197,6 +1299,10 @@ var LoggerImpl = class _LoggerImpl {
       this._levelHandler = levelSingleton;
     }
   }
+  SetExposeStack(enable) {
+    this._levelHandler.setExposeStack(enable);
+    return this;
+  }
   EnableLevel(level, ...modules) {
     this._levelHandler.enableLevel(level, ...modules);
     return this;
@@ -1239,8 +1345,12 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Err(err) {
+    var _a;
     if (err instanceof Error) {
       this._attributes["error"] = logValue(err.message);
+      if (this._levelHandler.isStackExposed) {
+        this._attributes["stack"] = logValue((_a = err.stack) == null ? void 0 : _a.split("\n").map((s) => s.trim()));
+      }
     } else {
       this._attributes["error"] = logValue("" + err);
     }
@@ -1372,6 +1482,10 @@ var WithLoggerBuilder = class {
     Object.assign(this._li._withAttributes, this._li._attributes);
     return this._li;
   }
+  SetExposeStack(enable) {
+    this._li._levelHandler.setExposeStack(enable);
+    return this;
+  }
   EnableLevel(level, ...modules) {
     this._li._levelHandler.enableLevel(level, ...modules);
     return this;
@@ -1467,37 +1581,60 @@ var WithLoggerBuilder = class {
 };
 
 // src/test/log_collector.ts
-var LogWriter2 = class {
-  constructor() {
-    this._bufferArr = [];
+var LogWriterCollector = class {
+  constructor(bufferArr) {
+    this._resolveClosed = new Future();
+    this.closed = this._resolveClosed.asPromise();
     this.desiredSize = null;
     this.ready = Promise.resolve(void 0);
-    this._resolveClosed = () => {
-    };
-    this.closed = new Promise((resolve) => {
-      this._resolveClosed = resolve;
-    });
+    this._bufferArr = bufferArr;
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
   abort(reason) {
     throw new Error("Method not implemented.");
   }
-  close() {
-    this._resolveClosed();
+  async close() {
+    await this.closed;
     return Promise.resolve(void 0);
   }
   releaseLock() {
   }
-  write(chunk) {
+  async write(chunk) {
     if (chunk) {
       this._bufferArr.push(chunk);
     }
     return Promise.resolve(void 0);
   }
 };
+var FanoutWriter = class {
+  constructor(writers) {
+    this.desiredSize = null;
+    this._writers = writers;
+    this.ready = Promise.all(this._writers.map((w) => w.ready)).then(() => void 0);
+    this.closed = Promise.all(this._writers.map((w) => w.closed)).then(() => void 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  abort(reason) {
+    return Promise.all(this._writers.map((w) => w.abort(reason))).then(() => {
+    });
+  }
+  close() {
+    return Promise.all(this._writers.map((w) => w.close())).then(() => {
+    });
+  }
+  releaseLock() {
+    this._writers.map((w) => w.releaseLock());
+  }
+  write(chunk) {
+    return Promise.all(this._writers.map((w) => w.write(chunk))).then(() => {
+    });
+  }
+};
 var LogCollector = class {
-  constructor() {
+  constructor(pass) {
     this.locked = false;
+    this._bufferArr = [];
+    this._pass = pass;
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   abort(reason) {
@@ -1513,7 +1650,11 @@ var LogCollector = class {
   }
   getWriter() {
     if (!this._writer) {
-      this._writer = new LogWriter2();
+      const dests = [new LogWriterCollector(this._bufferArr)];
+      if (this._pass) {
+        dests.push(this._pass);
+      }
+      this._writer = new FanoutWriter(dests);
     }
     return this._writer;
   }
@@ -1528,7 +1669,7 @@ var LogCollector = class {
           for (const x of res) {
             yield* __yieldStar(x);
           }
-        }(this._writer._bufferArr)
+        }(this._bufferArr)
       )
     );
     const splitStr = jsonNlStr.split("\n");
@@ -1540,7 +1681,7 @@ var LogCollector = class {
 
 // src/test/mock_logger.ts
 function MockLogger(params) {
-  const lc = new LogCollector();
+  const lc = new LogCollector(params == null ? void 0 : params.pass);
   let modNames = ["MockLogger"];
   if (typeof (params == null ? void 0 : params.moduleName) === "string") {
     modNames = [params == null ? void 0 : params.moduleName];
@@ -1683,29 +1824,6 @@ var None = class extends Option {
   }
 };
 
-// src/runtime.ts
-function isSet(value, ref = globalThis) {
-  const [head, ...tail] = value.split(".");
-  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
-    if (tail.length <= 1) {
-      return true;
-    }
-    return isSet(tail.join("."), ref[head]);
-  }
-  return false;
-}
-function runtimeFn() {
-  const isReactNative = isSet("navigator.product") && globalThis.navigator.product === "ReactNative";
-  const isNodeIsh = isSet("process.versions.node") && !isReactNative;
-  const isDeno = isSet("Deno") && !isReactNative;
-  return {
-    isNodeIsh,
-    isBrowser: !(isNodeIsh || isDeno) && !isReactNative,
-    isDeno,
-    isReactNative
-  };
-}
-
 // src/crypto.ts
 function randomBytes(size) {
   const bytes = new Uint8Array(size);
@@ -1732,6 +1850,7 @@ function toCryptoRuntime(cryptoOpts = {}) {
   BrowserEnvActions,
   BuildURI,
   EnvImpl,
+  FanoutWriter,
   Future,
   IDMode,
   IsLogger,
@@ -1742,7 +1861,8 @@ function toCryptoRuntime(cryptoOpts = {}) {
   LevelHandlerImpl,
   LogCollector,
   LogValue,
-  LogWriter,
+  LogWriterCollector,
+  LogWriterStream,
   LoggerImpl,
   MockLogger,
   None,