@adviser/cement 0.3.1 → 0.3.3

package/node/index.cjs

@@ -37,10 +37,8 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 // src/node/index.ts
 var node_exports = {};
 __export(node_exports, {
-  DenoExitServiceImpl: () => DenoExitServiceImpl,
-  DenoSysAbstraction: () => DenoSysAbstraction,
-  DenoSystemService: () => DenoSystemService,
   MockFileService: () => MockFileService,
+  NodeEnvActions: () => NodeEnvActions,
   NodeExitServiceImpl: () => NodeExitServiceImpl,
   NodeFileService: () => NodeFileService,
   NodeSysAbstraction: () => NodeSysAbstraction,
@@ -448,54 +446,105 @@ 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 : {};
-  }
-  register(env) {
-    return env;
-  }
-  active() {
-    return typeof __privateGet(this, _node) === "object" && typeof __privateGet(this, _node).process === "object" && typeof __privateGet(this, _node).process.env === "object";
+var Keyed = class {
+  constructor(factory) {
+    this._map = /* @__PURE__ */ new Map();
+    this.factory = factory;
   }
-  keys() {
-    return Object.keys(this._env);
+  async asyncGet(key) {
+    return this.get(await key());
   }
   get(key) {
-    return this._env[key];
-  }
-  set(key, value) {
-    if (value) {
-      this._env[key] = value;
+    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;
   }
-  delete(key) {
-    delete this._env[key];
+  unget(key) {
+    const keyed = this._map.get(key);
+    keyed == null ? void 0 : keyed.reset();
+    this._map.delete(key);
+  }
+  reset() {
+    this._map.forEach((keyed) => keyed.reset());
+    this._map.clear();
   }
 };
-_node = new WeakMap();
+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]);
+  }
+  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/deno/deno-file-service.ts
+var path2 = __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);
@@ -510,11 +559,99 @@ 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/web/web-sys-abstraction.ts
+var once2 = new ResolveOnce();
+var BrowserEnvActions = class _BrowserEnvActions {
   constructor(opts) {
     this.env = /* @__PURE__ */ new Map();
     this.opts = opts;
   }
+  static new(opts) {
+    return once2.once(() => new _BrowserEnvActions(opts));
+  }
   get(key) {
     return this.env.get(key);
   }
@@ -539,24 +676,77 @@ var BrowserEnvActions = class {
     return env;
   }
 };
+
+// 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 key in o) {
+      const value = o[key];
+      if (typeof value === "string") {
+        if (env.env) {
+          env.env.set(key, value);
+        } else {
+          env.injectOnRegister[key] = value;
+        }
+      }
+    }
+  }
+  active() {
+    return runtimeFn().isCFWorker;
+  }
+  register(env) {
+    this.env = env;
+    for (const key in this.injectOnRegister) {
+      env.set(key, this.injectOnRegister[key]);
+    }
+    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());
+  }
+};
+
+// 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) }
 ];
-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;
@@ -626,6 +816,43 @@ var EnvImpl = class {
 
 // src/node/node-sys-abstraction.ts
 var import_node_process2 = __toESM(require("process"), 1);
+var once4 = new ResolveOnce();
+var _node;
+var _NodeEnvActions = class _NodeEnvActions {
+  constructor(opts) {
+    __privateAdd(this, _node, globalThis);
+    this._env = this.active() ? __privateGet(this, _node).process.env : {};
+    this.opts = opts;
+  }
+  static new(opts) {
+    return once4.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[key];
+  }
+  set(key, value) {
+    if (value) {
+      this._env[key] = value;
+    }
+  }
+  delete(key) {
+    delete this._env[key];
+  }
+};
+_node = new WeakMap();
+var NodeEnvActions = _NodeEnvActions;
 var NodeExitServiceImpl = class {
   constructor() {
     this._exitHandlers = [];
@@ -718,176 +945,6 @@ function NodeSysAbstraction(param) {
   return new WrapperSysAbstraction(my, param);
 }
 
-// src/node/deno-sys-abstraction.ts
-var process3 = __toESM(require("process"), 1);
-
-// src/node/deno-file-service.ts
-var path2 = __toESM(require("path"), 1);
-var Deno = globalThis.Deno;
-var DenoFileService = class {
-  constructor(baseDir = Deno.cwd(), txtEnde = Utf8EnDecoderSingleton()) {
-    this.baseDir = this.abs(baseDir);
-    this.txtEnde = txtEnde;
-  }
-  // nodeImport(fname: string): string {
-  //   // console.log('nodeImport:'+ fname);
-  //   if (path.isAbsolute(fname)) {
-  //     return fname;
-  //   } else {
-  //     return "./" + path.normalize(fname);
-  //   }
-  // }
-  async readFileString(fname) {
-    return this.txtEnde.decode(await Deno.readFile(fname));
-  }
-  dirname(fname) {
-    return path2.dirname(fname);
-  }
-  basename(fname) {
-    return path2.basename(fname);
-  }
-  join(...paths) {
-    return path2.join(...paths);
-  }
-  relative(from, to) {
-    if (to === void 0) {
-      to = from;
-      from = Deno.cwd();
-    }
-    const ret = path2.relative(from, to);
-    return ret;
-  }
-  abs(fname) {
-    if (path2.isAbsolute(fname)) {
-      return fname;
-    } else {
-      const cwd = Deno.cwd();
-      return path2.resolve(cwd, fname);
-    }
-  }
-  isAbsolute(fname) {
-    return path2.isAbsolute(fname);
-  }
-  async writeFileString(fname, content, ende = Utf8EnDecoderSingleton()) {
-    const o = await this.create(fname);
-    const wr = o.stream.getWriter();
-    await wr.write(ende.encode(content));
-    await wr.close();
-  }
-  async create(fname) {
-    let oName = fname;
-    if (!path2.isAbsolute(fname)) {
-      oName = this.abs(fname);
-    }
-    const base = path2.dirname(oName);
-    await Deno.mkdir(base, { recursive: true });
-    const out = await Deno.open(oName, {
-      write: true,
-      create: true,
-      truncate: true
-    });
-    return {
-      name: oName,
-      stream: out
-    };
-  }
-};
-
-// src/node/deno-sys-abstraction.ts
-var Deno2 = globalThis.Deno;
-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 process3.argv;
-  }
-  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;
-var my2 = void 0;
-function DenoSysAbstraction(param) {
-  if (!my2) {
-    my2 = new BaseSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
-      FileSystem: new DenoFileService(),
-      SystemService: new DenoSystemService()
-    });
-  }
-  return new WrapperSysAbstraction(my2, param);
-}
-
 // src/node/mock-file-service.ts
 var MockFileService = class extends NodeFileService {
   constructor() {
@@ -926,10 +983,8 @@ var MockFileService = class extends NodeFileService {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DenoExitServiceImpl,
-  DenoSysAbstraction,
-  DenoSystemService,
   MockFileService,
+  NodeEnvActions,
   NodeExitServiceImpl,
   NodeFileService,
   NodeSysAbstraction,