@adviser/cement 0.3.19 → 0.4.0

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 { 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 || TxtEnDecoderSingleton(),
-      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/sys-abstraction.ts

@@ -39,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;
 }

package/src/test/mock-logger.ts

@@ -1,8 +1,8 @@
 import { LevelHandlerImpl } from "../log-level-impl.js";
 import { Logger } from "../logger.js";
 import { LoggerImpl } from "../logger-impl.js";
-import { SysAbstraction } from "../sys-abstraction.js";
 import { LogCollector } from "./log-write-stream.js";
+import { BasicSysAbstraction } from "../sys-abstraction.js";
 
 export interface MockLoggerReturn {
   readonly logger: Logger;
@@ -10,7 +10,7 @@ export interface MockLoggerReturn {
 }
 
 export function MockLogger(params?: {
-  readonly sys?: SysAbstraction;
+  readonly sys?: BasicSysAbstraction;
   readonly pass?: WritableStreamDefaultWriter<Uint8Array>;
   moduleName?: string | string[];
   readonly disableDebug?: boolean;

package/src/txt-en-decoder.ts

@@ -1,3 +1,4 @@
+import { ResolveOnce } from "./resolve-once.js";
 import { Result } from "./result.js";
 import { coerceIntoUint8, ToUInt8 } from "./utils/coerce-uint8.js";
 
@@ -43,8 +44,7 @@ class TxtOps implements TxtEnDecoder {
   }
 }
 
-let txtEnDecoder: TxtEnDecoder;
+const txtEnDecoder = new ResolveOnce<TxtEnDecoder>();
 export function TxtEnDecoderSingleton(): TxtEnDecoder {
-  txtEnDecoder = txtEnDecoder ?? new TxtOps();
-  return txtEnDecoder;
+  return txtEnDecoder.once(() => new TxtOps());
 }

package/src/uri.ts

@@ -1,3 +1,4 @@
+import type { DeepWritable } from "ts-essentials";
 import { exception2Result, Result } from "./result.js";
 import { getParamsResult, KeysParam } from "./utils/get-params-result.js";
 import { relativePath } from "./utils/relative-path.js";
@@ -38,6 +39,7 @@ export interface URIInterface<R extends URIInterface<R>> {
   getParam<T extends string | undefined>(key: string | OneKey<string>, def?: T): T extends string ? string : string | undefined;
   getParamResult(key: string, msgFn?: (key: string) => string): Result<string>;
   getParamsResult(...keys: KeysParam): Result<Record<string, string>>;
+  match(other: CoerceURI): MatchResult;
   clone(): R;
   asURL(): URL;
   toString(): string;
@@ -45,6 +47,67 @@ export interface URIInterface<R extends URIInterface<R>> {
   asObj(...strips: StripCommand[]): Partial<HostURIObject | PathURIObject>;
 }
 
+export interface MatchResult {
+  readonly score: number;
+  readonly protocol: boolean;
+  readonly hostname: boolean;
+  readonly port: boolean;
+  readonly pathname: boolean;
+  readonly pathParts: string[];
+  readonly params: Record<string, string>;
+}
+
+function match(iref: CoerceURI, ioth: CoerceURI): MatchResult {
+  const mr: DeepWritable<MatchResult> = {
+    score: 0,
+    protocol: false,
+    hostname: false,
+    port: false,
+    pathname: false,
+    pathParts: [],
+    params: {},
+  };
+  const ref = URI.from(iref);
+  const oth = URI.from(ioth);
+  if (ref.protocol === oth.protocol) {
+    mr.score += 1;
+    mr.protocol = true;
+  }
+  try {
+    const refH = ref.hostname;
+    const refP = ref.port;
+    if (refH === oth.hostname) {
+      mr.score += 1;
+      mr.hostname = true;
+    }
+    if (refP.length && refP === oth.port) {
+      mr.score += 1;
+      mr.port = true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (e) {
+    // ignore
+  }
+  if (ref.pathname.length && ref.pathname !== "/") {
+    const pref = ref.pathname.split("/").filter((p) => p.length);
+    const poth = oth.pathname.split("/").filter((p) => p.length);
+    for (let i = 0; i < pref.length && i < poth.length; i++) {
+      if (poth[i] === pref[i]) {
+        mr.score += 1;
+        mr.pathname = true;
+        mr.pathParts.push(pref[i]);
+      }
+    }
+  }
+  for (const [key, value] of ref.getParams) {
+    if (oth.getParam(key) === value) {
+      mr.score += 1;
+      mr.params[key] = value;
+    }
+  }
+  return mr;
+}
+
 function coerceKey(key: string | OneKey<string>, def?: string): { key: string; def?: string } {
   if (typeof key === "object") {
     const keys = Object.keys(key);
@@ -274,6 +337,10 @@ export class BuildURI implements URIInterface<BuildURI> {
     return from((url) => new BuildURI(url), strURLUri, defaultProtocol);
   }
 
+  match(other: CoerceURI): MatchResult {
+    return match(this.URI(), URI.from(other));
+  }
+
   port(p: string): BuildURI {
     this._url.port = p;
     return this;
@@ -454,6 +521,10 @@ export class URI implements URIInterface<URI> {
     };
   }
 
+  match(other: CoerceURI): MatchResult {
+    return match(this, other);
+  }
+
   // if no protocol is provided, default to file:
   static merge(into: CoerceURI, from: CoerceURI, defaultProtocol = "file:"): URI {
     const intoUrl = BuildURI.from(into, defaultProtocol);

package/src/web/index.ts

@@ -1 +1 @@
-export * from "./web-sys-abstraction.js";
+export * from "./web-basic-sys-abstraction.js";

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

@@ -0,0 +1,105 @@
+import { BaseBasicSysAbstraction, WrapperBasicSysAbstraction, WrapperBasicSysAbstractionParams } from "../base-sys-abstraction.js";
+import { ResolveOnce } from "../resolve-once.js";
+import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
+import { Env, envFactory } from "../sys-env.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+import { ConsoleWriterStream } from "../utils/console-write-stream.js";
+
+// export class WebFileService implements FileService {
+//   get baseDir(): string {
+//     throw new Error("basedir-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   create(fname: string): Promise<NamedWritableStream> {
+//     throw new Error("create-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   readFileString(fname: string): Promise<string> {
+//     throw new Error("readFileString-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   writeFileString(fname: string, content: string): Promise<void> {
+//     throw new Error("writeFileString-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   abs(fname: string): string {
+//     throw new Error("abs-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   join(...paths: string[]): string {
+//     throw new Error("join-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   relative(from: string, to?: string): string {
+//     throw new Error("relative-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   dirname(fname: string): string {
+//     throw new Error("dirname-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   basename(fname: string): string {
+//     throw new Error("basename-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   nodeImport(fname: string): string {
+//     throw new Error("nodeImport-Method not implemented.");
+//   }
+//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
+//   isAbsolute(fname: string): boolean {
+//     throw new Error("isAbsolute-Method not implemented.");
+//   }
+// }
+
+class WebSystemService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  constructor(ende: TxtEnDecoder) {
+    this._txtEnDe = ende;
+  }
+  Env(): Env {
+    return envFactory();
+  }
+  Args(): string[] {
+    throw new Error("Args-Method not implemented.");
+  }
+  Stdout(): WritableStream<Uint8Array> {
+    return new ConsoleWriterStream();
+    // const decoder = this._txtEnDe;
+    // return new WritableStream({
+    //   write(chunk): Promise<void> {
+    //     return new Promise((resolve) => {
+    //       const decoded = decoder.decode(chunk);
+    //       // eslint-disable-next-line no-console
+    //       console.log(decoded.trimEnd());
+    //       resolve();
+    //     });
+    //   },
+    // });
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    const decoder = this._txtEnDe;
+    return new WritableStream({
+      write(chunk): Promise<void> {
+        return new Promise((resolve) => {
+          const decoded = decoder.decode(chunk);
+          // eslint-disable-next-line no-console
+          console.error(decoded.trimEnd());
+          resolve();
+        });
+      },
+    });
+  }
+}
+
+const baseSysAbstraction = new ResolveOnce();
+export function WebBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new WebSystemService(param?.TxtEnDecoder ?? my._txtEnDe),
+    ...param,
+  });
+}

package/{sys-abstraction-B0x6IE7r.d.ts → sys-abstraction-CeAxxg9H.d.ts}

@@ -95,19 +95,23 @@ type IDMode = (typeof IDMode)[keyof typeof IDMode];
 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;
+interface RuntimeSysAbstraction extends BasicSysAbstraction {
+    System(): SystemService;
+    FileSystem(): FileService;
+}
+interface BasicRuntimeService {
     Stdout(): WritableStream<Uint8Array>;
     Stderr(): WritableStream<Uint8Array>;
+    Env(): Env;
+    Args(): string[];
+}
+interface BasicSysAbstraction extends BasicRuntimeService {
+    Time(): Time;
     NextId(): string;
     Random0ToValue(value: number): number;
-    System(): SystemService;
-    FileSystem(): FileService;
 }
 
-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 SysAbstraction as S, Time as T, type VoidFunc as V, TimeMode as a, type SystemService as b, type EnvActions as c, EnvImpl as d, type EnvFactoryOpts as e, String2TimeMode as f, type EnvTuple as g, type EnvMap as h, type EnvFactoryFn as i, envFactory as j, TimeUnits as k, type TimeUnit as l, registerEnvAction as r };
+export { type BasicSysAbstraction as B, 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, TimeMode as a, type BasicRuntimeService as b, type EnvActions as c, EnvImpl as d, type EnvFactoryOpts as e, type RuntimeSysAbstraction as f, String2TimeMode as g, type EnvTuple as h, type EnvMap as i, type EnvFactoryFn as j, envFactory as k, TimeUnits as l, type TimeUnit as m, registerEnvAction as r };

package/{sys-abstraction-BTs3Vzy4.d.cts → sys-abstraction-DDAwGTnk.d.cts}

@@ -95,19 +95,23 @@ type IDMode = (typeof IDMode)[keyof typeof IDMode];
 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;
+interface RuntimeSysAbstraction extends BasicSysAbstraction {
+    System(): SystemService;
+    FileSystem(): FileService;
+}
+interface BasicRuntimeService {
     Stdout(): WritableStream<Uint8Array>;
     Stderr(): WritableStream<Uint8Array>;
+    Env(): Env;
+    Args(): string[];
+}
+interface BasicSysAbstraction extends BasicRuntimeService {
+    Time(): Time;
     NextId(): string;
     Random0ToValue(value: number): number;
-    System(): SystemService;
-    FileSystem(): FileService;
 }
 
-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 SysAbstraction as S, Time as T, type VoidFunc as V, TimeMode as a, type SystemService as b, type EnvActions as c, EnvImpl as d, type EnvFactoryOpts as e, String2TimeMode as f, type EnvTuple as g, type EnvMap as h, type EnvFactoryFn as i, envFactory as j, TimeUnits as k, type TimeUnit as l, registerEnvAction as r };
+export { type BasicSysAbstraction as B, 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, TimeMode as a, type BasicRuntimeService as b, type EnvActions as c, EnvImpl as d, type EnvFactoryOpts as e, type RuntimeSysAbstraction as f, String2TimeMode as g, type EnvTuple as h, type EnvMap as i, type EnvFactoryFn as j, envFactory as k, TimeUnits as l, type TimeUnit as m, registerEnvAction as r };