@adviser/cement 0.3.2 → 0.3.4

package/test/index.cjs

@@ -80,8 +80,8 @@ var Future = class {
     __privateAdd(this, _rejectFn, () => {
       throw new Error("This Promise is not working as expected.");
     });
-    __privateSet(this, _promise, new Promise((resolve2, reject) => {
-      __privateSet(this, _resolveFn, resolve2);
+    __privateSet(this, _promise, new Promise((resolve, reject) => {
+      __privateSet(this, _resolveFn, resolve);
       __privateSet(this, _rejectFn, reject);
     }));
   }
@@ -513,9 +513,9 @@ var SysTime = class extends Time {
     return /* @__PURE__ */ new Date();
   }
   Sleep(duration) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       setTimeout(() => {
-        resolve2();
+        resolve();
       }, duration);
     });
   }
@@ -842,12 +842,7 @@ function runtimeFn() {
   };
 }
 
-// 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;
+// src/deno/deno-env-actions.ts
 var once = new ResolveOnce();
 var _deno;
 var _DenoEnvActions = class _DenoEnvActions {
@@ -887,95 +882,8 @@ var _DenoEnvActions = class _DenoEnvActions {
 };
 _deno = new WeakMap();
 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);
+// src/node/node-env-actions.ts
 var once2 = new ResolveOnce();
 var _node;
 var _NodeEnvActions = class _NodeEnvActions {
@@ -1013,111 +921,73 @@ var _NodeEnvActions = class _NodeEnvActions {
 };
 _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);
-    });
+
+// src/web/web-env-actions.ts
+var once3 = new ResolveOnce();
+var BrowserEnvActions = class _BrowserEnvActions {
+  constructor(opts) {
+    this.env = /* @__PURE__ */ new Map();
+    this.opts = opts;
   }
-  injectExitHandlers(hdls) {
-    this._exitHandlers = hdls;
+  static new(opts) {
+    return once3.once(() => new _BrowserEnvActions(opts));
   }
-  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);
-    });
+  get(key2) {
+    return this.env.get(key2);
   }
-};
-var _NodeSystemService = class _NodeSystemService {
-  constructor() {
-    this._exitService = new NodeExitServiceImpl();
-    this._exitService.injectExitHandlers(_NodeSystemService._exitHandlers);
+  set(key2, value) {
+    if (value) {
+      this.env.set(key2, value);
+    }
   }
-  Env() {
-    return envFactory();
+  delete(key2) {
+    this.env.delete(key2);
   }
-  Args() {
-    return import_node_process2.default.argv;
+  keys() {
+    return Array.from(this.env.keys());
   }
-  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);
-      }
-    };
+  active() {
+    return true;
   }
-  Exit(code) {
-    this._exitService.exit(code);
+  register(env) {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis;
+    browser[sym] = env;
+    return env;
   }
 };
-_NodeSystemService._exitHandlers = [];
-var NodeSystemService = _NodeSystemService;
 
-// src/cf/cf-sys-abstraction.ts
-var once3 = new ResolveOnce();
+// src/cf/cf-env-actions.ts
+var once4 = 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));
+    return once4.once(() => new _CFEnvActions(opts));
   }
   static inject(o) {
-    var _a;
     const env = _CFEnvActions.new({});
     for (const key2 in o) {
       const value = o[key2];
       if (typeof value === "string") {
-        (_a = env.env) == null ? void 0 : _a.set(key2, value);
+        if (env.env) {
+          env.env.set(key2, value);
+        } else {
+          env.injectOnRegister[key2] = value;
+        }
       }
     }
   }
-  constructor(env) {
-    this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
-  }
   active() {
     return runtimeFn().isCFWorker;
   }
   register(env) {
     this.env = env;
+    for (const key2 in this.injectOnRegister) {
+      env.set(key2, this.injectOnRegister[key2]);
+    }
     return env;
   }
   get(key2) {
@@ -1151,12 +1021,12 @@ function envFactory(opts = {}) {
   }
   return _envFactories.get(found.id).once(() => {
     const action = found.fn(opts);
-    const ret = new EnvImpl2(action, opts);
+    const ret = new EnvImpl(action, opts);
     action.register(ret);
     return ret;
   });
 }
-var EnvImpl2 = class {
+var EnvImpl = class {
   constructor(map, opts = {}) {
     this._onSet = [];
     this._map = map;
@@ -1225,39 +1095,6 @@ var EnvImpl2 = class {
 };
 
 // src/web/web-sys-abstraction.ts
-var once4 = new ResolveOnce();
-var BrowserEnvActions = class _BrowserEnvActions {
-  constructor(opts) {
-    this.env = /* @__PURE__ */ new Map();
-    this.opts = opts;
-  }
-  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 WebFileService = class {
   get baseDir() {
     throw new Error("basedir-Method not implemented.");
@@ -1468,23 +1305,23 @@ var Path = class {
     this.parts.push(part);
   }
 };
-function splitPath(path3) {
+function splitPath(path) {
   const p = new Path();
-  if (path3 === "") {
+  if (path === "") {
     return p;
   }
-  for (let count = 0; path3.length; count++) {
-    if (path3.match(/^\/+/)) {
+  for (let count = 0; path.length; count++) {
+    if (path.match(/^\/+/)) {
       if (count === 0) {
         p.add(3 /* Root */);
       } else {
         p.add(1 /* Slash */);
       }
-      path3 = path3.replace(/^\/+/, "");
+      path = path.replace(/^\/+/, "");
     } else {
-      const part = path3.replace(/\/.*$/, "");
+      const part = path.replace(/\/.*$/, "");
       p.add(part);
-      path3 = path3.replace(/^[^/]+/, "");
+      path = path.replace(/^[^/]+/, "");
     }
   }
   return p;
@@ -1493,29 +1330,29 @@ function pathJoin(...paths) {
   let prev = "";
   const res = [];
   for (let i = 0; i < paths.length; i++) {
-    const path3 = paths[i];
-    if (path3 === "") {
+    const path = paths[i];
+    if (path === "") {
       continue;
     }
-    if (!(prev.endsWith("/") || path3.startsWith("/"))) {
+    if (!(prev.endsWith("/") || path.startsWith("/"))) {
       if (prev !== "") {
         res.push("/");
       }
-      res.push(path3);
+      res.push(path);
     } else {
-      res.push(path3);
+      res.push(path);
     }
-    prev = path3;
+    prev = path;
   }
   return res.join("");
 }
-function relativePath(path3, relative2) {
-  const relativeParts = splitPath(relative2);
+function relativePath(path, relative) {
+  const relativeParts = splitPath(relative);
   let result;
   if (relativeParts.parts[0] === 3 /* Root */) {
-    result = relative2;
+    result = relative;
   } else {
-    result = pathJoin(path3, relative2);
+    result = pathJoin(path, relative);
   }
   const unoptPath = splitPath(result);
   const out = [];
@@ -1567,12 +1404,12 @@ function stripper(strip, obj) {
   });
   return localStripper(void 0, restrips, obj);
 }
-function localStripper(path3, restrips, obj) {
+function localStripper(path, restrips, obj) {
   if (typeof obj !== "object" || obj === null) {
     return obj;
   }
   if (Array.isArray(obj)) {
-    return obj.map((i) => localStripper(path3, restrips, i));
+    return obj.map((i) => localStripper(path, restrips, i));
   }
   const ret = { ...obj };
   const matcher = (key2, nextPath) => {
@@ -1586,8 +1423,8 @@ function localStripper(path3, restrips, obj) {
   for (const key2 in ret) {
     if (Object.prototype.hasOwnProperty.call(ret, key2)) {
       let nextPath;
-      if (path3) {
-        nextPath = [path3, key2].join(".");
+      if (path) {
+        nextPath = [path, key2].join(".");
       } else {
         nextPath = key2;
       }
@@ -2468,8 +2305,8 @@ var LoggerImpl = class _LoggerImpl {
     return this.Uint64(key2, value);
   }
   async Flush() {
-    return new Promise((resolve2) => {
-      this._logWriter._flush(void 0, resolve2);
+    return new Promise((resolve) => {
+      this._logWriter._flush(void 0, resolve);
     });
   }
   With() {