@adviser/cement 0.2.5 → 0.2.7

package/index.cjs

@@ -75,6 +75,7 @@ var __yieldStar = (value) => {
 var src_exports = {};
 __export(src_exports, {
   BrowserEnvActions: () => BrowserEnvActions,
+  BuildURI: () => BuildURI,
   EnvImpl: () => EnvImpl,
   Future: () => Future,
   IDMode: () => IDMode,
@@ -102,9 +103,13 @@ __export(src_exports, {
   Time: () => Time,
   TimeMode: () => TimeMode,
   TimeUnits: () => TimeUnits,
+  URI: () => URI,
+  asyncLogValue: () => asyncLogValue,
   envFactory: () => envFactory,
   logValue: () => logValue,
-  removeSelfRef: () => removeSelfRef
+  removeSelfRef: () => removeSelfRef,
+  runtimeFn: () => runtimeFn,
+  toCryptoRuntime: () => toCryptoRuntime
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -137,6 +142,9 @@ function removeSelfRef() {
     return value;
   };
 }
+function asyncLogValue(val) {
+  throw new Error("Not implemented");
+}
 function logValue(val) {
   switch (typeof val) {
     case "function":
@@ -927,6 +935,30 @@ var LogWriter = class {
     });
   }
 };
+function getLen(value) {
+  if (Array.isArray(value)) {
+    return logValue(() => value.length);
+  } else if (typeof value === "string") {
+    return logValue(() => value.length);
+  } else if (typeof value === "object" && value !== null) {
+    if (typeof value.size === "number") {
+      return logValue(() => value.size);
+    } else if (typeof value.length === "number") {
+      return logValue(() => value.length);
+    }
+    return logValue(() => Object.keys(value).length);
+  }
+  return logValue(() => -1);
+}
+function hash(value) {
+  return "not implemented";
+}
+function toLogValue(lop) {
+  if (lop && typeof lop.then === "function") {
+    throw new Error("async logValue Not implemented");
+  }
+  return lop;
+}
 var LoggerImpl = class _LoggerImpl {
   // readonly _id: string = "logger-" + Math.random().toString(36)
   constructor(params) {
@@ -1036,15 +1068,11 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Len(value, key = "len") {
-    if (Array.isArray(value)) {
-      this._attributes[key] = logValue(() => value.length);
-    } else if (typeof value === "string") {
-      this._attributes[key] = logValue(() => value.length);
-    } else if (typeof value === "object" && value !== null) {
-      this._attributes[key] = logValue(() => Object.keys(value).length);
-    } else {
-      this.Int(key, -1);
-    }
+    this._attributes[key] = getLen(value);
+    return this;
+  }
+  Hash(value, key = "hash") {
+    this._attributes[key] = asyncLogValue(async () => `${getLen(value).value()}:${await hash(value)}`);
     return this;
   }
   Url(url, key = "url") {
@@ -1102,7 +1130,7 @@ var LoggerImpl = class _LoggerImpl {
     if (typeof msg === "string" && !msg.trim().length) {
       delete attr["msg"];
     }
-    if (((_a = attr["ts"]) == null ? void 0 : _a.value()) === "ETERNITY") {
+    if (((_a = toLogValue(attr["ts"])) == null ? void 0 : _a.value()) === "ETERNITY") {
       this.Timestamp.call({
         _sys: this._sys,
         _attributes: attr
@@ -1113,7 +1141,10 @@ var LoggerImpl = class _LoggerImpl {
   Msg(...args) {
     const fnError = this._resetAttributes(() => {
       var _a, _b;
-      const doWrite = this._levelHandler.isEnabled((_a = this._attributes["level"]) == null ? void 0 : _a.value(), (_b = this._attributes["module"]) == null ? void 0 : _b.value());
+      const doWrite = this._levelHandler.isEnabled(
+        (_a = toLogValue(this._attributes["level"])) == null ? void 0 : _a.value(),
+        (_b = toLogValue(this._attributes["module"])) == null ? void 0 : _b.value()
+      );
       let fnRet = () => this._produceError(__spreadValues({}, this._attributes), ...args);
       if (doWrite) {
         const str = fnRet();
@@ -1160,6 +1191,10 @@ var WithLoggerBuilder = class {
     this._li.Len(value, key);
     return this;
   }
+  Hash(value, key) {
+    this._li.Hash(value, key);
+    return this;
+  }
   Ref(key, action) {
     this._li.Ref(key, action);
     return this;
@@ -1249,7 +1284,9 @@ var LogWriter2 = class {
   releaseLock() {
   }
   write(chunk) {
-    chunk && this._bufferArr.push(chunk);
+    if (chunk) {
+      this._bufferArr.push(chunk);
+    }
     return Promise.resolve(void 0);
   }
 };
@@ -1310,7 +1347,9 @@ function MockLogger(params) {
     sys: params == null ? void 0 : params.sys,
     levelHandler: new LevelHandlerImpl()
   }).With().Module(modNames[0]).Logger();
-  !(params == null ? void 0 : params.disableDebug) && logger.SetDebug(...modNames);
+  if (!(params == null ? void 0 : params.disableDebug)) {
+    logger.SetDebug(...modNames);
+  }
   return {
     logCollector: lc,
     logger
@@ -1438,9 +1477,198 @@ var None = class extends Option {
     throw new Error("None.unwrap");
   }
 };
+
+// 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 isNodeIsh = isSet("process.versions.node");
+  const isDeno = isSet("Deno");
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno),
+    isDeno,
+    isReactNative: false
+  };
+}
+
+// src/uri.ts
+function falsy2undef(value) {
+  return value === void 0 || value === null ? void 0 : value;
+}
+function ensureURLWithDefaultProto(url, defaultProtocol) {
+  if (!url) {
+    return new URL(`${defaultProtocol}//`);
+  }
+  if (typeof url === "string") {
+    try {
+      return new URL(url);
+    } catch (e) {
+      return new URL(`${defaultProtocol}//${url}`);
+    }
+  } else {
+    return url;
+  }
+}
+var BuildURI = class {
+  constructor(url) {
+    this._url = url;
+  }
+  hostname(h) {
+    this._url.hostname = h;
+    return this;
+  }
+  password(p) {
+    this._url.password = p;
+    return this;
+  }
+  port(p) {
+    this._url.port = p;
+    return this;
+  }
+  username(u) {
+    this._url.username = u;
+    return this;
+  }
+  search(s) {
+    this._url.search = s;
+    return this;
+  }
+  protocol(p) {
+    this._url.protocol = p;
+    return this;
+  }
+  pathname(p) {
+    this._url.pathname = p;
+    return this;
+  }
+  hash(h) {
+    this._url.hash = h;
+    return this;
+  }
+  host(h) {
+    this._url.host = h;
+    return this;
+  }
+  delParam(key) {
+    this._url.searchParams.delete(key);
+    return this;
+  }
+  setParam(key, str) {
+    this._url.searchParams.set(key, str);
+    return this;
+  }
+  toString() {
+    return this._url.toString();
+  }
+  build() {
+    return URI.from(this._url);
+  }
+};
+var URI = class _URI {
+  // if no protocol is provided, default to file:
+  static from(strURLUri, defaultProtocol = "file:") {
+    switch (typeof falsy2undef(strURLUri)) {
+      case "undefined":
+        return new _URI(new URL(`${defaultProtocol}//`));
+      case "string":
+        return new _URI(ensureURLWithDefaultProto(strURLUri, defaultProtocol));
+      case "object":
+        if (strURLUri instanceof _URI) {
+          return new _URI(new URL(strURLUri._url.toString()));
+        } else if (strURLUri instanceof URL) {
+          return new _URI(new URL(strURLUri.toString()));
+        }
+        throw new Error(`unknown object type: ${strURLUri}`);
+      default:
+        throw new Error(`Invalid argument: ${typeof strURLUri}`);
+    }
+  }
+  constructor(url) {
+    this._url = url;
+  }
+  build() {
+    return new BuildURI(this.asURL());
+  }
+  get hostname() {
+    return this._url.hostname;
+  }
+  get password() {
+    return this._url.password;
+  }
+  get port() {
+    return this._url.port;
+  }
+  get username() {
+    return this._url.username;
+  }
+  get search() {
+    return this._url.search;
+  }
+  get protocol() {
+    return this._url.protocol;
+  }
+  get pathname() {
+    return this._url.toString().replace(/^.*:\/\//, "").replace(/\?.*$/, "");
+  }
+  get hash() {
+    return this._url.hash;
+  }
+  get host() {
+    return this._url.host;
+  }
+  hasParam(key) {
+    return this._url.searchParams.has(key);
+  }
+  getParam(key) {
+    return falsy2undef(this._url.searchParams.get(key));
+  }
+  clone() {
+    return new _URI(this.asURL());
+  }
+  asURL() {
+    const url = new URL(this._url.toString());
+    url.searchParams.sort();
+    return url;
+  }
+  toString() {
+    return this._url.toString();
+  }
+};
+
+// src/crypto.ts
+function randomBytes(size) {
+  const bytes = new Uint8Array(size);
+  if (size > 0) {
+    crypto.getRandomValues(bytes);
+  }
+  return bytes;
+}
+function digestSHA256(data) {
+  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
+}
+function toCryptoRuntime(cryptoOpts = {}) {
+  const runtime = {
+    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
+    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
+    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
+    randomBytes: cryptoOpts.randomBytes || randomBytes,
+    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256
+  };
+  return runtime;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BrowserEnvActions,
+  BuildURI,
   EnvImpl,
   Future,
   IDMode,
@@ -1468,8 +1696,12 @@ var None = class extends Option {
   Time,
   TimeMode,
   TimeUnits,
+  URI,
+  asyncLogValue,
   envFactory,
   logValue,
-  removeSelfRef
+  removeSelfRef,
+  runtimeFn,
+  toCryptoRuntime
 });
 //# sourceMappingURL=index.cjs.map