@adviser/cement 0.1.10 → 0.1.12

package/index.cjs

@@ -0,0 +1,987 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Future: () => Future,
+  IDMode: () => IDMode,
+  Level: () => Level,
+  LevelHandlerImpl: () => LevelHandlerImpl,
+  LogCollector: () => LogCollector,
+  LogWriter: () => LogWriter,
+  LoggerImpl: () => LoggerImpl,
+  MockLogger: () => MockLogger,
+  None: () => None,
+  Option: () => Option,
+  RandomMode: () => RandomMode,
+  Result: () => Result,
+  ResultError: () => ResultError,
+  ResultOK: () => ResultOK,
+  Some: () => Some,
+  String2TimeMode: () => String2TimeMode,
+  Time: () => Time,
+  TimeMode: () => TimeMode,
+  TimeUnits: () => TimeUnits
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/logger.ts
+var Level = /* @__PURE__ */ ((Level2) => {
+  Level2["WARN"] = "warn";
+  Level2["DEBUG"] = "debug";
+  Level2["INFO"] = "info";
+  Level2["ERROR"] = "error";
+  return Level2;
+})(Level || {});
+
+// src/sys_abstraction.ts
+var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
+  TimeMode2["REAL"] = "real";
+  TimeMode2["CONST"] = "const";
+  TimeMode2["STEP"] = "step";
+  return TimeMode2;
+})(TimeMode || {});
+var RandomMode = /* @__PURE__ */ ((RandomMode2) => {
+  RandomMode2["CONST"] = "const";
+  RandomMode2["STEP"] = "step";
+  RandomMode2["RANDOM"] = "random";
+  return RandomMode2;
+})(RandomMode || {});
+var IDMode = /* @__PURE__ */ ((IDMode2) => {
+  IDMode2["UUID"] = "uuid";
+  IDMode2["CONST"] = "const";
+  IDMode2["STEP"] = "step";
+  return IDMode2;
+})(IDMode || {});
+function String2TimeMode(s) {
+  switch (s == null ? void 0 : s.toLowerCase()) {
+    case "real":
+      return "real" /* REAL */;
+    case "const":
+      return "const" /* CONST */;
+    case "step":
+      return "step" /* STEP */;
+    default:
+      return "real" /* REAL */;
+  }
+}
+
+// src/time.ts
+var Time = class {
+  TimeSince(start) {
+    const now = this.Now();
+    return now.getTime() - start.getTime();
+  }
+};
+var TimeUnits = /* @__PURE__ */ ((TimeUnits2) => {
+  TimeUnits2[TimeUnits2["Microsecond"] = 1] = "Microsecond";
+  TimeUnits2[TimeUnits2["Second"] = 1e3] = "Second";
+  TimeUnits2[TimeUnits2["Minute"] = 6e4] = "Minute";
+  TimeUnits2[TimeUnits2["Hour"] = 36e5] = "Hour";
+  return TimeUnits2;
+})(TimeUnits || {});
+
+// src/base_sys_abstraction.ts
+var SysTime = class extends Time {
+  Now() {
+    return /* @__PURE__ */ new Date();
+  }
+  Sleep(duration) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, duration);
+    });
+  }
+};
+var ConstTime = class extends Time {
+  Now() {
+    return new Date(2021, 1, 1, 0, 0, 0, 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Sleep(duration) {
+    return Promise.resolve();
+  }
+};
+var StepTime = class extends Time {
+  constructor() {
+    super();
+    this._step = new ConstTime().Now();
+  }
+  Now() {
+    if (this._step.getTime() === 0) {
+      this._step = new ConstTime().Now();
+      return this._step;
+    }
+    this._step = new Date(this._step.getTime() + 1e3);
+    return this._step;
+  }
+  Sleep(duration) {
+    this._step = new Date(this._step.getTime() + duration);
+    return Promise.resolve();
+  }
+};
+function TimeFactory(timeMode) {
+  switch (timeMode) {
+    case "real" /* REAL */:
+      return new SysTime();
+    case "const" /* CONST */:
+      return new ConstTime();
+    case "step" /* STEP */:
+      return new StepTime();
+  }
+  return new SysTime();
+}
+var RandomService = class {
+  constructor(mode) {
+    this._step = 0;
+    this._mode = mode;
+  }
+  Random0ToValue(value) {
+    switch (this._mode) {
+      case "const" /* CONST */:
+        return 0.5 * value;
+      case "step" /* STEP */:
+        this._step += 1e-4;
+        return this._step * value;
+      case "random" /* RANDOM */:
+        return Math.random() * value;
+      default:
+        throw new Error("Unknown RandomMode");
+    }
+  }
+};
+var IdService = class {
+  constructor(mode) {
+    this._step = 0;
+    if (!mode) {
+      mode = "uuid" /* UUID */;
+    }
+    this._mode = mode;
+  }
+  NextId() {
+    switch (this._mode) {
+      case "uuid" /* UUID */:
+        return crypto.randomUUID();
+      case "const" /* CONST */:
+        return "VeryUniqueID";
+      case "step" /* STEP */:
+        return `STEPId-${this._step++}`;
+      default:
+        throw new Error("Unknown IDMode");
+    }
+  }
+};
+var decoder = new TextDecoder();
+var BaseSysAbstraction = class {
+  constructor(params) {
+    this._time = new SysTime();
+    this._stdout = new WritableStream({
+      write(chunk) {
+        return new Promise((resolve) => {
+          const decoded = decoder.decode(chunk);
+          console.log(decoded.trimEnd());
+          resolve();
+        });
+      }
+    });
+    this._stderr = new WritableStream({
+      write(chunk) {
+        return new Promise((resolve) => {
+          const decoded = decoder.decode(chunk);
+          console.error(decoded.trimEnd());
+          resolve();
+        });
+      }
+    });
+    this._idService = new IdService();
+    this._randomService = new RandomService("random" /* RANDOM */);
+    this._fileSystem = params.FileSystem;
+    this._systemService = params.SystemService;
+  }
+};
+var WrapperSysAbstraction = class {
+  constructor(base, params) {
+    this._time = base._time;
+    this._stdout = base._stdout;
+    this._stderr = base._stderr;
+    this._idService = base._idService;
+    this._randomService = base._randomService;
+    this._fileSystem = base._fileSystem;
+    this._systemService = base._systemService;
+    if (params) {
+      if (params.TimeMode) {
+        this._time = TimeFactory(params.TimeMode);
+      }
+      if (params.Stdout) {
+        this._stdout = params.Stdout;
+      }
+      if (params.Stderr) {
+        this._stderr = params.Stderr;
+      }
+      if (params.IdMode) {
+        this._idService = new IdService(params.IdMode);
+      }
+      if (params.RandomMode) {
+        this._randomService = new RandomService(params.RandomMode);
+      }
+      if (params.FileSystem) {
+        this._fileSystem = params.FileSystem;
+      }
+      if (params.SystemService) {
+        this._systemService = params.SystemService;
+      }
+    }
+  }
+  Time() {
+    return this._time;
+  }
+  NextId() {
+    return this._idService.NextId();
+  }
+  Random0ToValue(value) {
+    return this._randomService.Random0ToValue(value);
+  }
+  Stdout() {
+    return this._stdout;
+  }
+  Stderr() {
+    return this._stderr;
+  }
+  System() {
+    return this._systemService;
+  }
+  FileSystem() {
+    return this._fileSystem;
+  }
+};
+
+// src/web/web_sys_abstraction.ts
+var WebFileService = class {
+  get baseDir() {
+    throw new Error("basedir-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  create(fname) {
+    throw new Error("create-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  readFileString(fname) {
+    throw new Error("readFileString-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  writeFileString(fname, content) {
+    throw new Error("writeFileString-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  abs(fname) {
+    throw new Error("abs-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  join(...paths) {
+    throw new Error("join-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  relative(from, to) {
+    throw new Error("relative-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  dirname(fname) {
+    throw new Error("dirname-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  basename(fname) {
+    throw new Error("basename-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  nodeImport(fname) {
+    throw new Error("nodeImport-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isAbsolute(fname) {
+    throw new Error("isAbsolute-Method not implemented.");
+  }
+};
+var WebSystemService = class {
+  Env() {
+    throw new Error("Env-Method not implemented.");
+  }
+  Args() {
+    throw new Error("Args-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  OnExit(hdl) {
+    throw new Error("OnExit-Method not implemented.");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Exit(code) {
+    throw new Error("Exit-Method not implemented.");
+  }
+};
+var my = void 0;
+function WebSysAbstraction(param) {
+  if (!my) {
+    my = new BaseSysAbstraction({
+      FileSystem: new WebFileService(),
+      SystemService: new WebSystemService()
+    });
+  }
+  return new WrapperSysAbstraction(my, param);
+}
+
+// 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();
+  }
+  enableLevel(level, ...modules) {
+    if (modules.length == 0) {
+      this._globalLevels.add(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, level]));
+      },
+      ...modules
+    );
+  }
+  disableLevel(level, ...modules) {
+    if (modules.length == 0) {
+      this._globalLevels.delete(level);
+      return;
+    }
+    this.forModules(
+      level,
+      (p) => {
+        this._modules.delete(p);
+      },
+      ...modules
+    );
+  }
+  forModules(level, fnAction, ...modules) {
+    for (const m of modules.flat()) {
+      const parts = m.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      for (const p of parts) {
+        fnAction(p);
+      }
+    }
+  }
+  setDebug(...modules) {
+    this.forModules(
+      "debug" /* DEBUG */,
+      (p) => {
+        this._modules.set(p, /* @__PURE__ */ new Set([...this._globalLevels, "debug" /* DEBUG */]));
+      },
+      ...modules
+    );
+  }
+  isEnabled(ilevel, module2) {
+    const level = ilevel;
+    if (module2 !== void 0) {
+      const levels = this._modules.get(module2);
+      if (levels && levels.has(level)) {
+        return true;
+      }
+    }
+    if (level === void 0) {
+      return true;
+    }
+    return this._globalLevels.has(level);
+  }
+};
+var levelSingleton = new LevelHandlerImpl();
+var LogWriter = class {
+  constructor(out) {
+    this._toFlush = [];
+    this._flushIsRunning = false;
+    this._flushDoneFns = Array();
+    this._out = out;
+  }
+  write(encoded) {
+    const my2 = async () => {
+      try {
+        const writer = this._out.getWriter();
+        await writer.ready;
+        await writer.write(encoded);
+        await writer.releaseLock();
+      } catch (err) {
+        console.error("Chunk error:", err);
+      }
+    };
+    this._toFlush.push(my2);
+    this._flush();
+  }
+  _flush(toFlush = void 0, done) {
+    if (done) {
+      this._flushDoneFns.push(done);
+    }
+    if (this._toFlush.length == 0) {
+      this._flushIsRunning = false;
+      this._flushDoneFns.forEach((fn) => fn());
+      this._flushDoneFns = [];
+      return;
+    }
+    if (!toFlush && this._toFlush.length == 1 && !this._flushIsRunning) {
+      this._flushIsRunning = true;
+    } else if (!toFlush) {
+      return;
+    }
+    const my2 = this._toFlush.shift();
+    my2 == null ? void 0 : my2().finally(() => {
+      this._flush(this._toFlush);
+    });
+  }
+};
+var LoggerImpl = class _LoggerImpl {
+  // readonly _id: string = "logger-" + Math.random().toString(36)
+  constructor(params) {
+    this._attributes = {};
+    if (!params) {
+      params = {};
+    }
+    if (!params.sys) {
+      this._sys = WebSysAbstraction();
+    } else {
+      this._sys = params.sys;
+    }
+    if (params.logWriter) {
+      this._logWriter = params.logWriter;
+    } else {
+      if (!params.out) {
+        this._logWriter = new LogWriter(this._sys.Stdout());
+      } else {
+        this._logWriter = new LogWriter(params.out);
+      }
+    }
+    if (!params.withAttributes) {
+      this._withAttributes = {};
+    } else {
+      this._withAttributes = __spreadValues({}, params.withAttributes);
+    }
+    this._attributes = __spreadValues({}, this._withAttributes);
+    if (params.levelHandler) {
+      this._levelHandler = params.levelHandler;
+    } else {
+      this._levelHandler = levelSingleton;
+    }
+  }
+  EnableLevel(level, ...modules) {
+    this._levelHandler.enableLevel(level, ...modules);
+    return this;
+  }
+  DisableLevel(level, ...modules) {
+    this._levelHandler.disableLevel(level, ...modules);
+    return this;
+  }
+  Module(key) {
+    this._attributes["module"] = key;
+    this._withAttributes["module"] = key;
+    return this;
+  }
+  SetDebug(...modules) {
+    this._levelHandler.setDebug(...modules);
+    return this;
+  }
+  Timestamp() {
+    this._attributes["ts"] = this._sys.Time().Now().toISOString();
+    return this;
+  }
+  Warn() {
+    this._attributes["level"] = "warn" /* WARN */;
+    return this;
+  }
+  Log() {
+    return this;
+  }
+  Debug() {
+    this._attributes["level"] = "debug" /* DEBUG */;
+    return this;
+  }
+  Error() {
+    this._attributes["level"] = "error" /* ERROR */;
+    return this;
+  }
+  Info() {
+    this._attributes["level"] = "info" /* INFO */;
+    return this;
+  }
+  Err(err) {
+    if (err instanceof Error) {
+      this._attributes["error"] = err.message;
+    } else {
+      this._attributes["error"] = "" + err;
+    }
+    return this;
+  }
+  WithLevel(l) {
+    this._attributes["level"] = l;
+    return this;
+  }
+  Str(key, value) {
+    this._attributes[key] = value;
+    return this;
+  }
+  Any(key, value) {
+    this._attributes[key] = value;
+    return this;
+  }
+  Dur(key, nsec) {
+    this._attributes[key] = `${nsec}ms`;
+    return this;
+  }
+  Uint64(key, value) {
+    this._attributes[key] = value;
+    return this;
+  }
+  async Flush() {
+    return new Promise((resolve) => {
+      this._logWriter._flush(void 0, resolve);
+    });
+  }
+  With() {
+    return new WithLoggerBuilder(
+      new _LoggerImpl({
+        logWriter: this._logWriter,
+        sys: this._sys,
+        levelHandler: this._levelHandler,
+        withAttributes: __spreadValues({
+          module: this._attributes["module"]
+        }, this._withAttributes)
+      })
+    );
+  }
+  _resetAttributes(fn) {
+    const ret = fn();
+    Object.keys(this._attributes).forEach((key) => {
+      delete this._attributes[key];
+    });
+    Object.assign(this._attributes, this._withAttributes);
+    return ret;
+  }
+  Msg(...args) {
+    const error = this._resetAttributes(() => {
+      const doWrite = this._levelHandler.isEnabled(this._attributes["level"], this._attributes["module"]);
+      this._attributes["msg"] = args.join(" ");
+      if (typeof this._attributes["msg"] === "string" && !this._attributes["msg"].trim().length) {
+        delete this._attributes["msg"];
+      }
+      if (this._attributes["ts"] === "ETERNITY") {
+        this.Timestamp();
+      }
+      const str = JSON.stringify(this._attributes);
+      if (doWrite) {
+        const encoded = encoder.encode(str + "\n");
+        this._logWriter.write(encoded);
+      }
+      return new Error(str);
+    });
+    return {
+      AsError: () => error
+    };
+  }
+};
+var WithLoggerBuilder = class {
+  constructor(li) {
+    this._li = li;
+  }
+  Logger() {
+    Object.assign(this._li._withAttributes, this._li._attributes);
+    console.log(`Logger:${JSON.stringify([...this._li._levelHandler._globalLevels])}`);
+    return this._li;
+  }
+  EnableLevel(level, ...modules) {
+    this._li._levelHandler.enableLevel(level, ...modules);
+    return this;
+  }
+  DisableLevel(level, ...modules) {
+    this._li._levelHandler.enableLevel(level, ...modules);
+    return this;
+  }
+  Module(key) {
+    this._li.Module(key);
+    return this;
+  }
+  SetDebug(...modules) {
+    this._li.SetDebug(...modules);
+    return this;
+  }
+  Str(key, value) {
+    this._li.Str(key, value);
+    return this;
+  }
+  Log() {
+    this._li.Log();
+    return this;
+  }
+  WithLevel(level) {
+    this._li.WithLevel(level);
+    return this;
+  }
+  Error() {
+    this._li.Error();
+    return this;
+  }
+  Warn() {
+    this._li.Error();
+    return this;
+  }
+  Debug() {
+    this._li.Debug();
+    return this;
+  }
+  Err(err) {
+    this._li.Err(err);
+    return this;
+  }
+  Info() {
+    this._li.Info();
+    return this;
+  }
+  Timestamp() {
+    this._li._attributes["ts"] = "ETERNITY";
+    return this;
+  }
+  Any(key, value) {
+    this._li.Any(key, value);
+    return this;
+  }
+  Dur(key, nsec) {
+    this._li.Dur(key, nsec);
+    return this;
+  }
+  Uint64(key, value) {
+    this._li.Uint64(key, value);
+    return this;
+  }
+};
+
+// src/test/log_collector.ts
+var LogWriter2 = class {
+  constructor() {
+    this._bufferArr = [];
+    this.desiredSize = null;
+    this.ready = Promise.resolve(void 0);
+    this._resolveClosed = () => {
+    };
+    this.closed = new Promise((resolve) => {
+      this._resolveClosed = resolve;
+    });
+  }
+  // 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();
+    return Promise.resolve(void 0);
+  }
+  releaseLock() {
+  }
+  write(chunk) {
+    chunk && this._bufferArr.push(chunk);
+    return Promise.resolve(void 0);
+  }
+};
+var LogCollector = class {
+  constructor() {
+    this.locked = false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  abort(reason) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+    if (this._writer) {
+      const ret = await this._writer.close();
+      this._writer = void 0;
+      return ret;
+    }
+    return Promise.resolve(void 0);
+  }
+  getWriter() {
+    if (!this._writer) {
+      this._writer = new LogWriter2();
+    }
+    return this._writer;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Logs() {
+    if (!this._writer) {
+      return [];
+    }
+    const jsonNlStr = new TextDecoder().decode(
+      new Uint8Array(
+        function* (res) {
+          for (const x of res) {
+            yield* __yieldStar(x);
+          }
+        }(this._writer._bufferArr)
+      )
+    );
+    const splitStr = jsonNlStr.split("\n");
+    const filterStr = splitStr.filter((a) => a.length);
+    const mapStr = filterStr.map((a) => JSON.parse(a));
+    return mapStr;
+  }
+};
+
+// src/test/mock_logger.ts
+function MockLogger(params) {
+  const lc = new LogCollector();
+  let modNames = ["MockLogger"];
+  if (typeof (params == null ? void 0 : params.moduleName) === "string") {
+    modNames = [params == null ? void 0 : params.moduleName];
+  } else if (Array.isArray(params == null ? void 0 : params.moduleName)) {
+    modNames = [...params.moduleName, ...modNames];
+  }
+  const logger = new LoggerImpl({
+    out: lc,
+    sys: params == null ? void 0 : params.sys,
+    levelHandler: new LevelHandlerImpl()
+  }).With().Module(modNames[0]).Logger();
+  !(params == null ? void 0 : params.disableDebug) && logger.SetDebug(...modNames);
+  return {
+    logCollector: lc,
+    logger
+  };
+}
+
+// src/result.ts
+var Result = class _Result {
+  static Ok(t) {
+    return new ResultOK(t);
+  }
+  static Err(t) {
+    if (typeof t === "string") {
+      return new ResultError(new Error(t));
+    }
+    return new ResultError(t);
+  }
+  static Is(t) {
+    return t instanceof _Result;
+  }
+  isOk() {
+    return this.is_ok();
+  }
+  isErr() {
+    return this.is_err();
+  }
+  Ok() {
+    return this.unwrap();
+  }
+  Err() {
+    return this.unwrap_err();
+  }
+};
+var ResultOK = class extends Result {
+  constructor(t) {
+    super();
+    this._t = t;
+  }
+  is_ok() {
+    return true;
+  }
+  is_err() {
+    return false;
+  }
+  unwrap_err() {
+    throw new Error("Result is Ok");
+  }
+  unwrap() {
+    return this._t;
+  }
+};
+var ResultError = class extends Result {
+  constructor(t) {
+    super();
+    this._error = t;
+  }
+  is_ok() {
+    return false;
+  }
+  is_err() {
+    return true;
+  }
+  unwrap() {
+    throw new Error(`Result is Err: ${this._error}`);
+  }
+  unwrap_err() {
+    return this._error;
+  }
+};
+
+// src/option.ts
+var Option = class _Option {
+  static Some(t) {
+    return new Some(t);
+  }
+  static None() {
+    return new None();
+  }
+  static Is(t) {
+    return t instanceof _Option;
+  }
+  IsNone() {
+    return this.is_none();
+  }
+  IsSome() {
+    return this.is_some();
+  }
+  Unwrap() {
+    return this.unwrap();
+  }
+};
+var Some = class extends Option {
+  constructor(_t) {
+    super();
+    this._t = _t;
+  }
+  is_none() {
+    return false;
+  }
+  is_some() {
+    return true;
+  }
+  unwrap() {
+    return this._t;
+  }
+};
+var None = class extends Option {
+  is_none() {
+    return true;
+  }
+  is_some() {
+    return false;
+  }
+  unwrap() {
+    throw new Error("None.unwrap");
+  }
+};
+
+// src/future.ts
+var _promise, _resolveFn, _rejectFn;
+var Future = class {
+  constructor() {
+    __privateAdd(this, _promise);
+    __privateAdd(this, _resolveFn, () => {
+      throw new Error("This Promise is not working as expected.");
+    });
+    __privateAdd(this, _rejectFn, () => {
+      throw new Error("This Promise is not working as expected.");
+    });
+    __privateSet(this, _promise, new Promise((resolve, reject) => {
+      __privateSet(this, _resolveFn, resolve);
+      __privateSet(this, _rejectFn, reject);
+    }));
+  }
+  async asPromise() {
+    return __privateGet(this, _promise);
+  }
+  resolve(value) {
+    __privateGet(this, _resolveFn).call(this, value);
+  }
+  reject(reason) {
+    __privateGet(this, _rejectFn).call(this, reason);
+  }
+};
+_promise = new WeakMap();
+_resolveFn = new WeakMap();
+_rejectFn = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Future,
+  IDMode,
+  Level,
+  LevelHandlerImpl,
+  LogCollector,
+  LogWriter,
+  LoggerImpl,
+  MockLogger,
+  None,
+  Option,
+  RandomMode,
+  Result,
+  ResultError,
+  ResultOK,
+  Some,
+  String2TimeMode,
+  Time,
+  TimeMode,
+  TimeUnits
+});
+//# sourceMappingURL=index.cjs.map