@adviser/cement 0.3.0 → 0.3.2

package/src/deno/index.ts

@@ -0,0 +1,2 @@
+export * from "./deno-sys-abstraction.js";
+export * from "./deno-file-service.js";

package/src/index.ts

@@ -4,8 +4,7 @@ export * from "./logger.js";
 export * from "./sys-abstraction.js";
 export * from "./sys-env.js";
 export * from "./time.js";
-export * from "./test/log-write-stream.js";
-export * from "./test/mock-logger.js";
+export * from "./test/index.js";
 export * from "./txt-en-decoder.js";
 export * from "./log-level-impl.js";
 export * from "./result.js";

package/src/jsr.json

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

package/src/logger-impl.ts

@@ -146,7 +146,7 @@ export class LoggerImpl implements Logger {
         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");
@@ -267,7 +267,7 @@ export class LoggerImpl implements Logger {
       }
       if (this.levelHandler.isStackExposed) {
         this._attributes["stack"] = logValue(
-          err.stack?.split("\n").map((s) => s.trim()),
+          err.stack?.split(/[\r\n]+/).map((s) => s.trim()),
           toLogValueCtx(this.levelHandler),
         );
       }

package/src/logger.ts

@@ -81,11 +81,18 @@ function logValueInternal(val: LogValueArg, ctx: LogValueStateInternal): LogValu
         }
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
       } 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());
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (e) {
+          // ignore
         }
       }
+      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":

package/src/node/index.ts

@@ -1,4 +1,3 @@
 export * from "./node-file-service.js";
 export * from "./node-sys-abstraction.js";
-export * from "./deno-sys-abstraction.js";
 export * from "./mock-file-service.js";

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

@@ -7,9 +7,53 @@ import {
   WrapperSysAbstractionParams,
 } from "../base-sys-abstraction.js";
 import { NodeFileService } from "./node-file-service.js";
-import { Env, envFactory } from "../sys-env.js";
+import { Env, EnvActions, envFactory, EnvFactoryOpts } 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/runtime.ts

@@ -3,6 +3,7 @@ export interface Runtime {
   isBrowser: boolean;
   isDeno: boolean;
   isReactNative: boolean;
+  isCFWorker: boolean;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -17,20 +18,29 @@ function isSet(value: string, ref: any = globalThis): boolean {
   return false;
 }
 
+// caches.default or WebSocketPair
+
 export function runtimeFn(): Runtime {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const gt: any = globalThis;
-  const isReactNative =
+  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;
   }
-  const isDeno = isSet("Deno");
+  let isDeno = isSet("Deno");
+  const isCFWorker = isSet("caches.default") && isSet("WebSocketPair");
+  if (isCFWorker) {
+    isDeno = false;
+    isNodeIsh = false;
+    isReactNative = false;
+  }
   return {
     isNodeIsh,
-    isBrowser: !(isNodeIsh || isDeno) && !isReactNative,
+    isBrowser: !(isNodeIsh || isDeno || isCFWorker || isReactNative),
     isDeno,
     isReactNative,
+    isCFWorker,
   };
 }

package/src/sys-env.ts

@@ -1,4 +1,8 @@
-import { ResolveOnce } from "./resolve-once.js";
+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 { KeyedResolvOnce } from "./resolve-once.js";
 
 export interface EnvMap {
   get(key: string): string | undefined;
@@ -11,106 +15,6 @@ export interface EnvActions extends EnvMap {
   register(env: Env): Env;
 }
 
-class NodeEnvActions implements EnvActions {
-  readonly #node = globalThis as unknown as { process: { env: Record<string, string> } };
-
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
-  constructor(opts: Partial<EnvFactoryOpts>) {
-    // do nothing
-  }
-
-  register(env: Env): Env {
-    return env;
-  }
-
-  active(): boolean {
-    return typeof this.#node === "object" && typeof this.#node.process === "object" && typeof this.#node.process.env === "object";
-  }
-  readonly _env = 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];
-  }
-}
-
-class DenoEnvActions implements EnvActions {
-  readonly #deno = globalThis as unknown as { Deno: { env: Map<string, string> } };
-
-  get _env(): Map<string, string> {
-    return this.#deno.Deno.env;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
-  constructor(opts: Partial<EnvFactoryOpts>) {
-    // do nothing
-  }
-
-  register(env: Env): Env {
-    return env;
-  }
-  active(): boolean {
-    return typeof this.#deno === "object" && typeof this.#deno.Deno === "object" && typeof this.#deno.Deno.env === "object";
-  }
-  keys(): string[] {
-    return Array.from(this._env.keys());
-  }
-  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 BrowserEnvActions implements EnvActions {
-  readonly env: Map<string, string> = new Map<string, string>();
-  readonly opts: Partial<EnvFactoryOpts>;
-  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 interface EnvFactoryOpts {
   readonly symbol: string; // default "CP_ENV" used by BrowserEnvActions
   readonly presetEnv: Map<string, string>;
@@ -126,15 +30,38 @@ export interface Env extends EnvMap {
   onSet(fn: OnSetFn, ...filter: string[]): void;
 }
 
-const _envFactory = new ResolveOnce<Env>();
-export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
-  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");
+export type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
+
+const envActions: { id: string; fn: EnvFactoryFn }[] = [
+  { id: "cf", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => CFEnvActions.new(opts) },
+  { id: "node", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => NodeEnvActions.new(opts) },
+  { id: "deno", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => DenoEnvActions.new(opts) },
+  { id: "browser", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => BrowserEnvActions.new(opts) },
+];
+
+export function registerEnvAction(fn: EnvFactoryFn): () => void {
+  const id = `id-${Math.random()}`;
+  envActions.unshift({ id, fn });
+  // rerun envFactory
+  _envFactories.unget(id);
+  return () => {
+    const index = envActions.findIndex((i) => i.id === id);
+    if (index >= 0) {
+      envActions.splice(index, 1);
     }
-    const ret = new EnvImpl(found, opts);
-    found.register(ret);
+  };
+}
+
+const _envFactories = new KeyedResolvOnce<Env>();
+export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
+  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 EnvImpl(action, opts);
+    action.register(ret);
     return ret;
   });
 }

package/src/test/index.ts

@@ -0,0 +1,2 @@
+export * from "./log-write-stream.js";
+export * from "./mock-logger.js";

package/src/uri.ts

@@ -20,8 +20,8 @@ class _OPTIONAL {
 }
 
 interface _key {
-  REQUIRED: _REQUIRED;
-  OPTIONAL: _OPTIONAL;
+  readonly REQUIRED: _REQUIRED;
+  readonly OPTIONAL: _OPTIONAL;
 }
 
 export const key: _key = {

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

@@ -1,10 +1,50 @@
 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, envFactory } from "../sys-env.js";
+import { Env, EnvActions, envFactory, EnvFactoryOpts } from "../sys-env.js";
 import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
 
-class WebFileService implements FileService {
+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

@@ -0,0 +1,102 @@
+interface NamedWritableStream {
+    readonly name: string;
+    readonly stream: WritableStream<Uint8Array>;
+}
+interface FileService {
+    readonly baseDir: string;
+    create(fname: string): Promise<NamedWritableStream>;
+    readFileString(fname: string): Promise<string>;
+    writeFileString(fname: string, content: string): Promise<void>;
+    abs(fname: string): string;
+    join(...paths: string[]): string;
+    relative(from: string, to?: string): string;
+    dirname(fname: string): string;
+    basename(fname: string): string;
+    isAbsolute(fname: string): boolean;
+}
+
+interface EnvMap {
+    get(key: string): string | undefined;
+    set(key: string, value?: string): void;
+    delete(key: string): void;
+    keys(): string[];
+}
+interface EnvActions extends EnvMap {
+    active(): boolean;
+    register(env: Env): Env;
+}
+interface EnvFactoryOpts {
+    readonly symbol: string;
+    readonly presetEnv: Map<string, string>;
+}
+type OnSetFn = (key: string, value?: string) => void;
+interface OnSetItem {
+    readonly filter: Set<string>;
+    readonly fn: OnSetFn;
+}
+interface Env extends EnvMap {
+    onSet(fn: OnSetFn, ...filter: string[]): void;
+}
+type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
+declare function registerEnvAction(fn: EnvFactoryFn): () => void;
+declare function envFactory(opts?: Partial<EnvFactoryOpts>): Env;
+declare class EnvImpl implements Env {
+    readonly _map: EnvMap;
+    constructor(map: EnvMap, opts?: Partial<EnvFactoryOpts>);
+    _updatePresets(presetEnv?: Map<string, string>): void;
+    _applyOnSet(onSet: OnSetItem[], key?: string, value?: string): void;
+    readonly _onSet: OnSetItem[];
+    keys(): string[];
+    onSet(fn: OnSetFn, ...filter: string[]): void;
+    get(key: string): string | undefined;
+    set(key: string, value?: string): void;
+    delete(key: string): void;
+}
+
+declare abstract class Time {
+    abstract Now(add?: number): Date;
+    abstract Sleep(duration: Duration): Promise<void>;
+    TimeSince(start: Date): Duration;
+}
+type Duration = number;
+declare enum TimeUnits {
+    Microsecond = 1,
+    Second = 1000,
+    Minute = 60000,
+    Hour = 3600000
+}
+
+declare enum TimeMode {
+    REAL = "real",
+    CONST = "const",
+    STEP = "step"
+}
+declare enum RandomMode {
+    CONST = "const",
+    STEP = "step",
+    RANDOM = "random"
+}
+declare enum IDMode {
+    UUID = "uuid",
+    CONST = "const",
+    STEP = "step"
+}
+declare function String2TimeMode(s?: string): TimeMode;
+type VoidFunc = () => void | Promise<void>;
+interface SystemService {
+    Env(): Env;
+    Args(): string[];
+    OnExit(hdl: VoidFunc): VoidFunc;
+    Exit(code: number): void;
+}
+interface SysAbstraction {
+    Time(): Time;
+    Stdout(): WritableStream<Uint8Array>;
+    Stderr(): WritableStream<Uint8Array>;
+    NextId(): string;
+    Random0ToValue(value: number): number;
+    System(): SystemService;
+    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 };

package/sys-abstraction-GNnBj2sz.d.ts

@@ -0,0 +1,102 @@
+interface NamedWritableStream {
+    readonly name: string;
+    readonly stream: WritableStream<Uint8Array>;
+}
+interface FileService {
+    readonly baseDir: string;
+    create(fname: string): Promise<NamedWritableStream>;
+    readFileString(fname: string): Promise<string>;
+    writeFileString(fname: string, content: string): Promise<void>;
+    abs(fname: string): string;
+    join(...paths: string[]): string;
+    relative(from: string, to?: string): string;
+    dirname(fname: string): string;
+    basename(fname: string): string;
+    isAbsolute(fname: string): boolean;
+}
+
+interface EnvMap {
+    get(key: string): string | undefined;
+    set(key: string, value?: string): void;
+    delete(key: string): void;
+    keys(): string[];
+}
+interface EnvActions extends EnvMap {
+    active(): boolean;
+    register(env: Env): Env;
+}
+interface EnvFactoryOpts {
+    readonly symbol: string;
+    readonly presetEnv: Map<string, string>;
+}
+type OnSetFn = (key: string, value?: string) => void;
+interface OnSetItem {
+    readonly filter: Set<string>;
+    readonly fn: OnSetFn;
+}
+interface Env extends EnvMap {
+    onSet(fn: OnSetFn, ...filter: string[]): void;
+}
+type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
+declare function registerEnvAction(fn: EnvFactoryFn): () => void;
+declare function envFactory(opts?: Partial<EnvFactoryOpts>): Env;
+declare class EnvImpl implements Env {
+    readonly _map: EnvMap;
+    constructor(map: EnvMap, opts?: Partial<EnvFactoryOpts>);
+    _updatePresets(presetEnv?: Map<string, string>): void;
+    _applyOnSet(onSet: OnSetItem[], key?: string, value?: string): void;
+    readonly _onSet: OnSetItem[];
+    keys(): string[];
+    onSet(fn: OnSetFn, ...filter: string[]): void;
+    get(key: string): string | undefined;
+    set(key: string, value?: string): void;
+    delete(key: string): void;
+}
+
+declare abstract class Time {
+    abstract Now(add?: number): Date;
+    abstract Sleep(duration: Duration): Promise<void>;
+    TimeSince(start: Date): Duration;
+}
+type Duration = number;
+declare enum TimeUnits {
+    Microsecond = 1,
+    Second = 1000,
+    Minute = 60000,
+    Hour = 3600000
+}
+
+declare enum TimeMode {
+    REAL = "real",
+    CONST = "const",
+    STEP = "step"
+}
+declare enum RandomMode {
+    CONST = "const",
+    STEP = "step",
+    RANDOM = "random"
+}
+declare enum IDMode {
+    UUID = "uuid",
+    CONST = "const",
+    STEP = "step"
+}
+declare function String2TimeMode(s?: string): TimeMode;
+type VoidFunc = () => void | Promise<void>;
+interface SystemService {
+    Env(): Env;
+    Args(): string[];
+    OnExit(hdl: VoidFunc): VoidFunc;
+    Exit(code: number): void;
+}
+interface SysAbstraction {
+    Time(): Time;
+    Stdout(): WritableStream<Uint8Array>;
+    Stderr(): WritableStream<Uint8Array>;
+    NextId(): string;
+    Random0ToValue(value: number): number;
+    System(): SystemService;
+    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 };