@adviser/cement 0.2.17 → 0.2.18

package/index.cjs

@@ -74,12 +74,14 @@ var __yieldStar = (value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BaseSysAbstraction: () => BaseSysAbstraction,
   BrowserEnvActions: () => BrowserEnvActions,
   BuildURI: () => BuildURI,
+  ConstTime: () => ConstTime,
   EnvImpl: () => EnvImpl,
-  FanoutWriter: () => FanoutWriter,
   Future: () => Future,
   IDMode: () => IDMode,
+  IdService: () => IdService,
   IsLogger: () => IsLogger,
   Keyed: () => Keyed,
   KeyedResolvOnce: () => KeyedResolvOnce,
@@ -88,31 +90,37 @@ __export(src_exports, {
   LevelHandlerImpl: () => LevelHandlerImpl,
   LogCollector: () => LogCollector,
   LogValue: () => LogValue,
-  LogWriterCollector: () => LogWriterCollector,
+  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);
 
@@ -197,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";
@@ -244,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();
@@ -588,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
@@ -758,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.");
@@ -1049,7 +1057,71 @@ function runtimeFn() {
   };
 }
 
-// src/logger_impl.ts
+// 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() {
@@ -1193,68 +1265,6 @@ 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) {
@@ -1580,8 +1590,34 @@ var WithLoggerBuilder = class {
   }
 };
 
-// src/test/log_collector.ts
-var LogWriterCollector = class {
+// src/utils/fanout-write-stream.ts
+var FanoutWriteStream = 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(() => {
+    });
+  }
+};
+
+// src/test/log-write-stream.ts
+var LogWriteStream = class {
   constructor(bufferArr) {
     this._resolveClosed = new Future();
     this.closed = this._resolveClosed.asPromise();
@@ -1606,30 +1642,6 @@ var LogWriterCollector = class {
     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(pass) {
     this.locked = false;
@@ -1650,11 +1662,11 @@ var LogCollector = class {
   }
   getWriter() {
     if (!this._writer) {
-      const dests = [new LogWriterCollector(this._bufferArr)];
+      const dests = [new LogWriteStream(this._bufferArr)];
       if (this._pass) {
         dests.push(this._pass);
       }
-      this._writer = new FanoutWriter(dests);
+      this._writer = new FanoutWriteStream(dests);
     }
     return this._writer;
   }
@@ -1679,7 +1691,7 @@ var LogCollector = class {
   }
 };
 
-// src/test/mock_logger.ts
+// src/test/mock-logger.ts
 function MockLogger(params) {
   const lc = new LogCollector(params == null ? void 0 : params.pass);
   let modNames = ["MockLogger"];
@@ -1845,14 +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,
-  FanoutWriter,
   Future,
   IDMode,
+  IdService,
   IsLogger,
   Keyed,
   KeyedResolvOnce,
@@ -1861,30 +2115,36 @@ function toCryptoRuntime(cryptoOpts = {}) {
   LevelHandlerImpl,
   LogCollector,
   LogValue,
-  LogWriterCollector,
+  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