@adviser/cement 0.3.1 → 0.3.3

package/index.cjs

@@ -38,10 +38,9 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var src_exports = {};
 __export(src_exports, {
   BaseSysAbstraction: () => BaseSysAbstraction,
-  BrowserEnvActions: () => BrowserEnvActions,
   BuildURI: () => BuildURI,
   ConstTime: () => ConstTime,
-  EnvImpl: () => EnvImpl,
+  EnvImpl: () => EnvImpl2,
   Future: () => Future,
   HeadersImpl: () => HeadersImpl,
   HttpHeader: () => HttpHeader,
@@ -200,11 +199,16 @@ function logValueInternal(val, ctx) {
           return logValueInternal(ret, ctx);
         }
       } catch (e) {
-        if (val.match(/[\n\r]/)) {
-          const lines = val.trimEnd().split(/[\n\r]/);
-          return new LogValue(() => lines);
+        try {
+          const url = new URL(val);
+          return new LogValue(() => url.toString());
+        } catch (e2) {
         }
       }
+      if (val.match(/[\n\r]/)) {
+        const lines = val.split(/[\n\r]+/).map((v) => v.trim());
+        return new LogValue(() => lines);
+      }
       return new LogValue(() => val.toString());
     }
     case "number":
@@ -344,9 +348,9 @@ var SysTime = class extends Time {
     return /* @__PURE__ */ new Date();
   }
   Sleep(duration) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       setTimeout(() => {
-        resolve();
+        resolve2();
       }, duration);
     });
   }
@@ -536,8 +540,8 @@ var Future = class {
     __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, _promise, new Promise((resolve2, reject) => {
+      __privateSet(this, _resolveFn, resolve2);
       __privateSet(this, _rejectFn, reject);
     }));
   }
@@ -699,53 +703,86 @@ var KeyedResolvSeq = class extends Keyed {
   }
 };
 
-// src/sys-env.ts
-var _node;
-var NodeEnvActions = class {
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
-  constructor(opts) {
-    __privateAdd(this, _node, globalThis);
-    this._env = this.active() ? __privateGet(this, _node).process.env : {};
-  }
-  register(env) {
-    return env;
-  }
-  active() {
-    return typeof __privateGet(this, _node) === "object" && typeof __privateGet(this, _node).process === "object" && typeof __privateGet(this, _node).process.env === "object";
+// 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]);
   }
-  keys() {
-    return Object.keys(this._env);
+  return false;
+}
+function runtimeFn() {
+  const gt = globalThis;
+  let isReactNative = isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative";
+  let isNodeIsh = false;
+  if (!isSet("Deno")) {
+    isNodeIsh = isSet("process.versions.node") && !isReactNative;
   }
-  get(key2) {
-    return this._env[key2];
+  let isDeno = isSet("Deno");
+  const isCFWorker = isSet("caches.default") && isSet("WebSocketPair");
+  if (isCFWorker) {
+    isDeno = false;
+    isNodeIsh = false;
+    isReactNative = false;
   }
-  set(key2, value) {
-    if (value) {
-      this._env[key2] = value;
-    }
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno || isCFWorker || isReactNative),
+    isDeno,
+    isReactNative,
+    isCFWorker
+  };
+}
+
+// src/txt-en-decoder.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var Utf8EnDecoder = class {
+  encode(str) {
+    return encoder.encode(str);
   }
-  delete(key2) {
-    delete this._env[key2];
+  decode(data) {
+    return decoder.decode(data);
   }
 };
-_node = new WeakMap();
+var utf8EnDecoder = new Utf8EnDecoder();
+function Utf8EnDecoderSingleton() {
+  return utf8EnDecoder;
+}
+
+// src/deno/deno-file-service.ts
+var path = __toESM(require("path"), 1);
+var Deno = globalThis.Deno;
+
+// src/deno/deno-sys-abstraction.ts
+var Deno2 = globalThis.Deno;
+var once = new ResolveOnce();
 var _deno;
-var DenoEnvActions = class {
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
+var _DenoEnvActions = class _DenoEnvActions {
   constructor(opts) {
     __privateAdd(this, _deno, globalThis);
+    this.opts = opts;
+  }
+  static new(opts) {
+    return once.once(() => new _DenoEnvActions(opts));
   }
   get _env() {
     return __privateGet(this, _deno).Deno.env;
   }
   register(env) {
+    for (const key2 of env.keys()) {
+      this._env.set(key2, env.get(key2) || "");
+    }
     return env;
   }
   active() {
-    return typeof __privateGet(this, _deno) === "object" && typeof __privateGet(this, _deno).Deno === "object" && typeof __privateGet(this, _deno).Deno.env === "object";
+    return runtimeFn().isDeno;
   }
   keys() {
-    return Array.from(this._env.keys());
+    return Object.keys(this._env.toObject());
   }
   get(key2) {
     return this._env.get(key2);
@@ -760,44 +797,274 @@ var DenoEnvActions = class {
   }
 };
 _deno = new WeakMap();
-var BrowserEnvActions = class {
+var DenoEnvActions = _DenoEnvActions;
+var DenoExitServiceImpl = class {
+  constructor() {
+    this._exitHandlers = [];
+    this.invoked = false;
+    this._handleExit = async () => {
+      if (this.invoked) {
+        return;
+      }
+      this.invoked = true;
+      for (const h of this._exitHandlers) {
+        try {
+          const ret = h.hdl();
+          if (typeof ret.then === "function") {
+            await ret;
+          }
+        } finally {
+        }
+      }
+    };
+    globalThis.addEventListener("unhandledrejection", (e) => {
+      e.preventDefault();
+      this.exit(19);
+    });
+    globalThis.addEventListener("error", () => {
+      this.exit(19);
+    });
+    globalThis.addEventListener("uncaughtException", () => {
+      this.exit(19);
+    });
+    globalThis.addEventListener("unload", () => {
+      this.exit(0);
+    });
+    Deno2.addSignalListener("SIGQUIT", () => {
+      this.exit(3);
+    });
+    Deno2.addSignalListener("SIGINT", () => {
+      this.exit(2);
+    });
+    Deno2.addSignalListener("SIGTERM", () => {
+      this.exit(9);
+    });
+  }
+  injectExitHandlers(hdls) {
+    this._exitHandlers = hdls;
+  }
+  exit(code) {
+    this._handleExit().then(() => {
+      Deno2.exit(code);
+    }).catch((err) => {
+      console.error("ExitService: failed to handle exit", err);
+      Deno2.exit(code);
+    });
+  }
+};
+var _DenoSystemService = class _DenoSystemService {
+  constructor() {
+    this._exitService = new DenoExitServiceImpl();
+    this._exitService.injectExitHandlers(_DenoSystemService._exitHandlers);
+  }
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    return Deno2.args;
+  }
+  OnExit(hdl) {
+    const id = crypto.randomUUID();
+    _DenoSystemService._exitHandlers.push({ hdl, id });
+    return () => {
+      const idx = _DenoSystemService._exitHandlers.findIndex((h) => h.id === id);
+      if (idx >= 0) {
+        _DenoSystemService._exitHandlers.splice(idx, 1);
+      }
+    };
+  }
+  Exit(code) {
+    this._exitService.exit(code);
+  }
+};
+_DenoSystemService._exitHandlers = [];
+var DenoSystemService = _DenoSystemService;
+
+// src/node/node-file-service.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_process = __toESM(require("process"), 1);
+
+// src/node/node-sys-abstraction.ts
+var import_node_process2 = __toESM(require("process"), 1);
+var once2 = new ResolveOnce();
+var _node;
+var _NodeEnvActions = class _NodeEnvActions {
   constructor(opts) {
-    this.env = /* @__PURE__ */ new Map();
+    __privateAdd(this, _node, globalThis);
+    this._env = this.active() ? __privateGet(this, _node).process.env : {};
     this.opts = opts;
   }
+  static new(opts) {
+    return once2.once(() => new _NodeEnvActions(opts));
+  }
+  register(env) {
+    for (const key2 of env.keys()) {
+      this._env[key2] = env.get(key2) || "";
+    }
+    return env;
+  }
+  active() {
+    return runtimeFn().isNodeIsh;
+  }
+  keys() {
+    return Object.keys(this._env);
+  }
   get(key2) {
-    return this.env.get(key2);
+    return this._env[key2];
   }
   set(key2, value) {
     if (value) {
-      this.env.set(key2, value);
+      this._env[key2] = value;
     }
   }
   delete(key2) {
-    this.env.delete(key2);
+    delete this._env[key2];
   }
-  keys() {
-    return Array.from(this.env.keys());
+};
+_node = new WeakMap();
+var NodeEnvActions = _NodeEnvActions;
+var NodeExitServiceImpl = class {
+  constructor() {
+    this._exitHandlers = [];
+    this.invoked = false;
+    this._handleExit = async () => {
+      if (this.invoked) {
+        return;
+      }
+      this.invoked = true;
+      for (const h of this._exitHandlers) {
+        try {
+          const ret = h.hdl();
+          if (typeof ret.then === "function") {
+            await ret;
+          }
+        } finally {
+        }
+      }
+    };
+    import_node_process2.default.on("unhandledRejection", (reason, p) => {
+      this.exit(19);
+    });
+    import_node_process2.default.on("uncaughtException", (error) => {
+      this.exit(18);
+    });
+    import_node_process2.default.on("close", () => {
+      this.exit(0);
+    });
+    import_node_process2.default.on("exit", () => {
+      this.exit(0);
+    });
+    import_node_process2.default.on("SIGQUIT", () => {
+      this.exit(3);
+    });
+    import_node_process2.default.on("SIGINT", () => {
+      this.exit(2);
+    });
+    import_node_process2.default.on("SIGTERM", () => {
+      this.exit(9);
+    });
+  }
+  injectExitHandlers(hdls) {
+    this._exitHandlers = hdls;
+  }
+  exit(code) {
+    this._handleExit().then(() => {
+      import_node_process2.default.exit(code);
+    }).catch((err) => {
+      console.error("ExitService: failed to handle exit", err);
+      import_node_process2.default.exit(code);
+    });
+  }
+};
+var _NodeSystemService = class _NodeSystemService {
+  constructor() {
+    this._exitService = new NodeExitServiceImpl();
+    this._exitService.injectExitHandlers(_NodeSystemService._exitHandlers);
+  }
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    return import_node_process2.default.argv;
+  }
+  OnExit(hdl) {
+    const id = crypto.randomUUID();
+    _NodeSystemService._exitHandlers.push({ hdl, id });
+    return () => {
+      const idx = _NodeSystemService._exitHandlers.findIndex((h) => h.id === id);
+      if (idx >= 0) {
+        _NodeSystemService._exitHandlers.splice(idx, 1);
+      }
+    };
+  }
+  Exit(code) {
+    this._exitService.exit(code);
+  }
+};
+_NodeSystemService._exitHandlers = [];
+var NodeSystemService = _NodeSystemService;
+
+// src/cf/cf-sys-abstraction.ts
+var once3 = new ResolveOnce();
+var CFEnvActions = class _CFEnvActions {
+  constructor(env) {
+    this.injectOnRegister = {};
+    this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
+  }
+  static new(opts) {
+    return once3.once(() => new _CFEnvActions(opts));
+  }
+  static inject(o) {
+    const env = _CFEnvActions.new({});
+    for (const key2 in o) {
+      const value = o[key2];
+      if (typeof value === "string") {
+        if (env.env) {
+          env.env.set(key2, value);
+        } else {
+          env.injectOnRegister[key2] = value;
+        }
+      }
+    }
   }
   active() {
-    return true;
+    return runtimeFn().isCFWorker;
   }
   register(env) {
-    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
-    const browser = globalThis;
-    browser[sym] = env;
+    this.env = env;
+    for (const key2 in this.injectOnRegister) {
+      env.set(key2, this.injectOnRegister[key2]);
+    }
     return env;
   }
+  get(key2) {
+    return this.cfEnv.get(key2);
+  }
+  set(key2, value) {
+    if (value) {
+      this.cfEnv.set(key2, value);
+    }
+  }
+  delete(key2) {
+    this.cfEnv.delete(key2);
+  }
+  keys() {
+    return Array.from(this.cfEnv.keys());
+  }
 };
+
+// src/sys-env.ts
 var envActions = [
-  { id: "node", fn: (opts) => new NodeEnvActions(opts) },
-  { id: "deno", fn: (opts) => new DenoEnvActions(opts) },
-  { id: "browser", fn: (opts) => new BrowserEnvActions(opts) }
+  { id: "cf", fn: (opts) => CFEnvActions.new(opts) },
+  { id: "node", fn: (opts) => NodeEnvActions.new(opts) },
+  { id: "deno", fn: (opts) => DenoEnvActions.new(opts) },
+  { id: "browser", fn: (opts) => BrowserEnvActions.new(opts) }
 ];
 function registerEnvAction(fn) {
   const id = `id-${Math.random()}`;
   envActions.unshift({ id, fn });
-  _envFactory.reset();
+  _envFactories.unget(id);
   return () => {
     const index = envActions.findIndex((i) => i.id === id);
     if (index >= 0) {
@@ -805,19 +1072,20 @@ function registerEnvAction(fn) {
     }
   };
 }
-var _envFactory = new ResolveOnce();
+var _envFactories = new KeyedResolvOnce();
 function envFactory(opts = {}) {
-  return _envFactory.once(() => {
-    const found = envActions.map((facItem) => facItem.fn(opts)).find((env) => env.active());
-    if (!found) {
-      throw new Error("SysContainer:envFactory: no env available");
-    }
-    const ret = new EnvImpl(found, opts);
-    found.register(ret);
+  const found = envActions.find((fi) => fi.fn(opts).active());
+  if (!found) {
+    throw new Error("SysContainer:envFactory: no env available");
+  }
+  return _envFactories.get(found.id).once(() => {
+    const action = found.fn(opts);
+    const ret = new EnvImpl2(action, opts);
+    action.register(ret);
     return ret;
   });
 }
-var EnvImpl = class {
+var EnvImpl2 = class {
   constructor(map, opts = {}) {
     this._onSet = [];
     this._map = map;
@@ -885,23 +1153,40 @@ var EnvImpl = class {
   }
 };
 
-// src/txt-en-decoder.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-var Utf8EnDecoder = class {
-  encode(str) {
-    return encoder.encode(str);
+// src/web/web-sys-abstraction.ts
+var once4 = new ResolveOnce();
+var BrowserEnvActions = class _BrowserEnvActions {
+  constructor(opts) {
+    this.env = /* @__PURE__ */ new Map();
+    this.opts = opts;
   }
-  decode(data) {
-    return decoder.decode(data);
+  static new(opts) {
+    return once4.once(() => new _BrowserEnvActions(opts));
+  }
+  get(key2) {
+    return this.env.get(key2);
+  }
+  set(key2, value) {
+    if (value) {
+      this.env.set(key2, value);
+    }
+  }
+  delete(key2) {
+    this.env.delete(key2);
+  }
+  keys() {
+    return Array.from(this.env.keys());
+  }
+  active() {
+    return true;
+  }
+  register(env) {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis;
+    browser[sym] = env;
+    return env;
   }
 };
-var utf8EnDecoder = new Utf8EnDecoder();
-function Utf8EnDecoderSingleton() {
-  return utf8EnDecoder;
-}
-
-// src/web/web-sys-abstraction.ts
 var WebFileService = class {
   get baseDir() {
     throw new Error("basedir-Method not implemented.");
@@ -1112,23 +1397,23 @@ var Path = class {
     this.parts.push(part);
   }
 };
-function splitPath(path) {
+function splitPath(path3) {
   const p = new Path();
-  if (path === "") {
+  if (path3 === "") {
     return p;
   }
-  for (let count = 0; path.length; count++) {
-    if (path.match(/^\/+/)) {
+  for (let count = 0; path3.length; count++) {
+    if (path3.match(/^\/+/)) {
       if (count === 0) {
         p.add(3 /* Root */);
       } else {
         p.add(1 /* Slash */);
       }
-      path = path.replace(/^\/+/, "");
+      path3 = path3.replace(/^\/+/, "");
     } else {
-      const part = path.replace(/\/.*$/, "");
+      const part = path3.replace(/\/.*$/, "");
       p.add(part);
-      path = path.replace(/^[^/]+/, "");
+      path3 = path3.replace(/^[^/]+/, "");
     }
   }
   return p;
@@ -1137,29 +1422,29 @@ function pathJoin(...paths) {
   let prev = "";
   const res = [];
   for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
-    if (path === "") {
+    const path3 = paths[i];
+    if (path3 === "") {
       continue;
     }
-    if (!(prev.endsWith("/") || path.startsWith("/"))) {
+    if (!(prev.endsWith("/") || path3.startsWith("/"))) {
       if (prev !== "") {
         res.push("/");
       }
-      res.push(path);
+      res.push(path3);
     } else {
-      res.push(path);
+      res.push(path3);
     }
-    prev = path;
+    prev = path3;
   }
   return res.join("");
 }
-function relativePath(path, relative) {
-  const relativeParts = splitPath(relative);
+function relativePath(path3, relative2) {
+  const relativeParts = splitPath(relative2);
   let result;
   if (relativeParts.parts[0] === 3 /* Root */) {
-    result = relative;
+    result = relative2;
   } else {
-    result = pathJoin(path, relative);
+    result = pathJoin(path3, relative2);
   }
   const unoptPath = splitPath(result);
   const out = [];
@@ -1211,12 +1496,12 @@ function stripper(strip, obj) {
   });
   return localStripper(void 0, restrips, obj);
 }
-function localStripper(path, restrips, obj) {
+function localStripper(path3, restrips, obj) {
   if (typeof obj !== "object" || obj === null) {
     return obj;
   }
   if (Array.isArray(obj)) {
-    return obj.map((i) => localStripper(path, restrips, i));
+    return obj.map((i) => localStripper(path3, restrips, i));
   }
   const ret = { ...obj };
   const matcher = (key2, nextPath) => {
@@ -1230,8 +1515,8 @@ function localStripper(path, restrips, obj) {
   for (const key2 in ret) {
     if (Object.prototype.hasOwnProperty.call(ret, key2)) {
       let nextPath;
-      if (path) {
-        nextPath = [path, key2].join(".");
+      if (path3) {
+        nextPath = [path3, key2].join(".");
       } else {
         nextPath = key2;
       }
@@ -1708,33 +1993,6 @@ var URI = class _URI {
   }
 };
 
-// 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 gt = globalThis;
-  const isReactNative = isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative";
-  let isNodeIsh = false;
-  if (!isSet("Deno")) {
-    isNodeIsh = isSet("process.versions.node") && !isReactNative;
-  }
-  const isDeno = isSet("Deno");
-  return {
-    isNodeIsh,
-    isBrowser: !(isNodeIsh || isDeno) && !isReactNative,
-    isDeno,
-    isReactNative
-  };
-}
-
 // src/utils/console-write-stream.ts
 var ConsoleWriterStreamDefaultWriter = class {
   constructor(stream) {
@@ -2067,7 +2325,7 @@ var LoggerImpl = class _LoggerImpl {
         if (rt.isBrowser) {
           stream = new ConsoleWriterStream();
         } else {
-          if (rt.isNodeIsh || rt.isReactNative || rt.isDeno) {
+          if (rt.isNodeIsh || rt.isReactNative || rt.isDeno || rt.isCFWorker) {
             stream = this._sys.Stdout();
           } else {
             throw new Error("No output defined for runtime");
@@ -2171,7 +2429,7 @@ var LoggerImpl = class _LoggerImpl {
       }
       if (this.levelHandler.isStackExposed) {
         this._attributes["stack"] = logValue(
-          (_a = err.stack) == null ? void 0 : _a.split("\n").map((s) => s.trim()),
+          (_a = err.stack) == null ? void 0 : _a.split(/[\r\n]+/).map((s) => s.trim()),
           toLogValueCtx(this.levelHandler)
         );
       }
@@ -2287,8 +2545,8 @@ var LoggerImpl = class _LoggerImpl {
     return this.Uint64(key2, value);
   }
   async Flush() {
-    return new Promise((resolve) => {
-      this._logWriter._flush(void 0, resolve);
+    return new Promise((resolve2) => {
+      this._logWriter._flush(void 0, resolve2);
     });
   }
   With() {
@@ -2599,8 +2857,8 @@ function MockLogger(params) {
 
 // src/tracer.ts
 var Metric = class {
-  constructor(path) {
-    this.path = path;
+  constructor(path3) {
+    this.path = path3;
   }
   set(value) {
     this.value = value;
@@ -2635,23 +2893,23 @@ var Metrics = class {
     return obj;
   }
   get(ipath) {
-    const path = ipath.replace(/[/]+/g, "/").trim();
-    if (path.startsWith("/")) {
-      if (path.slice(1).length === 0) {
-        throw new Error(`Metrics path must contain value /:${path}`);
+    const path3 = ipath.replace(/[/]+/g, "/").trim();
+    if (path3.startsWith("/")) {
+      if (path3.slice(1).length === 0) {
+        throw new Error(`Metrics path must contain value /:${path3}`);
       }
-      let metric = this.map.get(path);
+      let metric = this.map.get(path3);
       if (!metric) {
-        metric = new Metric(path);
-        this.map.set(path, metric);
+        metric = new Metric(path3);
+        this.map.set(path3, metric);
       }
-      this.spanRefs.set(path, metric);
+      this.spanRefs.set(path3, metric);
       return metric;
-    } else if (path.includes("/")) {
-      throw new Error(`Metrics path must start with /:${path}`);
+    } else if (path3.includes("/")) {
+      throw new Error(`Metrics path must start with /:${path3}`);
     }
     const rootPath = this.tracenode.getRootPath();
-    return this.get(`${rootPath}/${path}`);
+    return this.get(`${rootPath}/${path3}`);
   }
 };
 var TraceNode = class _TraceNode {
@@ -3075,8 +3333,8 @@ function rebuffer(a, chunkSize) {
   };
   return new ReadableStream({
     async pull(controller) {
-      return new Promise((resolve) => {
-        pump(state, controller, resolve);
+      return new Promise((resolve2) => {
+        pump(state, controller, resolve2);
       });
     }
   });
@@ -3144,7 +3402,6 @@ function uint8array2stream(str) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseSysAbstraction,
-  BrowserEnvActions,
   BuildURI,
   ConstTime,
   EnvImpl,