@adviser/cement 0.2.16 → 0.2.17

package/index.d.ts

@@ -1,5 +1,6 @@
 import { S as SysAbstraction } from './sys_abstraction-CmSCeK7b.js';
 export { B as BrowserEnvActions, D as Duration, e as Env, c as EnvActions, d as EnvFactoryOpts, g as EnvImpl, E as EnvMap, F as FileService, I as IDMode, N as NamedWritableStream, O as OnSetItem, R as RandomMode, a as String2TimeMode, b as SystemService, h as Time, T as TimeMode, i as TimeUnits, V as VoidFunc, f as envFactory } from './sys_abstraction-CmSCeK7b.js';
+import { WritableStreamDefaultWriter as WritableStreamDefaultWriter$1 } from 'stream/web';
 
 declare abstract class Result<T, E = Error> {
     static Ok<T>(t: T): Result<T, Error>;
@@ -164,7 +165,7 @@ declare class LevelHandlerImpl implements LevelHandler {
     setDebug(...modules: (string | string[])[]): void;
     isEnabled(ilevel: unknown, module: unknown): boolean;
 }
-declare class LogWriter$1 {
+declare class LogWriterStream {
     readonly _out: WritableStream<Uint8Array>;
     readonly _toFlush: (() => Promise<void>)[];
     constructor(out: WritableStream<Uint8Array>);
@@ -175,7 +176,7 @@ declare class LogWriter$1 {
 }
 interface LoggerImplParams {
     readonly out?: WritableStream<Uint8Array>;
-    readonly logWriter?: LogWriter$1;
+    readonly logWriter?: LogWriterStream;
     readonly sys?: SysAbstraction;
     readonly withAttributes?: LogSerializable;
     readonly levelHandler?: LevelHandler;
@@ -184,7 +185,7 @@ declare class LoggerImpl implements Logger {
     readonly _sys: SysAbstraction;
     readonly _attributes: LogSerializable;
     readonly _withAttributes: LogSerializable;
-    readonly _logWriter: LogWriter$1;
+    readonly _logWriter: LogWriterStream;
     readonly _levelHandler: LevelHandler;
     constructor(params?: LoggerImplParams);
     SetExposeStack(enable?: boolean): Logger;
@@ -220,24 +221,46 @@ declare class LoggerImpl implements Logger {
     Msg(...args: string[]): AsError;
 }
 
-declare class LogWriter implements WritableStreamDefaultWriter<Uint8Array> {
-    readonly _bufferArr: Uint8Array[];
-    _resolveClosed: (value?: PromiseLike<undefined>) => void;
-    closed: Promise<undefined>;
-    desiredSize: number | null;
-    ready: Promise<undefined>;
+declare class Future<T> {
+    #private;
     constructor();
+    asPromise(): Promise<T>;
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+}
+
+declare class LogWriterCollector implements WritableStreamDefaultWriter$1<Uint8Array> {
+    private readonly _bufferArr;
+    constructor(bufferArr: Uint8Array[]);
+    readonly _resolveClosed: Future<undefined>;
+    readonly closed: Promise<undefined>;
+    readonly desiredSize: number | null;
+    readonly ready: Promise<undefined>;
     abort(reason?: any): Promise<void>;
     close(): Promise<void>;
     releaseLock(): void;
     write(chunk?: Uint8Array): Promise<void>;
 }
+declare class FanoutWriter implements WritableStreamDefaultWriter$1<Uint8Array> {
+    readonly _writers: WritableStreamDefaultWriter$1<Uint8Array>[];
+    readonly ready: Promise<undefined>;
+    readonly closed: Promise<undefined>;
+    readonly desiredSize: number | null;
+    constructor(writers: WritableStreamDefaultWriter$1<Uint8Array>[]);
+    abort(reason?: any): Promise<void>;
+    close(): Promise<void>;
+    releaseLock(): void;
+    write(chunk?: Uint8Array | undefined): Promise<void>;
+}
 declare class LogCollector implements WritableStream<Uint8Array> {
     readonly locked: boolean;
-    _writer?: LogWriter;
+    private _writer?;
+    private readonly _pass?;
+    private readonly _bufferArr;
+    constructor(pass?: WritableStreamDefaultWriter$1<Uint8Array>);
     abort(reason?: Uint8Array): Promise<void>;
     close(): Promise<void>;
-    getWriter(): WritableStreamDefaultWriter<Uint8Array>;
+    getWriter(): WritableStreamDefaultWriter$1<Uint8Array>;
     Logs(): any[];
 }
 
@@ -247,6 +270,7 @@ interface MockLoggerReturn {
 }
 declare function MockLogger(params?: {
     readonly sys?: SysAbstraction;
+    readonly pass?: WritableStreamDefaultWriter<Uint8Array>;
     moduleName?: string | string[];
     readonly disableDebug?: boolean;
 }): MockLoggerReturn;
@@ -276,14 +300,6 @@ declare class None<T> extends Option<T> {
 }
 type WithoutOption<T> = T extends Option<infer U> ? U : T;
 
-declare class Future<T> {
-    #private;
-    constructor();
-    asPromise(): Promise<T>;
-    resolve(value: T): void;
-    reject(reason: unknown): void;
-}
-
 interface ResolveSeqItem<T, C> {
     readonly future: Future<T>;
     readonly fn: (c: C) => Promise<T>;
@@ -409,4 +425,4 @@ interface CryptoRuntime {
 }
 declare function toCryptoRuntime(cryptoOpts?: Partial<CryptoRuntime>): CryptoRuntime;
 
-export { type AsError, BuildURI, type CTAesKeyAlgorithm, type CTAlgorithm, type CTAlgorithmIdentifier, type CTArrayBufferView, type CTBufferSource, type CTCryptoKey, type CTEcKeyImportParams, type CTHmacImportParams, type CTJsonWebKey, type CTKeyFormat, type CTKeyType, type CTKeyUsage, type CTNamedCurve, type CTRsaHashedImportParams, type CoerceURI, type CryptoRuntime, type FnSerialized, Future, IsLogger, Keyed, KeyedResolvOnce, KeyedResolvSeq, type Lengthed, Level, type LevelHandler, LevelHandlerImpl, LogCollector, type LogSerializable, LogValue, LogWriter$1 as LogWriter, type Logger, LoggerImpl, type LoggerImplParams, type LoggerInterface, MockLogger, type MockLoggerReturn, None, Option, ResolveOnce, ResolveSeq, Result, ResultError, ResultOK, type Runtime, type Serialized, type SizeOrLength, type Sized, Some, SysAbstraction, URI, type WithLogger, type WithoutOption, type WithoutResult, asyncLogValue, isURL, logValue, removeSelfRef, runtimeFn, toCryptoRuntime };
+export { type AsError, BuildURI, type CTAesKeyAlgorithm, type CTAlgorithm, type CTAlgorithmIdentifier, type CTArrayBufferView, type CTBufferSource, type CTCryptoKey, type CTEcKeyImportParams, type CTHmacImportParams, type CTJsonWebKey, type CTKeyFormat, type CTKeyType, type CTKeyUsage, type CTNamedCurve, type CTRsaHashedImportParams, type CoerceURI, type CryptoRuntime, FanoutWriter, type FnSerialized, Future, IsLogger, Keyed, KeyedResolvOnce, KeyedResolvSeq, type Lengthed, Level, type LevelHandler, LevelHandlerImpl, LogCollector, type LogSerializable, LogValue, LogWriterCollector, LogWriterStream, type Logger, LoggerImpl, type LoggerImplParams, type LoggerInterface, MockLogger, type MockLoggerReturn, None, Option, ResolveOnce, ResolveSeq, Result, ResultError, ResultOK, type Runtime, type Serialized, type SizeOrLength, type Sized, Some, SysAbstraction, URI, type WithLogger, type WithoutOption, type WithoutResult, asyncLogValue, isURL, logValue, removeSelfRef, runtimeFn, toCryptoRuntime };

package/index.js

@@ -299,6 +299,29 @@ 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 {
@@ -377,7 +400,7 @@ var LevelHandlerImpl = class {
   }
 };
 var levelSingleton = new LevelHandlerImpl();
-var LogWriter = class {
+var LogWriterStream = class {
   constructor(out) {
     this._toFlush = [];
     this._flushIsRunning = false;
@@ -443,6 +466,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) {
@@ -459,9 +544,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) {
@@ -758,37 +854,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) {
@@ -804,7 +923,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;
   }
@@ -819,7 +942,7 @@ var LogCollector = class {
           for (const x of res) {
             yield* __yieldStar(x);
           }
-        }(this._writer._bufferArr)
+        }(this._bufferArr)
       )
     );
     const splitStr = jsonNlStr.split("\n");
@@ -831,7 +954,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];
@@ -974,29 +1097,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);
@@ -1022,6 +1122,7 @@ export {
   BrowserEnvActions,
   BuildURI,
   EnvImpl,
+  FanoutWriter,
   Future,
   IDMode,
   IsLogger,
@@ -1032,7 +1133,8 @@ export {
   LevelHandlerImpl,
   LogCollector,
   LogValue,
-  LogWriter,
+  LogWriterCollector,
+  LogWriterStream,
   LoggerImpl,
   MockLogger,
   None,