@adviser/cement 0.0.0-jsr-t1 → 0.0.0-smoke-ci

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

@@ -0,0 +1,93 @@
+import { ResolveOnce } from "../resolve-once.js";
+import { runtimeFn } from "../runtime.js";
+import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
+
+// export interface ImportMetaEnv {
+//   import?: {
+//     meta?: {
+//       env?: Record<string, string>;
+//     };
+//   };
+// }
+export class NodeEnvActions implements EnvActions {
+  static once = new ResolveOnce<NodeEnvActions>();
+  // static cleanPrefixes = ["VITE_"];
+  // static addCleanPrefix(prefix: string): void {
+  //   if (!prefix.endsWith("_")) {
+  //     prefix += "_";
+  //   }
+  //   if (!NodeEnvActions.cleanPrefixes.includes(prefix)) {
+  //     NodeEnvActions.cleanPrefixes.push(prefix);
+  //   }
+  // }
+  readonly #node = globalThis as unknown as { process: { env: Record<string, string> } };
+  // readonly #importMetaEnv = globalThis as unknown as ImportMetaEnv;
+
+  // cleanImportMetaEnv(): Record<string, string> {
+  //   const metaEnv = this.#importMetaEnv.import?.meta?.env || {};
+  //   const cleaned: Record<string, string> = {};
+  //   for (const key of Object.keys(metaEnv)) {
+  //     const hasCleanPrefix = NodeEnvActions.cleanPrefixes.find((prefix) => key.startsWith(prefix));
+  //     if (hasCleanPrefix) {
+  //       const cleanedPrefix = key.replace(hasCleanPrefix, "");
+  //       const foundCleanPrefix = cleaned[cleanedPrefix];
+  //       if (!foundCleanPrefix) {
+  //         cleaned[cleanedPrefix] = metaEnv[key];
+  //       }
+  //     }
+  //     cleaned[key] = metaEnv[key];
+  //   }
+  //   return cleaned;
+  // }
+
+  // mergeEnv(): Record<string, string> {
+  //   // const importMetaEnv = this.cleanImportMetaEnv();
+  //   // console.debug("NodeEnvActions.mergeEnv", importMetaEnv);
+  //   const nodeEnv = Object.keys(this.#node.process.env).reduce(
+  //     (acc, key) => {
+  //       acc[key] = this.#node.process.env[key] || "";
+  //       return acc;
+  //     },
+  //     {} as Record<string, string>,
+  //   );
+  //   return { ...nodeEnv };
+  // }
+
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return NodeEnvActions.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;
+      // this.#node.process.env[key] = value; // also set in process.env
+    }
+  }
+  delete(key: string): void {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete this._env[key];
+  }
+}

package/src/node/node-file-service.ts

@@ -2,7 +2,7 @@ import path from "node:path";
 import fs from "node:fs";
 import process from "node:process";
 import { FileService, NamedWritableStream } from "../file-service.js";
-import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 
 export class NodeFileService implements FileService {
   readonly baseDir: string;
@@ -57,7 +57,7 @@ export class NodeFileService implements FileService {
     return path.isAbsolute(fname);
   }
 
-  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = Utf8EnDecoderSingleton()): Promise<void> {
+  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = TxtEnDecoderSingleton()): Promise<void> {
     const o = await this.create(fname);
     const wr = o.stream.getWriter();
     await wr.write(ende.encode(content));

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

@@ -1,15 +1,16 @@
-import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
+import { RuntimeSysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
 import {
   BaseSysAbstraction,
   ExitHandler,
   ExitService,
-  WrapperSysAbstraction,
-  WrapperSysAbstractionParams,
+  WrapperBasicSysAbstractionParams,
+  WrapperRuntimeSysAbstraction,
 } from "../base-sys-abstraction.js";
 import { NodeFileService } from "./node-file-service.js";
-import { Env, envFactory } from "../sys-env.js";
-import { Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import { TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 import process from "node:process";
+import { ResolveOnce } from "../resolve-once.js";
+import { NodeBasicSysAbstraction } from "./node-basic-sys-abstraction.js";
 
 export class NodeExitServiceImpl implements ExitService {
   constructor() {
@@ -84,14 +85,6 @@ export class NodeSystemService implements SystemService {
     this._exitService.injectExitHandlers(NodeSystemService._exitHandlers);
   }
 
-  Env(): Env {
-    return envFactory();
-  }
-
-  Args(): string[] {
-    return process.argv;
-  }
-
   OnExit(hdl: VoidFunc): VoidFunc {
     const id = crypto.randomUUID();
     NodeSystemService._exitHandlers.push({ hdl, id });
@@ -108,14 +101,18 @@ export class NodeSystemService implements SystemService {
   }
 }
 
-let my: BaseSysAbstraction | undefined = undefined;
-export function NodeSysAbstraction(param?: WrapperSysAbstractionParams): SysAbstraction {
-  if (!my) {
-    my = new BaseSysAbstraction({
-      TxtEnDecoder: param?.TxtEnDecoder || Utf8EnDecoderSingleton(),
-      FileSystem: new NodeFileService(),
-      SystemService: new NodeSystemService(),
-    });
-  }
-  return new WrapperSysAbstraction(my, param);
+const baseSysAbstraction = new ResolveOnce<BaseSysAbstraction>();
+export function NodeSysAbstraction(param?: WrapperBasicSysAbstractionParams): RuntimeSysAbstraction {
+  const my = baseSysAbstraction.once(
+    () =>
+      new BaseSysAbstraction({
+        TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+        FileSystem: new NodeFileService(),
+        SystemService: new NodeSystemService(),
+      }),
+  );
+  return new WrapperRuntimeSysAbstraction(my, {
+    basicRuntimeService: NodeBasicSysAbstraction(param),
+    ...param,
+  });
 }

package/src/option.ts

@@ -11,6 +11,13 @@ export abstract class Option<T> {
     return t instanceof Option;
   }
 
+  static From<T>(t?: T): Option<T> {
+    if (!t) {
+      return new None();
+    }
+    return new Some(t);
+  }
+
   IsNone(): boolean {
     return this.is_none();
   }

package/src/path-ops.ts

@@ -0,0 +1,48 @@
+export interface PathOps {
+  join(...args: string[]): string;
+  dirname(path: string): string;
+  basename(path: string): string;
+}
+
+class pathOpsImpl implements PathOps {
+  join(...paths: string[]): string {
+    const parts = this.#parts(paths.filter((i) => i).join("/"));
+    if (parts.dirname === "" || parts.dirname === ".") {
+      return parts.basename ? parts.basename : ".";
+    }
+    return parts.dirname + "/" + parts.basename;
+  }
+  #parts(path: string): { dirname: string; basename: string } {
+    // clean up path
+    // remove double slashes
+    // remove double dots ././
+    // remove trailing slashes
+    path = path
+      .replace(/\/+/g, "/")
+      .replace(/(\/\.\/)+/g, "/")
+      .replace(/\/+$/, "");
+    const splitted = path.split("/");
+    if (splitted.length === 1) {
+      return {
+        dirname: ".",
+        basename: splitted[0] === "." ? "" : splitted[0],
+      };
+    }
+    const basename = splitted.pop();
+    if (!basename) {
+      throw new Error("basename is undefined");
+    }
+    return {
+      dirname: splitted.join("/").replace(/^\.\//, ""),
+      basename,
+    };
+  }
+  dirname(path: string): string {
+    return this.#parts(path).dirname;
+  }
+  basename(path: string): string {
+    return this.#parts(path).basename;
+  }
+}
+
+export const pathOps: PathOps = new pathOpsImpl();

package/src/resolve-once.ts

@@ -1,23 +1,38 @@
 import { Future } from "./future.js";
+import { isPromise } from "./is-promise.js";
+import { LRUMap, LRUParam, UnregFn } from "./lru-map-set.js";
+import { Result } from "./result.js";
 
 interface ResolveSeqItem<T, C> {
   readonly future: Future<T>;
-  readonly fn: (c: C) => Promise<T>;
+  readonly fn: (c?: C) => Promise<T>;
   readonly id?: number;
 }
 
 export class ResolveSeq<T, C = void> {
-  readonly ctx: C;
+  readonly ctx?: C;
   constructor(ctx?: C) {
-    this.ctx = ctx as C;
+    this.ctx = ctx;
   }
   reset(): void {
     /* noop */
   }
-  async _step(item?: ResolveSeqItem<T, C> | undefined): Promise<void> {
+
+  readonly _flushWaiting: Future<void>[] = [];
+  flush(): Promise<void> {
+    if (this._seqFutures.length > 0) {
+      const waitForFlush = new Future<void>();
+      this._flushWaiting?.push(waitForFlush);
+      return waitForFlush.asPromise();
+    }
+    return Promise.resolve();
+  }
+  _step(item?: ResolveSeqItem<T, C>): Promise<void> {
     if (!item) {
       // done
-      return;
+      this._flushWaiting.forEach((f) => f.resolve());
+      this._flushWaiting?.splice(0, this._flushWaiting.length);
+      return Promise.resolve();
     }
     item
       .fn(this.ctx)
@@ -25,15 +40,16 @@ export class ResolveSeq<T, C = void> {
       .catch((e) => item.future.reject(e as Error))
       .finally(() => {
         this._seqFutures.shift();
-        this._step(this._seqFutures[0]);
+        void this._step(this._seqFutures[0]);
       });
+    return Promise.resolve();
   }
   readonly _seqFutures: ResolveSeqItem<T, C>[] = [];
-  async add(fn: (c: C) => Promise<T>, id?: number): Promise<T> {
+  async add(fn: (c?: C) => Promise<T>, id?: number): Promise<T> {
     const future = new Future<T>();
     this._seqFutures.push({ future, fn, id });
     if (this._seqFutures.length === 1) {
-      this._step(this._seqFutures[0]);
+      void this._step(this._seqFutures[0]);
     }
     return future.asPromise();
   }
@@ -46,27 +62,40 @@ export class ResolveOnce<T, CTX = void> {
   _onceValue?: T;
   _onceError?: Error;
   _isPromise = false;
+  _inProgress?: Future<T>;
 
-  readonly ctx: CTX;
+  readonly ctx?: CTX;
 
   constructor(ctx?: CTX) {
-    this.ctx = ctx as CTX;
+    this.ctx = ctx;
   }
 
   get ready(): boolean {
     return this._onceDone;
   }
 
+  get value(): T | undefined {
+    return this._onceDone ? this._onceValue : undefined;
+  }
+
   reset(): void {
     this._onceDone = false;
     this._onceOk = false;
     this._onceValue = undefined;
     this._onceError = undefined;
-    this._onceFutures.length = 0;
+    if (this._inProgress) {
+      const idx = this._onceFutures.findIndex((f) => f === this._inProgress);
+      if (idx >= 0) {
+        // leave the current in progress future
+        this._onceFutures.push(...this._onceFutures.splice(2).slice(1));
+      }
+    } else {
+      this._onceFutures.length = 0;
+    }
   }
 
   // T extends Option<infer U> ? U : T
-  once<R>(fn: (c: CTX) => R): R {
+  once<R>(fn: (c?: CTX) => R): R {
     if (this._onceDone) {
       if (this._onceError) {
         if (this._isPromise) {
@@ -77,8 +106,7 @@ export class ResolveOnce<T, CTX = void> {
       }
       if (this._onceOk) {
         if (this._isPromise) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          return Promise.resolve(this._onceValue!) as unknown as R;
+          return Promise.resolve(this._onceValue) as unknown as R;
         } else {
           return this._onceValue as unknown as R;
         }
@@ -93,33 +121,44 @@ export class ResolveOnce<T, CTX = void> {
         this._onceOk = true;
         this._onceDone = true;
         if (this._isPromise) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-non-null-assertion
           this._onceFutures.forEach((f) => f.resolve(this._onceValue!));
         }
         this._onceFutures.length = 0;
       };
       const catchFn = (e: Error): void => {
-        this._onceError = e as Error;
+        this._onceError = e;
         this._onceOk = false;
         this._onceValue = undefined;
         this._onceDone = true;
         if (this._isPromise) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-non-null-assertion
           this._onceFutures.forEach((f) => f.reject(this._onceError!));
         }
         this._onceFutures.length = 0;
       };
+      this._inProgress = future;
+      // let inCriticalSection = false;
       try {
         const ret = fn(this.ctx);
-        if (typeof (ret as Promise<T>).then === "function") {
+        if (isPromise(ret)) {
           this._isPromise = true;
-          (ret as Promise<T>).then(okFn).catch(catchFn);
+          // inCriticalSection = true;
+          (ret as Promise<T>)
+            .then(okFn)
+            .catch(catchFn)
+            .finally(() => {
+              this._inProgress = undefined;
+            });
         } else {
           okFn(ret as unknown as T);
         }
       } catch (e) {
         catchFn(e as Error);
       }
+      if (!this._isPromise) {
+        this._inProgress = undefined;
+      }
     }
     if (this._isPromise) {
       return future.asPromise() as unknown as R;
@@ -130,12 +169,29 @@ export class ResolveOnce<T, CTX = void> {
   }
 }
 
+export interface KeyedParam {
+  readonly lru: Partial<LRUParam>;
+}
+
 export class Keyed<T extends { reset: () => void }, K = string> {
-  private readonly _map = new Map<K, T>();
+  protected readonly _map: LRUMap<K, T>;
 
   readonly factory: (key: K) => T;
-  constructor(factory: (key: K) => T) {
+  constructor(factory: (key: K) => T, params: Partial<KeyedParam>) {
     this.factory = factory;
+    this._map = new LRUMap<K, T>(params?.lru ?? { maxEntries: -1 });
+  }
+
+  onSet(fn: (key: K, value: T) => void): UnregFn {
+    return this._map.onSet(fn);
+  }
+
+  onDelete(fn: (key: K, value: T) => void): UnregFn {
+    return this._map.onDelete(fn);
+  }
+
+  setParam(params: KeyedParam): void {
+    this._map.setParam(params.lru);
   }
 
   async asyncGet(key: () => Promise<K>): Promise<T> {
@@ -154,6 +210,13 @@ export class Keyed<T extends { reset: () => void }, K = string> {
     return keyed;
   }
 
+  has(key: K | (() => K)): boolean {
+    if (typeof key === "function") {
+      key = (key as () => K)();
+    }
+    return this._map.has(key);
+  }
+
   unget(key: K): void {
     const keyed = this._map.get(key);
     keyed?.reset();
@@ -166,14 +229,54 @@ export class Keyed<T extends { reset: () => void }, K = string> {
   }
 }
 
+interface KeyItem<K, V> {
+  readonly key: K;
+  readonly value: Result<V>;
+}
+
 export class KeyedResolvOnce<T, K = string> extends Keyed<ResolveOnce<T, K>, K> {
-  constructor() {
-    super((key) => new ResolveOnce<T, K>(key));
+  constructor(kp: Partial<KeyedParam> = {}) {
+    super((key) => new ResolveOnce<T, K>(key), kp);
+  }
+
+  *entries(): IterableIterator<KeyItem<K, T>> {
+    for (const [k, v] of this._map.entries()) {
+      if (!v._onceDone) {
+        continue;
+      }
+      if (v._onceError) {
+        yield { key: k, value: Result.Err<T>(v._onceError) };
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-non-null-assertion
+        yield { key: k, value: Result.Ok<T>(v._onceValue!) };
+      }
+    }
+  }
+
+  /**
+   *
+   * @returns The values of the resolved keys
+   */
+  values(): KeyItem<K, T>[] {
+    return Array.from(this.entries());
   }
 }
 
 export class KeyedResolvSeq<T, K = string> extends Keyed<ResolveSeq<T, K>, K> {
-  constructor() {
-    super((key) => new ResolveSeq<T, K>(key));
+  constructor(kp: Partial<KeyedParam> = {}) {
+    super((key) => new ResolveSeq<T, K>(key), kp);
   }
 }
+
+class LazyContainer<T> {
+  readonly resolveOnce = new ResolveOnce<T>();
+
+  call<R>(fn: () => R): () => ReturnType<typeof fn> {
+    return () => this.resolveOnce.once(fn);
+  }
+}
+
+export function Lazy<R>(fn: () => R): () => ReturnType<typeof fn> {
+  const lazy = new LazyContainer();
+  return lazy.call(fn);
+}

package/src/result.ts

@@ -1,11 +1,19 @@
+import { isPromise } from "./is-promise.js";
+
 export abstract class Result<T, E = Error> {
   static Ok<T = void>(t: T): Result<T, Error> {
     return new ResultOK(t);
   }
-  static Err<T, E extends Error = Error>(t: E | string): Result<T, E> {
+  static Err<T, E extends Error = Error>(t: E | string | Result<unknown, E>): Result<T, E> {
     if (typeof t === "string") {
       return new ResultError(new Error(t) as E);
     }
+    if (Result.Is(t)) {
+      if (t.is_ok()) {
+        return new ResultError(new Error("Result Error is Ok") as E);
+      }
+      return t as Result<T, E>;
+    }
     return new ResultError(t);
   }
   static Is<T>(t: unknown): t is Result<T> {
@@ -90,7 +98,7 @@ type WithResult<T> = T extends Promise<infer U> ? Promise<Result<U>> : Result<T>
 export function exception2Result<FN extends () => Promise<T> | T, T>(fn: FN): WithResult<ReturnType<FN>> {
   try {
     const res = fn();
-    if (res instanceof Promise) {
+    if (isPromise(res)) {
       return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e)) as WithResult<ReturnType<FN>>;
     }
     return Result.Ok(res) as WithResult<ReturnType<FN>>;

package/src/runtime.ts

@@ -3,34 +3,44 @@ export interface Runtime {
   isBrowser: boolean;
   isDeno: boolean;
   isReactNative: boolean;
+  isCFWorker: boolean;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isSet(value: string, ref: any = globalThis): boolean {
+function isSet(value: string, ref: Record<string, unknown> = globalThis): boolean {
   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 isSet(tail.join("."), ref[head] as Record<string, unknown>);
   }
   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 =
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     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-abstraction.ts

@@ -2,23 +2,26 @@ import { FileService } from "./file-service.js";
 import { Env } from "./sys-env.js";
 import { Time } from "./time.js";
 
-export enum TimeMode {
-  REAL = "real",
-  CONST = "const",
-  STEP = "step",
-}
+export const TimeMode = {
+  REAL: "real",
+  CONST: "const",
+  STEP: "step",
+};
+export type TimeMode = (typeof TimeMode)[keyof typeof TimeMode];
 
-export enum RandomMode {
-  CONST = "const",
-  STEP = "step",
-  RANDOM = "random",
-}
+export const RandomMode = {
+  CONST: "const",
+  STEP: "step",
+  RANDOM: "random",
+};
+export type RandomMode = (typeof RandomMode)[keyof typeof RandomMode];
 
-export enum IDMode {
-  UUID = "uuid",
-  CONST = "const",
-  STEP = "step",
-}
+export const IDMode = {
+  UUID: "uuid",
+  CONST: "const",
+  STEP: "step",
+};
+export type IDMode = (typeof IDMode)[keyof typeof IDMode];
 
 export function String2TimeMode(s?: string): TimeMode {
   switch (s?.toLowerCase()) {
@@ -36,18 +39,24 @@ export function String2TimeMode(s?: string): TimeMode {
 export type VoidFunc = () => void | Promise<void>;
 
 export interface SystemService {
-  Env(): Env;
-  Args(): string[];
   OnExit(hdl: VoidFunc): VoidFunc;
   Exit(code: number): void;
 }
 
-export interface SysAbstraction {
-  Time(): Time;
+export interface RuntimeSysAbstraction extends BasicSysAbstraction {
+  System(): SystemService;
+  FileSystem(): FileService;
+}
+
+export interface BasicRuntimeService {
   Stdout(): WritableStream<Uint8Array>;
   Stderr(): WritableStream<Uint8Array>;
+  Env(): Env;
+  Args(): string[];
+}
+
+export interface BasicSysAbstraction extends BasicRuntimeService {
+  Time(): Time;
   NextId(): string;
   Random0ToValue(value: number): number;
-  System(): SystemService;
-  FileSystem(): FileService;
 }