@adviser/cement 0.1.11 → 0.1.12

package/index.js

@@ -1,27 +1,612 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./file_service"), exports);
-__exportStar(require("./logger_impl"), exports);
-__exportStar(require("./logger"), exports);
-__exportStar(require("./sys_abstraction"), exports);
-__exportStar(require("./time"), exports);
-__exportStar(require("./test/log_collector"), exports);
-__exportStar(require("./test/mock_logger"), exports);
-__exportStar(require("./result"), exports);
-__exportStar(require("./option"), exports);
-__exportStar(require("./future"), exports);
+import {
+  WebSysAbstraction
+} from "./chunk-MWAFFTM4.js";
+import {
+  IDMode,
+  RandomMode,
+  String2TimeMode,
+  Time,
+  TimeMode,
+  TimeUnits
+} from "./chunk-PZTL4UNG.js";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadValues,
+  __yieldStar
+} from "./chunk-J2IM7FHM.js";
+
+// src/logger.ts
+var Level = /* @__PURE__ */ ((Level2) => {
+  Level2["WARN"] = "warn";
+  Level2["DEBUG"] = "debug";
+  Level2["INFO"] = "info";
+  Level2["ERROR"] = "error";
+  return Level2;
+})(Level || {});
+
+// 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, module) {
+    const level = ilevel;
+    if (module !== void 0) {
+      const levels = this._modules.get(module);
+      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 my = 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(my);
+    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 my = this._toFlush.shift();
+    my == null ? void 0 : my().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();
+export {
+  Future,
+  IDMode,
+  Level,
+  LevelHandlerImpl,
+  LogCollector,
+  LogWriter,
+  LoggerImpl,
+  MockLogger,
+  None,
+  Option,
+  RandomMode,
+  Result,
+  ResultError,
+  ResultOK,
+  Some,
+  String2TimeMode,
+  Time,
+  TimeMode,
+  TimeUnits
+};
 //# sourceMappingURL=index.js.map