@adviser/cement 0.2.16 → 0.2.18

package/index.cjs

@@ -74,11 +74,14 @@ var __yieldStar = (value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BaseSysAbstraction: () => BaseSysAbstraction,
   BrowserEnvActions: () => BrowserEnvActions,
   BuildURI: () => BuildURI,
+  ConstTime: () => ConstTime,
   EnvImpl: () => EnvImpl,
   Future: () => Future,
   IDMode: () => IDMode,
+  IdService: () => IdService,
   IsLogger: () => IsLogger,
   Keyed: () => Keyed,
   KeyedResolvOnce: () => KeyedResolvOnce,
@@ -87,30 +90,37 @@ __export(src_exports, {
   LevelHandlerImpl: () => LevelHandlerImpl,
   LogCollector: () => LogCollector,
   LogValue: () => LogValue,
-  LogWriter: () => LogWriter,
+  LogWriteStream: () => LogWriteStream,
+  LogWriterStream: () => LogWriterStream,
   LoggerImpl: () => LoggerImpl,
   MockLogger: () => MockLogger,
   None: () => None,
   Option: () => Option,
   RandomMode: () => RandomMode,
+  RandomService: () => RandomService,
   ResolveOnce: () => ResolveOnce,
   ResolveSeq: () => ResolveSeq,
   Result: () => Result,
   ResultError: () => ResultError,
   ResultOK: () => ResultOK,
   Some: () => Some,
+  StepTime: () => StepTime,
   String2TimeMode: () => String2TimeMode,
+  SysTime: () => SysTime,
   Time: () => Time,
+  TimeFactory: () => TimeFactory,
   TimeMode: () => TimeMode,
   TimeUnits: () => TimeUnits,
   URI: () => URI,
+  WrapperSysAbstraction: () => WrapperSysAbstraction,
   asyncLogValue: () => asyncLogValue,
   envFactory: () => envFactory,
   isURL: () => isURL,
   logValue: () => logValue,
   removeSelfRef: () => removeSelfRef,
   runtimeFn: () => runtimeFn,
-  toCryptoRuntime: () => toCryptoRuntime
+  toCryptoRuntime: () => toCryptoRuntime,
+  utils: () => utils_exports
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -195,7 +205,7 @@ function IsLogger(obj) {
   ].map((fn) => typeof obj[fn] === "function").reduce((a, b) => a && b, true);
 }
 
-// src/sys_abstraction.ts
+// src/sys-abstraction.ts
 var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
   TimeMode2["REAL"] = "real";
   TimeMode2["CONST"] = "const";
@@ -242,7 +252,7 @@ var TimeUnits = /* @__PURE__ */ ((TimeUnits2) => {
   return TimeUnits2;
 })(TimeUnits || {});
 
-// src/base_sys_abstraction.ts
+// src/base-sys-abstraction.ts
 var SysTime = class extends Time {
   Now() {
     return /* @__PURE__ */ new Date();
@@ -586,7 +596,7 @@ var KeyedResolvSeq = class extends Keyed {
   }
 };
 
-// src/sys_env.ts
+// src/sys-env.ts
 var _node;
 var NodeEnvActions = class {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
@@ -756,7 +766,7 @@ var EnvImpl = class {
   }
 };
 
-// src/web/web_sys_abstraction.ts
+// src/web/web-sys-abstraction.ts
 var WebFileService = class {
   get baseDir() {
     throw new Error("basedir-Method not implemented.");
@@ -1024,7 +1034,94 @@ var URI = class _URI {
   }
 };
 
-// src/logger_impl.ts
+// 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/utils/console-write-stream.ts
+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;
+  }
+};
+
+// src/logger-impl.ts
 var encoder = new TextEncoder();
 var LevelHandlerImpl = class {
   constructor() {
@@ -1102,7 +1199,7 @@ var LevelHandlerImpl = class {
   }
 };
 var levelSingleton = new LevelHandlerImpl();
-var LogWriter = class {
+var LogWriterStream = class {
   constructor(out) {
     this._toFlush = [];
     this._flushIsRunning = false;
@@ -1184,9 +1281,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) {
@@ -1482,29 +1590,52 @@ var WithLoggerBuilder = class {
   }
 };
 
-// src/test/log_collector.ts
-var LogWriter2 = class {
-  constructor() {
-    this._bufferArr = [];
+// src/utils/fanout-write-stream.ts
+var FanoutWriteStream = class {
+  constructor(writers) {
     this.desiredSize = null;
-    this.ready = Promise.resolve(void 0);
-    this._resolveClosed = () => {
-    };
-    this.closed = new Promise((resolve) => {
-      this._resolveClosed = resolve;
+    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(() => {
+    });
+  }
+};
+
+// src/test/log-write-stream.ts
+var LogWriteStream = class {
+  constructor(bufferArr) {
+    this._resolveClosed = new Future();
+    this.closed = this._resolveClosed.asPromise();
+    this.desiredSize = null;
+    this.ready = Promise.resolve(void 0);
+    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);
     }
@@ -1512,8 +1643,10 @@ var LogWriter2 = class {
   }
 };
 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) {
@@ -1529,7 +1662,11 @@ var LogCollector = class {
   }
   getWriter() {
     if (!this._writer) {
-      this._writer = new LogWriter2();
+      const dests = [new LogWriteStream(this._bufferArr)];
+      if (this._pass) {
+        dests.push(this._pass);
+      }
+      this._writer = new FanoutWriteStream(dests);
     }
     return this._writer;
   }
@@ -1544,7 +1681,7 @@ var LogCollector = class {
           for (const x of res) {
             yield* __yieldStar(x);
           }
-        }(this._writer._bufferArr)
+        }(this._bufferArr)
       )
     );
     const splitStr = jsonNlStr.split("\n");
@@ -1554,9 +1691,9 @@ var LogCollector = class {
   }
 };
 
-// src/test/mock_logger.ts
+// 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];
@@ -1699,29 +1836,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);
@@ -1743,13 +1857,256 @@ function toCryptoRuntime(cryptoOpts = {}) {
   };
   return runtime;
 }
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  ConsoleWriterStream: () => ConsoleWriterStream,
+  ConsoleWriterStreamDefaultWriter: () => ConsoleWriterStreamDefaultWriter,
+  FanoutWriteStream: () => FanoutWriteStream,
+  array2stream: () => array2stream,
+  devnull: () => devnull,
+  rebuffer: () => rebuffer,
+  rebufferArray: () => rebufferArray,
+  receiveFromStream: () => receiveFromStream,
+  sendToStream: () => sendToStream,
+  stream2array: () => stream2array,
+  stream2string: () => stream2string,
+  stream2uint8array: () => stream2uint8array,
+  streamMap: () => streamMap,
+  string2stream: () => string2stream,
+  uint8array2stream: () => uint8array2stream
+});
+
+// src/utils/stream-map.ts
+function streamMap(s, sm) {
+  const state = { reader: s.getReader(), streamMap: sm, idx: 0 };
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await state.reader.read();
+      if (done) {
+        if (state.streamMap.Close) {
+          state.streamMap.Close();
+        }
+        controller.close();
+        return;
+      }
+      const promiseOrU = state.streamMap.Map(value, state.idx++);
+      let mapped;
+      if (promiseOrU instanceof Promise || typeof promiseOrU.then === "function") {
+        mapped = await promiseOrU;
+      } else {
+        mapped = promiseOrU;
+      }
+      controller.enqueue(mapped);
+    }
+  });
+}
+async function devnull(a) {
+  const reader = a.getReader();
+  let cnt = 0;
+  while (true) {
+    const { done } = await reader.read();
+    if (done) {
+      break;
+    }
+    cnt++;
+  }
+  return cnt;
+}
+function array2stream(a) {
+  let i = 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (i >= a.length) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(a[i]);
+      i++;
+    }
+  });
+}
+async function stream2array(a) {
+  const ret = [];
+  const reader = a.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    ret.push(value);
+  }
+  return ret;
+}
+
+// src/utils/rebuffer.ts
+async function rebufferArray(a, chunkSize) {
+  return stream2array(rebuffer(array2stream(a), chunkSize));
+}
+function reChunk(cs, chunkSize) {
+  const len = cs.reduce((acc, v) => acc + v.length, 0);
+  const last = cs[cs.length - 1];
+  const lastOfs = len - last.length;
+  const rest = last.subarray(chunkSize - lastOfs);
+  cs[cs.length - 1] = last.subarray(0, chunkSize - lastOfs);
+  const chunk = new Uint8Array(chunkSize);
+  let ofs = 0;
+  for (const c of cs) {
+    chunk.set(c, ofs);
+    ofs += c.length;
+  }
+  return { rest, chunk };
+}
+function pump(ps, controller, next) {
+  ps.reader.read().then(({ done, value }) => {
+    if (done) {
+      if (ps.tmpLen > 0) {
+        controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+      }
+      controller.close();
+      next();
+      return;
+    }
+    if (ps.tmpLen + value.length > ps.chunkSize) {
+      ps.tmp.push(value);
+      const res = reChunk(ps.tmp, ps.chunkSize);
+      controller.enqueue(res.chunk);
+      ps.tmp = [res.rest];
+      ps.tmpLen = res.rest.length;
+      next();
+      return;
+    } else if (value.length) {
+      ps.tmp.push(value);
+      ps.tmpLen += value.length;
+    }
+    pump(ps, controller, next);
+  });
+}
+function rebuffer(a, chunkSize) {
+  const state = {
+    reader: a.getReader(),
+    tmp: [],
+    tmpLen: 0,
+    chunkSize
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      return new Promise((resolve) => {
+        pump(state, controller, resolve);
+      });
+    }
+  });
+}
+
+// src/utils/stream2string.ts
+async function stream2string(stream, maxSize) {
+  if (!stream) {
+    return Promise.resolve("");
+  }
+  const reader = stream.getReader();
+  let res = "";
+  const decoder2 = new TextDecoder();
+  let rSize = 0;
+  while (typeof maxSize === "undefined" || rSize < maxSize) {
+    try {
+      const read = await reader.read();
+      if (read.done) {
+        break;
+      }
+      if (maxSize && rSize + read.value.length > maxSize) {
+        read.value = read.value.slice(0, maxSize - rSize);
+      }
+      const block = decoder2.decode(read.value, { stream: true });
+      rSize += read.value.length;
+      res += block;
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  return Promise.resolve(res);
+}
+async function stream2uint8array(stream) {
+  if (!stream) {
+    return Promise.resolve(new Uint8Array());
+  }
+  const reader = stream.getReader();
+  let res = new Uint8Array();
+  while (1) {
+    try {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      res = new Uint8Array([...res, ...value]);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  return Promise.resolve(res);
+}
+
+// src/utils/stream-test-helper.ts
+async function receiveFromStream(reb, state) {
+  return new Promise((resolve) => {
+    let reBufferCalls = 0;
+    const reader = reb.getReader();
+    function pump2() {
+      reader.read().then(({ done, value }) => {
+        state.CollectorFn({ done, value, fillCalls: state.fillCalls, reBufferCalls });
+        reBufferCalls++;
+        if (done) {
+          resolve();
+          return;
+        }
+        pump2();
+      });
+    }
+    pump2();
+  });
+}
+async function sendToStream(reb, state) {
+  return new Promise((resolve) => {
+    const writer = reb.getWriter();
+    function pump2(i) {
+      if (i >= state.sendChunks) {
+        writer.close();
+        resolve();
+        return;
+      }
+      writer.ready.then(() => {
+        state.fillCalls++;
+        writer.write(new Uint8Array(Array(state.sendChunkSize).fill(i)));
+        pump2(i + 1);
+      });
+    }
+    pump2(0);
+  });
+}
+
+// src/utils/string2stream.ts
+function string2stream(str) {
+  const encoder2 = new TextEncoder();
+  return uint8array2stream(encoder2.encode(str));
+}
+function uint8array2stream(str) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(str);
+      controller.close();
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BaseSysAbstraction,
   BrowserEnvActions,
   BuildURI,
+  ConstTime,
   EnvImpl,
   Future,
   IDMode,
+  IdService,
   IsLogger,
   Keyed,
   KeyedResolvOnce,
@@ -1758,29 +2115,36 @@ function toCryptoRuntime(cryptoOpts = {}) {
   LevelHandlerImpl,
   LogCollector,
   LogValue,
-  LogWriter,
+  LogWriteStream,
+  LogWriterStream,
   LoggerImpl,
   MockLogger,
   None,
   Option,
   RandomMode,
+  RandomService,
   ResolveOnce,
   ResolveSeq,
   Result,
   ResultError,
   ResultOK,
   Some,
+  StepTime,
   String2TimeMode,
+  SysTime,
   Time,
+  TimeFactory,
   TimeMode,
   TimeUnits,
   URI,
+  WrapperSysAbstraction,
   asyncLogValue,
   envFactory,
   isURL,
   logValue,
   removeSelfRef,
   runtimeFn,
-  toCryptoRuntime
+  toCryptoRuntime,
+  utils
 });
 //# sourceMappingURL=index.cjs.map