@adviser/cement 0.3.2 → 0.3.4

package/src/cf/cf-env-actions.ts

@@ -0,0 +1,53 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { runtimeFn } from "../runtime.js";
+import { EnvActions, EnvImpl, EnvFactoryOpts, Env } from "../sys-env.js";
+
+const once = new ResolveOnce<CFEnvActions>();
+export class CFEnvActions implements EnvActions {
+  readonly injectOnRegister: Record<string, string> = {};
+  readonly cfEnv: Map<string, string>;
+  env?: EnvImpl;
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return once.once(() => new CFEnvActions(opts));
+  }
+  static inject(o: Record<string, string>): void {
+    const env = CFEnvActions.new({}) as CFEnvActions;
+    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;
+        }
+      }
+    }
+  }
+  private constructor(env: Partial<EnvFactoryOpts>) {
+    this.cfEnv = new Map<string, string>(Object.entries(env.presetEnv || {}));
+  }
+  active(): boolean {
+    return runtimeFn().isCFWorker;
+  }
+  register(env: Env): Env {
+    this.env = env as EnvImpl;
+    for (const key in this.injectOnRegister) {
+      env.set(key, this.injectOnRegister[key]);
+    }
+    return env;
+  }
+  get(key: string): string | undefined {
+    return this.cfEnv.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this.cfEnv.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this.cfEnv.delete(key);
+  }
+  keys(): string[] {
+    return Array.from(this.cfEnv.keys());
+  }
+}

package/src/cf/cf-sys-abstraction.ts

@@ -1,53 +1,9 @@
 import { BaseSysAbstraction, WrapperSysAbstraction, WrapperSysAbstractionParams } from "../base-sys-abstraction.js";
-import { ResolveOnce } from "../resolve-once.js";
-import { runtimeFn } from "../runtime.js";
 import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import { Env, EnvActions, envFactory, EnvFactoryOpts, EnvImpl } from "../sys-env.js";
+import { Env, envFactory } from "../sys-env.js";
 import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
 import { WebFileService } from "../web/web-sys-abstraction.js";
 
-const once = new ResolveOnce<CFEnvActions>();
-export class CFEnvActions implements EnvActions {
-  readonly cfEnv: Map<string, string>;
-  env?: EnvImpl;
-  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
-    return once.once(() => new CFEnvActions(opts));
-  }
-  static inject(o: Record<string, string>): void {
-    const env = CFEnvActions.new({}) as CFEnvActions;
-    for (const key in o) {
-      const value = o[key];
-      if (typeof value === "string") {
-        env.env?.set(key, value);
-      }
-    }
-  }
-  private constructor(env: Partial<EnvFactoryOpts>) {
-    this.cfEnv = new Map<string, string>(Object.entries(env.presetEnv || {}));
-  }
-  active(): boolean {
-    return runtimeFn().isCFWorker;
-  }
-  register(env: Env): Env {
-    this.env = env as EnvImpl;
-    return env;
-  }
-  get(key: string): string | undefined {
-    return this.cfEnv.get(key);
-  }
-  set(key: string, value?: string): void {
-    if (value) {
-      this.cfEnv.set(key, value);
-    }
-  }
-  delete(key: string): void {
-    this.cfEnv.delete(key);
-  }
-  keys(): string[] {
-    return Array.from(this.cfEnv.keys());
-  }
-}
-
 export class CFSystemService implements SystemService {
   Env(): Env {
     return envFactory();

package/src/deno/deno-env-actions.ts

@@ -0,0 +1,57 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { runtimeFn } from "../runtime.js";
+import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
+
+interface DenoEnv {
+  get: (key: string) => string | undefined;
+  toObject: () => Record<string, string>;
+  set: (key: string, value: string) => void;
+  has: (key: string) => boolean;
+  delete: (key: string) => void;
+}
+
+const once = new ResolveOnce<DenoEnvActions>();
+export class DenoEnvActions implements EnvActions {
+  readonly #deno = globalThis as unknown as {
+    Deno: {
+      env: DenoEnv;
+    };
+  };
+
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return once.once(() => new DenoEnvActions(opts));
+  }
+
+  get _env(): DenoEnv {
+    return this.#deno.Deno.env;
+  }
+
+  readonly opts: Partial<EnvFactoryOpts>;
+  private constructor(opts: Partial<EnvFactoryOpts>) {
+    this.opts = opts;
+  }
+
+  register(env: Env): Env {
+    for (const key of env.keys()) {
+      this._env.set(key, env.get(key) || "");
+    }
+    return env;
+  }
+  active(): boolean {
+    return runtimeFn().isDeno;
+  }
+  keys(): string[] {
+    return Object.keys(this._env.toObject());
+  }
+  get(key: string): string | undefined {
+    return this._env.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this._env.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this._env.delete(key);
+  }
+}

package/src/deno/deno-sys-abstraction.ts

@@ -5,10 +5,8 @@ import {
   WrapperSysAbstractionParams,
   WrapperSysAbstraction,
 } from "../base-sys-abstraction.js";
-import { ResolveOnce } from "../resolve-once.js";
-import { runtimeFn } from "../runtime.js";
 import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import { Env, EnvActions, envFactory, EnvFactoryOpts } from "../sys-env.js";
+import { Env, envFactory } from "../sys-env.js";
 import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
 // import * as process from "node:process";
 import { DenoFileService } from "./deno-file-service.js";
@@ -19,60 +17,6 @@ const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {
   args: string[];
 };
 
-interface DenoEnv {
-  get: (key: string) => string | undefined;
-  toObject: () => Record<string, string>;
-  set: (key: string, value: string) => void;
-  has: (key: string) => boolean;
-  delete: (key: string) => void;
-}
-
-const once = new ResolveOnce<DenoEnvActions>();
-export class DenoEnvActions implements EnvActions {
-  readonly #deno = globalThis as unknown as {
-    Deno: {
-      env: DenoEnv;
-    };
-  };
-
-  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
-    return once.once(() => new DenoEnvActions(opts));
-  }
-
-  get _env(): DenoEnv {
-    return this.#deno.Deno.env;
-  }
-
-  readonly opts: Partial<EnvFactoryOpts>;
-  private constructor(opts: Partial<EnvFactoryOpts>) {
-    this.opts = opts;
-  }
-
-  register(env: Env): Env {
-    for (const key of env.keys()) {
-      this._env.set(key, env.get(key) || "");
-    }
-    return env;
-  }
-  active(): boolean {
-    return runtimeFn().isDeno;
-  }
-  keys(): string[] {
-    return Object.keys(this._env.toObject());
-  }
-  get(key: string): string | undefined {
-    return this._env.get(key);
-  }
-  set(key: string, value?: string): void {
-    if (value) {
-      this._env.set(key, value);
-    }
-  }
-  delete(key: string): void {
-    this._env.delete(key);
-  }
-}
-
 export class DenoExitServiceImpl implements ExitService {
   constructor() {
     globalThis.addEventListener("unhandledrejection", (e) => {

package/src/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@adviser/cement",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "exports": {
     ".": "./index.ts",
     "./web": "./web/index.ts",

package/src/node/node-env-actions.ts

@@ -0,0 +1,45 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { runtimeFn } from "../runtime.js";
+import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
+
+const once = new ResolveOnce<NodeEnvActions>();
+export class NodeEnvActions implements EnvActions {
+  readonly #node = globalThis as unknown as { process: { env: Record<string, string> } };
+
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return once.once(() => new NodeEnvActions(opts));
+  }
+
+  readonly opts: Partial<EnvFactoryOpts>;
+  private constructor(opts: Partial<EnvFactoryOpts>) {
+    this.opts = opts;
+  }
+
+  register(env: Env): Env {
+    for (const key of env.keys()) {
+      this._env[key] = env.get(key) || "";
+    }
+    return env;
+  }
+
+  active(): boolean {
+    return runtimeFn().isNodeIsh;
+    // typeof this.#node === "object" && typeof this.#node.process === "object" && typeof this.#node.process.env === "object";
+  }
+  readonly _env: Record<string, string> = this.active() ? this.#node.process.env : {};
+  keys(): string[] {
+    return Object.keys(this._env);
+  }
+  get(key: string): string | undefined {
+    return this._env[key];
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this._env[key] = value;
+    }
+  }
+  delete(key: string): void {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete this._env[key];
+  }
+}

package/src/node/node-sys-abstraction.ts

@@ -7,53 +7,9 @@ import {
   WrapperSysAbstractionParams,
 } from "../base-sys-abstraction.js";
 import { NodeFileService } from "./node-file-service.js";
-import { Env, EnvActions, envFactory, EnvFactoryOpts } from "../sys-env.js";
+import { Env, envFactory } from "../sys-env.js";
 import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
 import process from "node:process";
-import { runtimeFn } from "../runtime.js";
-import { ResolveOnce } from "../resolve-once.js";
-
-const once = new ResolveOnce<NodeEnvActions>();
-export class NodeEnvActions implements EnvActions {
-  readonly #node = globalThis as unknown as { process: { env: Record<string, string> } };
-
-  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
-    return once.once(() => new NodeEnvActions(opts));
-  }
-
-  readonly opts: Partial<EnvFactoryOpts>;
-  private constructor(opts: Partial<EnvFactoryOpts>) {
-    this.opts = opts;
-  }
-
-  register(env: Env): Env {
-    for (const key of env.keys()) {
-      this._env[key] = env.get(key) || "";
-    }
-    return env;
-  }
-
-  active(): boolean {
-    return runtimeFn().isNodeIsh;
-    // typeof this.#node === "object" && typeof this.#node.process === "object" && typeof this.#node.process.env === "object";
-  }
-  readonly _env: Record<string, string> = this.active() ? this.#node.process.env : {};
-  keys(): string[] {
-    return Object.keys(this._env);
-  }
-  get(key: string): string | undefined {
-    return this._env[key];
-  }
-  set(key: string, value?: string): void {
-    if (value) {
-      this._env[key] = value;
-    }
-  }
-  delete(key: string): void {
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-    delete this._env[key];
-  }
-}
 
 export class NodeExitServiceImpl implements ExitService {
   constructor() {

package/src/sys-env.ts

@@ -1,7 +1,7 @@
-import { DenoEnvActions } from "./deno/deno-sys-abstraction.js";
-import { NodeEnvActions } from "./node/node-sys-abstraction.js";
-import { BrowserEnvActions } from "./web/web-sys-abstraction.js";
-import { CFEnvActions } from "./cf/cf-sys-abstraction.js";
+import { DenoEnvActions } from "./deno/deno-env-actions.js";
+import { NodeEnvActions } from "./node/node-env-actions.js";
+import { BrowserEnvActions } from "./web/web-env-actions.js";
+import { CFEnvActions } from "./cf/cf-env-actions.js";
 import { KeyedResolvOnce } from "./resolve-once.js";
 
 export interface EnvMap {

package/src/web/web-env-actions.ts

@@ -0,0 +1,41 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { EnvActions, EnvFactoryOpts, Env } from "../sys-env.js";
+
+const once = new ResolveOnce<BrowserEnvActions>();
+export class BrowserEnvActions implements EnvActions {
+  readonly env: Map<string, string> = new Map<string, string>();
+  readonly opts: Partial<EnvFactoryOpts>;
+
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return once.once(() => new BrowserEnvActions(opts));
+  }
+
+  private constructor(opts: Partial<EnvFactoryOpts>) {
+    this.opts = opts;
+  }
+
+  get(key: string): string | undefined {
+    return this.env.get(key);
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this.env.set(key, value);
+    }
+  }
+  delete(key: string): void {
+    this.env.delete(key);
+  }
+  keys(): string[] {
+    return Array.from(this.env.keys());
+  }
+  active(): boolean {
+    return true; // that should work on every runtime
+  }
+
+  register(env: Env): Env {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis as unknown as Record<symbol, Env>;
+    browser[sym] = env;
+    return env;
+  }
+}

package/src/web/web-sys-abstraction.ts

@@ -1,49 +1,9 @@
 import { BaseSysAbstraction, WrapperSysAbstraction, WrapperSysAbstractionParams } from "../base-sys-abstraction.js";
 import { FileService, NamedWritableStream } from "../file-service.js";
-import { ResolveOnce } from "../resolve-once.js";
 import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import { Env, EnvActions, envFactory, EnvFactoryOpts } from "../sys-env.js";
+import { Env, envFactory } from "../sys-env.js";
 import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
 
-const once = new ResolveOnce<BrowserEnvActions>();
-export class BrowserEnvActions implements EnvActions {
-  readonly env: Map<string, string> = new Map<string, string>();
-  readonly opts: Partial<EnvFactoryOpts>;
-
-  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
-    return once.once(() => new BrowserEnvActions(opts));
-  }
-
-  private constructor(opts: Partial<EnvFactoryOpts>) {
-    this.opts = opts;
-  }
-
-  get(key: string): string | undefined {
-    return this.env.get(key);
-  }
-  set(key: string, value?: string): void {
-    if (value) {
-      this.env.set(key, value);
-    }
-  }
-  delete(key: string): void {
-    this.env.delete(key);
-  }
-  keys(): string[] {
-    return Array.from(this.env.keys());
-  }
-  active(): boolean {
-    return true; // that should work on every runtime
-  }
-
-  register(env: Env): Env {
-    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
-    const browser = globalThis as unknown as Record<symbol, Env>;
-    browser[sym] = env;
-    return env;
-  }
-}
-
 export class WebFileService implements FileService {
   get baseDir(): string {
     throw new Error("basedir-Method not implemented.");

package/{sys-abstraction-GNnBj2sz.d.cts → sys-abstraction-Coxu8BjZ.d.cts}

@@ -99,4 +99,4 @@ interface SysAbstraction {
     FileSystem(): FileService;
 }
 
-export { type Duration as D, type EnvActions as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, EnvImpl as a, type EnvFactoryOpts as b, type Env as c, type SysAbstraction as d, TimeMode as e, String2TimeMode as f, type EnvMap as g, type EnvFactoryFn as h, envFactory as i, TimeUnits as j, registerEnvAction as r };
+export { type Duration as D, type Env as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvMap as d, type EnvActions as e, type EnvFactoryOpts as f, type EnvFactoryFn as g, envFactory as h, EnvImpl as i, TimeUnits as j, registerEnvAction as r };

package/{sys-abstraction-GNnBj2sz.d.ts → sys-abstraction-Coxu8BjZ.d.ts}

@@ -99,4 +99,4 @@ interface SysAbstraction {
     FileSystem(): FileService;
 }
 
-export { type Duration as D, type EnvActions as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, EnvImpl as a, type EnvFactoryOpts as b, type Env as c, type SysAbstraction as d, TimeMode as e, String2TimeMode as f, type EnvMap as g, type EnvFactoryFn as h, envFactory as i, TimeUnits as j, registerEnvAction as r };
+export { type Duration as D, type Env as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvMap as d, type EnvActions as e, type EnvFactoryOpts as f, type EnvFactoryFn as g, envFactory as h, EnvImpl as i, TimeUnits as j, registerEnvAction as r };