@adviser/cement 0.2.21 → 0.2.23

package/index.cjs

@@ -116,8 +116,10 @@ __export(src_exports, {
   WrapperSysAbstraction: () => WrapperSysAbstraction,
   asyncLogValue: () => asyncLogValue,
   envFactory: () => envFactory,
+  exception2Result: () => exception2Result,
   isURL: () => isURL,
   logValue: () => logValue,
+  protocols: () => protocols,
   removeSelfRef: () => removeSelfRef,
   runtimeFn: () => runtimeFn,
   toCryptoRuntime: () => toCryptoRuntime,
@@ -842,6 +844,91 @@ function WebSysAbstraction(param) {
   return new WrapperSysAbstraction(my, param);
 }
 
+// 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) {
+    if (!t) {
+      return false;
+    }
+    if (t instanceof _Result) {
+      return true;
+    }
+    const rt = t;
+    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
+      return true;
+    }
+    return false;
+  }
+  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;
+  }
+};
+function exception2Result(fn) {
+  try {
+    const res = fn();
+    if (res instanceof Promise) {
+      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
+    }
+    return Result.Ok(res);
+  } catch (e) {
+    return Result.Err(e);
+  }
+}
+
 // src/uri.ts
 function falsy2undef(value) {
   return value === void 0 || value === null ? void 0 : value;
@@ -866,9 +953,21 @@ function isURL(value) {
 var MutableURL = class _MutableURL extends URL {
   constructor(urlStr) {
     super("defect://does.not.exist");
-    this._sysURL = new URL(urlStr);
-    this._protocol = this._sysURL.protocol;
-    this._hasHostpart = ["http:", "https:"].includes(this._protocol);
+    const partedURL = urlStr.split(":");
+    this._hasHostpart = protocols.has(partedURL[0]);
+    let hostPartUrl = ["http", ...partedURL.slice(1)].join(":");
+    if (!this._hasHostpart) {
+      const pathname = hostPartUrl.replace(/http:\/\/[/]*/, "").replace(/[#?].*$/, "");
+      hostPartUrl = hostPartUrl.replace(/http:\/\//, `http://localhost/${pathname}`);
+    }
+    try {
+      this._sysURL = new URL(hostPartUrl);
+    } catch (ie) {
+      const e = ie;
+      e.message = `${e.message} for URL: ${urlStr}`;
+      throw e;
+    }
+    this._protocol = `${partedURL[0]}:`;
     if (this._hasHostpart) {
       this._pathname = this._sysURL.pathname;
     } else {
@@ -879,15 +978,35 @@ var MutableURL = class _MutableURL extends URL {
   clone() {
     return new _MutableURL(this.toString());
   }
+  get host() {
+    if (!this._hasHostpart) {
+      throw new Error(
+        `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(protocols.keys()))}`
+      );
+    }
+    return this._sysURL.host;
+  }
+  get port() {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+    }
+    return this._sysURL.port;
+  }
+  set port(p) {
+    if (!this._hasHostpart) {
+      throw new Error(`you can use port only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+    }
+    this._sysURL.port = p;
+  }
   get hostname() {
     if (!this._hasHostpart) {
-      throw new Error("you can use hostname only if protocol is http or https");
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
     }
     return this._sysURL.hostname;
   }
   set hostname(h) {
     if (!this._hasHostpart) {
-      throw new Error("you can use hostname only if protocol is http or https");
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
     }
     this._sysURL.hostname = h;
   }
@@ -959,6 +1078,10 @@ var BuildURI = class _BuildURI {
   static from(strURLUri, defaultProtocol = "file:") {
     return from((url) => new _BuildURI(url), strURLUri, defaultProtocol);
   }
+  port(p) {
+    this._url.port = p;
+    return this;
+  }
   hostname(h) {
     this._url.hostname = h;
     return this;
@@ -1020,7 +1143,20 @@ var BuildURI = class _BuildURI {
     return URI.from(this._url);
   }
 };
+var protocols = /* @__PURE__ */ new Map([
+  ["http", true],
+  ["https", true],
+  ["ws", true],
+  ["wss", true]
+]);
 var URI = class _URI {
+  static protocolHasHostpart(protocol) {
+    protocol = protocol.replace(/:$/, "");
+    protocols.set(protocol, true);
+    return () => {
+      protocols.delete(protocol);
+    };
+  }
   // if no protocol is provided, default to file:
   static merge(into, from2, defaultProtocol = "file:") {
     const intoUrl = BuildURI.from(into, defaultProtocol);
@@ -1042,6 +1178,9 @@ var URI = class _URI {
   static from(strURLUri, defaultProtocol = "file:") {
     return from((url) => new _URI(url), strURLUri, defaultProtocol);
   }
+  static fromResult(strURLUri, defaultProtocol = "file:") {
+    return exception2Result(() => from((url) => new _URI(url), strURLUri, defaultProtocol));
+  }
   constructor(url) {
     this._url = url.clone();
   }
@@ -1054,9 +1193,12 @@ var URI = class _URI {
   // get password(): string {
   //   return this._url.password;
   // }
-  // get port(): string {
-  //   return this._url.port;
-  // }
+  get port() {
+    return this._url.port;
+  }
+  get host() {
+    return this._url.host;
+  }
   // get username(): string {
   //   return this._url.username;
   // }
@@ -1067,7 +1209,7 @@ var URI = class _URI {
     return this._url.protocol;
   }
   get pathname() {
-    return this._url.toString().replace(/^.*:\/\//, "").replace(/\?.*$/, "");
+    return this._url.pathname;
   }
   // get hash(): string {
   //   return this._url.hash;
@@ -1431,7 +1573,13 @@ var LoggerImpl = class _LoggerImpl {
   }
   Err(err) {
     var _a;
-    if (err instanceof Error) {
+    if (Result.Is(err)) {
+      if (err.isOk()) {
+        this.Result("noerror", err);
+      } else {
+        this.Result("error", err);
+      }
+    } else if (err instanceof Error) {
       this._attributes["error"] = logValue(err.message);
       if (this._levelHandler.isStackExposed) {
         this._attributes["stack"] = logValue((_a = err.stack) == null ? void 0 : _a.split("\n").map((s) => s.trim()));
@@ -1785,80 +1933,6 @@ function MockLogger(params) {
   };
 }
 
-// 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) {
-    if (!t) {
-      return false;
-    }
-    if (t instanceof _Result) {
-      return true;
-    }
-    const rt = t;
-    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
-      return true;
-    }
-    return false;
-  }
-  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) {
@@ -2212,8 +2286,10 @@ function uint8array2stream(str) {
   WrapperSysAbstraction,
   asyncLogValue,
   envFactory,
+  exception2Result,
   isURL,
   logValue,
+  protocols,
   removeSelfRef,
   runtimeFn,
   toCryptoRuntime,