@adviser/cement 0.2.30 → 0.2.32

package/index.cjs

@@ -140,14 +140,13 @@ __export(src_exports, {
   bin2text: () => bin2text,
   envFactory: () => envFactory,
   exception2Result: () => exception2Result,
+  hasHostPartProtocols: () => hasHostPartProtocols,
   isURL: () => isURL,
   logValue: () => logValue,
-  protocols: () => protocols,
   removeSelfRef: () => removeSelfRef,
   runtimeFn: () => runtimeFn,
   toCryptoRuntime: () => toCryptoRuntime,
-  utils: () => utils_exports,
-  wrapRefcounted: () => wrapRefcounted
+  utils: () => utils_exports
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -1052,6 +1051,61 @@ function exception2Result(fn) {
   }
 }
 
+// src/utils/stripper.ts
+function stripper(strip, obj) {
+  const strips = Array.isArray(strip) ? strip : [strip];
+  const restrips = strips.map((s) => {
+    if (typeof s === "string") {
+      const escaped = s.replace(/[-\\[\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\^\\$\\|]/g, "\\$&");
+      return new RegExp(`^${escaped}$`);
+    }
+    return s;
+  });
+  return localStripper(void 0, restrips, obj);
+}
+function localStripper(path, restrips, obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  const ret = __spreadValues({}, obj);
+  const matcher = (key, nextPath) => {
+    for (const re of restrips) {
+      if (re.test(key) || re.test(nextPath)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  for (const key in ret) {
+    if (Object.prototype.hasOwnProperty.call(ret, key)) {
+      let nextPath;
+      if (path) {
+        nextPath = [path, key].join(".");
+      } else {
+        nextPath = key;
+      }
+      if (matcher(key, nextPath)) {
+        delete ret[key];
+        continue;
+      }
+      if (typeof ret[key] === "object") {
+        if (Array.isArray(ret[key])) {
+          ret[key] = ret[key].reduce((acc, v, i) => {
+            const toDelete = matcher(key, `${nextPath}[${i}]`);
+            if (!toDelete) {
+              acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
+            }
+            return acc;
+          }, []);
+        } else {
+          ret[key] = localStripper(nextPath, restrips, ret[key]);
+        }
+      }
+    }
+  }
+  return ret;
+}
+
 // src/uri.ts
 function falsy2undef(value) {
   return value === void 0 || value === null ? void 0 : value;
@@ -1077,7 +1131,7 @@ var MutableURL = class _MutableURL extends URL {
   constructor(urlStr) {
     super("defect://does.not.exist");
     const partedURL = urlStr.split(":");
-    this._hasHostpart = protocols.has(partedURL[0]);
+    this._hasHostpart = hasHostPartProtocols.has(partedURL[0]);
     let hostPartUrl = ["http", ...partedURL.slice(1)].join(":");
     if (!this._hasHostpart) {
       const pathname = hostPartUrl.replace(/http:\/\/[/]*/, "").replace(/[#?].*$/, "");
@@ -1104,32 +1158,32 @@ var MutableURL = class _MutableURL extends URL {
   get host() {
     if (!this._hasHostpart) {
       throw new Error(
-        `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(protocols.keys()))}`
+        `you can use hostname only if protocol is ${this.toString()} ${JSON.stringify(Array.from(hasHostPartProtocols.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()))}`);
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.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()))}`);
+      throw new Error(`you can use port only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
     }
     this._sysURL.port = p;
   }
   get hostname() {
     if (!this._hasHostpart) {
-      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
     }
     return this._sysURL.hostname;
   }
   set hostname(h) {
     if (!this._hasHostpart) {
-      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(protocols.keys()))}`);
+      throw new Error(`you can use hostname only if protocol is ${JSON.stringify(Array.from(hasHostPartProtocols.keys()))}`);
     }
     this._sysURL.hostname = h;
   }
@@ -1190,6 +1244,35 @@ function from(fac, strURLUri, defaultProtocol) {
       throw new Error(`Invalid argument: ${typeof strURLUri}`);
   }
 }
+function getParamResult(key, val, msgFn = (key2) => {
+  return `missing parameter: ${key2}`;
+}) {
+  if (val === void 0) {
+    return Result.Err(msgFn(key));
+  }
+  return Result.Ok(val);
+}
+function getParamsResult(keys, getParam) {
+  const keyStrs = keys.flat().filter((k) => typeof k === "string");
+  const msgFn = keys.find((k) => typeof k === "function") || ((...keys2) => {
+    const msg = keys2.join(",");
+    return `missing parameters: ${msg}`;
+  });
+  const errors = [];
+  const result = {};
+  for (const key of keyStrs) {
+    const val = getParam.getParam(key);
+    if (val === void 0) {
+      errors.push(key);
+    } else {
+      result[key] = val;
+    }
+  }
+  if (errors.length) {
+    return Result.Err(msgFn(...errors));
+  }
+  return Result.Ok(result);
+}
 var BuildURI = class _BuildURI {
   // pathname needs this
   constructor(url) {
@@ -1241,6 +1324,20 @@ var BuildURI = class _BuildURI {
   //   this._url.host = h;
   //   return this;
   // }
+  appendRelative(p) {
+    const url = URI.from(p);
+    let pathname = url.pathname;
+    if (url.pathname === "/") {
+      pathname = "";
+    } else if (!pathname.startsWith("/")) {
+      pathname = `/${pathname}`;
+    }
+    this.pathname(this._url.pathname + pathname);
+    for (const [key, value] of url.getParams) {
+      this.setParam(key, value);
+    }
+    return this;
+  }
   delParam(key) {
     this._url.searchParams.delete(key);
     return this;
@@ -1261,6 +1358,12 @@ var BuildURI = class _BuildURI {
   getParam(key) {
     return falsy2undef(this._url.searchParams.get(key));
   }
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
+  }
+  getParamsResult(...keys) {
+    return getParamsResult(keys, this);
+  }
   toString() {
     this._url.searchParams.sort();
     return this._url.toString();
@@ -1268,17 +1371,20 @@ var BuildURI = class _BuildURI {
   toJSON() {
     return this.toString();
   }
+  asObj(...strips) {
+    return this.URI().asObj(...strips);
+  }
   URI() {
     return URI.from(this._url);
   }
 };
-var protocols = /* @__PURE__ */ new Set(["http", "https", "ws", "wss"]);
+var hasHostPartProtocols = /* @__PURE__ */ new Set(["http", "https", "ws", "wss"]);
 var URI = class _URI {
   static protocolHasHostpart(protocol) {
     protocol = protocol.replace(/:$/, "");
-    protocols.add(protocol);
+    hasHostPartProtocols.add(protocol);
     return () => {
-      protocols.delete(protocol);
+      hasHostPartProtocols.delete(protocol);
     };
   }
   // if no protocol is provided, default to file:
@@ -1350,6 +1456,9 @@ var URI = class _URI {
   getParam(key) {
     return falsy2undef(this._url.searchParams.get(key));
   }
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
+  }
   clone() {
     return new _URI(this._url);
   }
@@ -1362,6 +1471,22 @@ var URI = class _URI {
   toJSON() {
     return this.toString();
   }
+  asObj(...strips) {
+    const pathURI = {
+      style: "path",
+      protocol: this.protocol,
+      pathname: this.pathname,
+      searchParams: Object.fromEntries(this.getParams)
+    };
+    if (hasHostPartProtocols.has(this.protocol.replace(/:$/, ""))) {
+      return stripper(strips, __spreadProps(__spreadValues({}, pathURI), {
+        style: "host",
+        hostname: this.hostname,
+        port: this.port
+      }));
+    }
+    return stripper(strips, pathURI);
+  }
 };
 
 // src/runtime.ts
@@ -1853,8 +1978,10 @@ var LoggerImpl = class _LoggerImpl {
       }
       return fnRet;
     });
+    const asError = () => new Error(this._txtEnDe.decode(fnError()));
     return {
-      AsError: () => new Error(this._txtEnDe.decode(fnError()))
+      ResultError: () => Result.Err(asError()),
+      AsError: asError
     };
   }
 };
@@ -2330,26 +2457,6 @@ var VERSION = Object.keys({
   __packageVersion__: "xxxx"
 })[0];
 
-// src/refcounted.ts
-function wrapRefcounted(t, method) {
-  const my2 = t;
-  my2.__refcounted = (my2.__refcounted || 0) + 1;
-  if (my2.__refcounted === 1) {
-    my2.__unrefcounted = my2[method];
-    const mRec = my2;
-    mRec[method] = function() {
-      this.__refcounted--;
-      if (this.__refcounted === 0) {
-        this.__unrefcounted();
-      }
-      if (this.__refcounted < 0) {
-        throw new Error("already closed");
-      }
-    };
-  }
-  return t;
-}
-
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -2603,13 +2710,12 @@ function uint8array2stream(str) {
   bin2text,
   envFactory,
   exception2Result,
+  hasHostPartProtocols,
   isURL,
   logValue,
-  protocols,
   removeSelfRef,
   runtimeFn,
   toCryptoRuntime,
-  utils,
-  wrapRefcounted
+  utils
 });
 //# sourceMappingURL=index.cjs.map