@adviser/cement 0.3.0 → 0.3.2

package/web/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -18,6 +20,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
@@ -27,6 +37,8 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 // src/web/index.ts
 var web_exports = {};
 __export(web_exports, {
+  BrowserEnvActions: () => BrowserEnvActions,
+  WebFileService: () => WebFileService,
   WebSysAbstraction: () => WebSysAbstraction
 });
 module.exports = __toCommonJS(web_exports);
@@ -45,9 +57,9 @@ var SysTime = class extends Time {
     return /* @__PURE__ */ new Date();
   }
   Sleep(duration) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       setTimeout(() => {
-        resolve();
+        resolve2();
       }, duration);
     });
   }
@@ -237,8 +249,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);
     }));
   }
@@ -335,54 +347,121 @@ var ResolveOnce = class {
     }
   }
 };
-
-// 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 : {};
+var Keyed = class {
+  constructor(factory) {
+    this._map = /* @__PURE__ */ new Map();
+    this.factory = factory;
   }
-  register(env) {
-    return env;
+  async asyncGet(key) {
+    return this.get(await key());
   }
-  active() {
-    return typeof __privateGet(this, _node) === "object" && typeof __privateGet(this, _node).process === "object" && typeof __privateGet(this, _node).process.env === "object";
+  get(key) {
+    if (typeof key === "function") {
+      key = key();
+    }
+    let keyed = this._map.get(key);
+    if (!keyed) {
+      keyed = this.factory(key);
+      this._map.set(key, keyed);
+    }
+    return keyed;
   }
-  keys() {
-    return Object.keys(this._env);
+  unget(key) {
+    const keyed = this._map.get(key);
+    keyed == null ? void 0 : keyed.reset();
+    this._map.delete(key);
   }
-  get(key) {
-    return this._env[key];
+  reset() {
+    this._map.forEach((keyed) => keyed.reset());
+    this._map.clear();
   }
-  set(key, value) {
-    if (value) {
-      this._env[key] = value;
+};
+var KeyedResolvOnce = class extends Keyed {
+  constructor() {
+    super((key) => new ResolveOnce(key));
+  }
+};
+
+// 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]);
   }
-  delete(key) {
-    delete this._env[key];
+  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;
+  }
+  let isDeno = isSet("Deno");
+  const isCFWorker = isSet("caches.default") && isSet("WebSocketPair");
+  if (isCFWorker) {
+    isDeno = false;
+    isNodeIsh = false;
+    isReactNative = false;
+  }
+  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);
+  }
+  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 key of env.keys()) {
+      this._env.set(key, env.get(key) || "");
+    }
     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(key) {
     return this._env.get(key);
@@ -397,48 +476,277 @@ 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 key of env.keys()) {
+      this._env[key] = env.get(key) || "";
+    }
+    return env;
+  }
+  active() {
+    return runtimeFn().isNodeIsh;
+  }
+  keys() {
+    return Object.keys(this._env);
+  }
   get(key) {
-    return this.env.get(key);
+    return this._env[key];
   }
   set(key, value) {
     if (value) {
-      this.env.set(key, value);
+      this._env[key] = value;
     }
   }
   delete(key) {
-    this.env.delete(key);
+    delete this._env[key];
   }
-  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 {
+  static new(opts) {
+    return once3.once(() => new _CFEnvActions(opts));
+  }
+  static inject(o) {
+    var _a;
+    const env = _CFEnvActions.new({});
+    for (const key in o) {
+      const value = o[key];
+      if (typeof value === "string") {
+        (_a = env.env) == null ? void 0 : _a.set(key, value);
+      }
+    }
+  }
+  constructor(env) {
+    this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
   }
   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;
     return env;
   }
+  get(key) {
+    return this.cfEnv.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this.cfEnv.set(key, value);
+    }
+  }
+  delete(key) {
+    this.cfEnv.delete(key);
+  }
+  keys() {
+    return Array.from(this.cfEnv.keys());
+  }
 };
-var _envFactory = new ResolveOnce();
+
+// src/sys-env.ts
+var envActions = [
+  { 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) }
+];
+var _envFactories = new KeyedResolvOnce();
 function envFactory(opts = {}) {
-  return _envFactory.once(() => {
-    const found = [new NodeEnvActions(opts), new DenoEnvActions(opts), new BrowserEnvActions(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;
@@ -506,23 +814,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(key) {
+    return this.env.get(key);
+  }
+  set(key, value) {
+    if (value) {
+      this.env.set(key, value);
+    }
+  }
+  delete(key) {
+    this.env.delete(key);
+  }
+  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.");
@@ -597,6 +922,8 @@ function WebSysAbstraction(param) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BrowserEnvActions,
+  WebFileService,
   WebSysAbstraction
 });
 //# sourceMappingURL=index.cjs.map