@adviser/cement 0.3.6 → 0.3.7

package/src/cf/index.ts

@@ -1 +1,2 @@
 export * from "./cf-sys-abstraction.js";
+export * from "./cf-env-actions.js";

package/src/http_header.ts

@@ -37,7 +37,7 @@ export class HeadersImpl extends Headers {
 export class HttpHeader {
   readonly _headers: Map<string, string[]> = new Map<string, string[]>();
 
-  static from(headers?: HeadersInit | NodeJS.Dict<string | string[]> | Headers | HttpHeader): HttpHeader {
+  static from(headers?: HeadersInit | Headers | HttpHeader): HttpHeader {
     if (headers instanceof HttpHeader) {
       return headers.Clone();
     }

package/src/index.ts

@@ -19,7 +19,11 @@ export * from "./base-sys-abstraction.js";
 export * from "./bin2text.js";
 export * from "./version.js";
 export * from "./http_header.js";
-export * as utils from "./utils/index.js";
+export * from "./path-ops.js";
+export * from "./json-en-decoder.js";
+
 // ugly
+export * as utils from "./utils/index.js";
 import * as utils from "./utils/index.js";
+
 export const param = utils.param;

package/src/json-en-decoder.ts

@@ -0,0 +1,83 @@
+import { exception2Result, Result } from "./result.js";
+import { AsyncToEnDecoder, ToEnDecoder, TxtEnDecoder, Utf8EnDecoderSingleton } from "./txt-en-decoder.js";
+
+export interface JSONEndeCoder {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stringify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+  asyncStringify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<string>;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  uint8ify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): Uint8Array;
+  asyncUint8ify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<Uint8Array>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse<T>(input: ToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Result<T>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  asyncParse<T>(input: AsyncToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Promise<Result<T>>;
+}
+
+class JSONOps implements JSONEndeCoder {
+  readonly txtOps: TxtEnDecoder;
+  constructor(txtOps: TxtEnDecoder) {
+    this.txtOps = txtOps;
+  }
+  async asyncStringify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<string> {
+    const resolved = await input;
+    return this.stringify(resolved, replacer, space);
+  }
+  async asyncUint8ify<T>(
+    input: Promise<Result<T> | T>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    replacer?: (this: any, key: string, value: any) => any,
+    space?: string | number,
+  ): Promise<Uint8Array> {
+    const resolved = await input;
+    return this.uint8ify(resolved, replacer, space);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async asyncParse<T>(input: AsyncToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Promise<Result<T>> {
+    return this.parse(await this.txtOps.asyncDecode(input), reviver);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stringify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string {
+    return JSON.stringify(Result.Is(input) ? input.unwrap() : input, replacer, space);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  uint8ify<T>(input: Result<T> | T, replacer?: (this: any, key: string, value: any) => any, space?: string | number): Uint8Array {
+    return this.txtOps.encode(this.stringify(input, replacer, space));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse<T>(input: ToEnDecoder, reviver?: (this: any, key: string, value: any) => any): Result<T> {
+    return exception2Result(() => JSON.parse(this.txtOps.decode(input), reviver) as T) as Result<T>;
+  }
+}
+
+let jsonEnCoder: JSONEndeCoder;
+export function JSONEnDecoderSingleton(txtEnde?: TxtEnDecoder): JSONEndeCoder {
+  let needNew = false;
+  if (txtEnde && txtEnde !== Utf8EnDecoderSingleton()) {
+    needNew = !!txtEnde;
+    txtEnde = txtEnde ?? Utf8EnDecoderSingleton();
+  }
+  if (needNew && txtEnde) {
+    return new JSONOps(txtEnde);
+  }
+  jsonEnCoder = jsonEnCoder ?? new JSONOps(Utf8EnDecoderSingleton());
+  return jsonEnCoder;
+}

package/src/jsr.json

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

package/src/path-ops.ts

@@ -0,0 +1,30 @@
+export interface PathOps {
+  join(...args: string[]): string;
+  dirname(path: string): string;
+  basename(path: string): string;
+}
+
+class pathOpsImpl implements PathOps {
+  join(...paths: string[]): string {
+    return paths.map((i) => i.replace(/\/+$/, "")).join("/");
+  }
+  #parts(path: string): { dirname: string; basename: string } {
+    const splitted = path.split("/");
+    const last = splitted.pop();
+    if (splitted.length && last === "") {
+      return this.#parts(this.join(...splitted));
+    }
+    return {
+      dirname: this.join(...splitted),
+      basename: last ?? "",
+    };
+  }
+  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/txt-en-decoder.ts

@@ -1,21 +1,50 @@
+import { Result } from "./result.js";
+import { coerceIntoUint8, ToUInt8 } from "./utils/coerce-uint8.js";
+
+export type ToEnDecoder = ToUInt8 | string | Result<string>;
+export type AsyncToEnDecoder = ToEnDecoder | Blob | Promise<ToEnDecoder | Blob>;
+
 export interface TxtEnDecoder {
-  encode(str: string): Uint8Array;
-  decode(data: Uint8Array): string;
+  encode(input: string): Uint8Array;
+  decode(input: ToEnDecoder): string;
+  asyncDecode(input: AsyncToEnDecoder): Promise<string>;
 }
 
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
+class Utf8EnDecoder implements TxtEnDecoder {
+  readonly encoder = new TextEncoder();
+  readonly decoder = new TextDecoder();
 
-export class Utf8EnDecoder implements TxtEnDecoder {
   encode(str: string): Uint8Array {
-    return encoder.encode(str);
+    return this.encoder.encode(str);
   }
-  decode(data: Uint8Array): string {
-    return decoder.decode(data);
+  decode(data: ToEnDecoder): string {
+    if (Result.Is(data)) {
+      if (data.isErr()) {
+        throw data.Err();
+      }
+      // only for string let do coerceInto the work
+      const unwrapped = data.unwrap();
+      if (typeof unwrapped === "string") {
+        return this.decode(unwrapped);
+      }
+    }
+    if (typeof data === "string") {
+      return data;
+    }
+    return this.decoder.decode(coerceIntoUint8(data as ToUInt8).Ok());
+  }
+
+  async asyncDecode(data: AsyncToEnDecoder): Promise<string> {
+    let resolved = await data;
+    if (resolved instanceof Blob) {
+      resolved = await resolved.arrayBuffer();
+    }
+    return this.decode(resolved);
   }
 }
 
-const utf8EnDecoder = new Utf8EnDecoder();
+let utf8EnDecoder: TxtEnDecoder;
 export function Utf8EnDecoderSingleton(): TxtEnDecoder {
+  utf8EnDecoder = utf8EnDecoder ?? new Utf8EnDecoder();
   return utf8EnDecoder;
 }

package/src/utils/coerce-uint8.ts

@@ -0,0 +1,53 @@
+import { Result } from "../result.js";
+
+// Tested in txt-en-decoder.test.ts
+
+interface GlobalBuffer {
+  Buffer?: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isBuffer: (obj: any) => obj is {
+      buffer: ArrayBufferLike;
+      byteOffset: number;
+      byteLength: number;
+    };
+  };
+}
+const globalBuffer = globalThis as GlobalBuffer;
+
+export type ToUInt8Plain = Uint8Array | ArrayBuffer | ArrayBufferView;
+export type ToUInt8Async = ToUInt8Plain | Blob;
+export type ToUInt8 = ToUInt8Plain | Result<ToUInt8Plain>;
+export type AsyncToUInt8 = ToUInt8Async | Result<ToUInt8Async> | Promise<ToUInt8Async> | Promise<Result<ToUInt8Async>>;
+
+export function coerceIntoUint8(raw: ToUInt8): Result<Uint8Array> {
+  if (raw instanceof ArrayBuffer) {
+    return Result.Ok(new Uint8Array(raw));
+  }
+  if (ArrayBuffer.isView(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
+  }
+  if (raw instanceof Blob) {
+    return Result.Err("Blob not supported");
+  }
+  if (globalBuffer.Buffer && globalBuffer.Buffer.isBuffer(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
+  }
+  if (raw instanceof Uint8Array) {
+    return Result.Ok(raw);
+  }
+  if (Result.Is(raw)) {
+    if (raw.isErr()) {
+      return Result.Err(raw);
+    }
+    return coerceIntoUint8(raw.unwrap());
+  }
+  return Result.Err("Not a Uint8Array");
+}
+
+export async function asyncCoerceIntoUint8(raw: AsyncToUInt8): Promise<Result<Uint8Array>> {
+  let resolved = await raw;
+  if (resolved instanceof Blob) {
+    resolved = await resolved.arrayBuffer();
+  }
+  return coerceIntoUint8(resolved as ToUInt8);
+}

package/src/utils/index.ts

@@ -6,3 +6,6 @@ export * from "./console-write-stream.js";
 export * from "./fanout-write-stream.js";
 export * from "./get-params-result.js";
 export * from "./stripper.js";
+export * from "./sorted-object.js";
+export * from "./uint8array-equal.js";
+export * from "./coerce-uint8.js";

package/src/utils/sorted-object.ts

@@ -0,0 +1,18 @@
+export function toSortedObjectArray<T>(set?: T): Record<string, unknown>[] {
+  if (!set) return [];
+  return toSortedArray(set).map(([k, v]) => ({ [k]: v }));
+}
+
+export function toSortedArray<T>(set?: T): [string, unknown][] {
+  if (!set) return [];
+  return Object.entries(set).sort(([a], [b]) => a.localeCompare(b));
+}
+
+export function toSortedObject<S, T extends NonNullable<S>>(set?: T): T {
+  if (!set) return set as T;
+  return Object.fromEntries(toSortedArray(set)) as T;
+  // return toSortedArray(set).reduce((acc, cur) => {
+  //     acc[cur[0]] = cur[1];
+  //     return acc
+  // }, {} as Record<string, unknown>) as T;
+}

package/src/utils/uint8array-equal.ts

@@ -0,0 +1,11 @@
+export function UInt8ArrayEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}

package/{sys-abstraction-BRDT_TIU.d.cts → sys-abstraction-B-0XMe9V.d.cts}

@@ -1,4 +1,4 @@
-import { K as KeysParam, R as Result } from './get-params-result-Bhy5997x.cjs';
+import { K as KeysParam, R as Result } from './get-params-result-CXYbMEcV.cjs';
 
 interface NamedWritableStream {
     readonly name: string;
@@ -106,4 +106,4 @@ interface SysAbstraction {
     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 SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvTuple as d, type EnvMap as e, type EnvActions as f, type EnvFactoryOpts as g, type EnvFactoryFn as h, envFactory as i, EnvImpl as j, TimeUnits as k, 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 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, registerEnvAction as r };

package/{sys-abstraction-Bd0EzwO6.d.ts → sys-abstraction-CZa-VyNs.d.ts}

@@ -1,4 +1,4 @@
-import { K as KeysParam, R as Result } from './get-params-result-Bhy5997x.js';
+import { K as KeysParam, R as Result } from './get-params-result-CXYbMEcV.js';
 
 interface NamedWritableStream {
     readonly name: string;
@@ -106,4 +106,4 @@ interface SysAbstraction {
     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 SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvTuple as d, type EnvMap as e, type EnvActions as f, type EnvFactoryOpts as g, type EnvFactoryFn as h, envFactory as i, EnvImpl as j, TimeUnits as k, 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 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, registerEnvAction as r };

package/test/index.cjs

@@ -99,19 +99,159 @@ _promise = new WeakMap();
 _resolveFn = new WeakMap();
 _rejectFn = new WeakMap();
 
+// src/result.ts
+var Result = class _Result {
+  static Ok(t) {
+    return new ResultOK(t);
+  }
+  static Err(t) {
+    if (typeof t === "string") {
+      return new ResultError(new Error(t));
+    }
+    if (_Result.Is(t)) {
+      if (t.is_ok()) {
+        return new ResultError(new Error("Result Error is Ok"));
+      }
+      return t;
+    }
+    return new ResultError(t);
+  }
+  static Is(t) {
+    if (!t) {
+      return false;
+    }
+    if (t instanceof _Result) {
+      return true;
+    }
+    const rt = t;
+    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
+      return true;
+    }
+    return false;
+  }
+  isOk() {
+    return this.is_ok();
+  }
+  isErr() {
+    return this.is_err();
+  }
+  Ok() {
+    return this.unwrap();
+  }
+  Err() {
+    return this.unwrap_err();
+  }
+};
+var ResultOK = class extends Result {
+  constructor(t) {
+    super();
+    this._t = t;
+  }
+  is_ok() {
+    return true;
+  }
+  is_err() {
+    return false;
+  }
+  unwrap_err() {
+    throw new Error("Result is Ok");
+  }
+  unwrap() {
+    return this._t;
+  }
+};
+var ResultError = class extends Result {
+  constructor(t) {
+    super();
+    this._error = t;
+  }
+  is_ok() {
+    return false;
+  }
+  is_err() {
+    return true;
+  }
+  unwrap() {
+    throw new Error(`Result is Err: ${this._error}`);
+  }
+  unwrap_err() {
+    return this._error;
+  }
+};
+function exception2Result(fn) {
+  try {
+    const res = fn();
+    if (res instanceof Promise) {
+      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
+    }
+    return Result.Ok(res);
+  } catch (e) {
+    return Result.Err(e);
+  }
+}
+
+// src/utils/coerce-uint8.ts
+var globalBuffer = globalThis;
+function coerceIntoUint8(raw) {
+  if (raw instanceof ArrayBuffer) {
+    return Result.Ok(new Uint8Array(raw));
+  }
+  if (ArrayBuffer.isView(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
+  }
+  if (raw instanceof Blob) {
+    return Result.Err("Blob not supported");
+  }
+  if (globalBuffer.Buffer && globalBuffer.Buffer.isBuffer(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
+  }
+  if (raw instanceof Uint8Array) {
+    return Result.Ok(raw);
+  }
+  if (Result.Is(raw)) {
+    if (raw.isErr()) {
+      return Result.Err(raw);
+    }
+    return coerceIntoUint8(raw.unwrap());
+  }
+  return Result.Err("Not a Uint8Array");
+}
+
 // src/txt-en-decoder.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
 var Utf8EnDecoder = class {
+  constructor() {
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder();
+  }
   encode(str) {
-    return encoder.encode(str);
+    return this.encoder.encode(str);
   }
   decode(data) {
-    return decoder.decode(data);
+    if (Result.Is(data)) {
+      if (data.isErr()) {
+        throw data.Err();
+      }
+      const unwrapped = data.unwrap();
+      if (typeof unwrapped === "string") {
+        return this.decode(unwrapped);
+      }
+    }
+    if (typeof data === "string") {
+      return data;
+    }
+    return this.decoder.decode(coerceIntoUint8(data).Ok());
+  }
+  async asyncDecode(data) {
+    let resolved = await data;
+    if (resolved instanceof Blob) {
+      resolved = await resolved.arrayBuffer();
+    }
+    return this.decode(resolved);
   }
 };
-var utf8EnDecoder = new Utf8EnDecoder();
+var utf8EnDecoder;
 function Utf8EnDecoderSingleton() {
+  utf8EnDecoder = utf8EnDecoder != null ? utf8EnDecoder : new Utf8EnDecoder();
   return utf8EnDecoder;
 }
 
@@ -300,8 +440,8 @@ function logValueInternal(val, ctx) {
       }
       if (ArrayBuffer.isView(val)) {
         try {
-          const decoder2 = new TextDecoder();
-          const asStr = decoder2.decode(val);
+          const decoder = new TextDecoder();
+          const asStr = decoder.decode(val);
           const obj = JSON.parse(asStr);
           return logValueInternal(obj, ctx);
         } catch (e) {
@@ -624,14 +764,14 @@ var BaseSysAbstraction = class {
     this._fileSystem = params.FileSystem;
     this._systemService = params.SystemService;
     this._txtEnDe = params.TxtEnDecoder;
-    const decoder2 = this._txtEnDe;
+    const decoder = this._txtEnDe;
     this._stdout = CFWriteableStream((chunk) => {
-      const decoded = decoder2.decode(chunk);
+      const decoded = decoder.decode(chunk);
       console.log(decoded.trimEnd());
       return Promise.resolve();
     });
     this._stderr = CFWriteableStream((chunk) => {
-      const decoded = decoder2.decode(chunk);
+      const decoded = decoder.decode(chunk);
       console.error(decoded.trimEnd());
       return Promise.resolve();
     });
@@ -1008,97 +1148,6 @@ var CFEnvActions = class _CFEnvActions {
   }
 };
 
-// src/result.ts
-var Result = class _Result {
-  static Ok(t) {
-    return new ResultOK(t);
-  }
-  static Err(t) {
-    if (typeof t === "string") {
-      return new ResultError(new Error(t));
-    }
-    if (_Result.Is(t)) {
-      if (t.is_ok()) {
-        return new ResultError(new Error("Result Error is Ok"));
-      }
-      return t;
-    }
-    return new ResultError(t);
-  }
-  static Is(t) {
-    if (!t) {
-      return false;
-    }
-    if (t instanceof _Result) {
-      return true;
-    }
-    const rt = t;
-    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
-      return true;
-    }
-    return false;
-  }
-  isOk() {
-    return this.is_ok();
-  }
-  isErr() {
-    return this.is_err();
-  }
-  Ok() {
-    return this.unwrap();
-  }
-  Err() {
-    return this.unwrap_err();
-  }
-};
-var ResultOK = class extends Result {
-  constructor(t) {
-    super();
-    this._t = t;
-  }
-  is_ok() {
-    return true;
-  }
-  is_err() {
-    return false;
-  }
-  unwrap_err() {
-    throw new Error("Result is Ok");
-  }
-  unwrap() {
-    return this._t;
-  }
-};
-var ResultError = class extends Result {
-  constructor(t) {
-    super();
-    this._error = t;
-  }
-  is_ok() {
-    return false;
-  }
-  is_err() {
-    return true;
-  }
-  unwrap() {
-    throw new Error(`Result is Err: ${this._error}`);
-  }
-  unwrap_err() {
-    return this._error;
-  }
-};
-function exception2Result(fn) {
-  try {
-    const res = fn();
-    if (res instanceof Promise) {
-      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
-    }
-    return Result.Ok(res);
-  } catch (e) {
-    return Result.Err(e);
-  }
-}
-
 // src/utils/get-params-result.ts
 var _REQUIRED = class {
   constructor() {