@adviser/cement 0.3.5 → 0.3.7

package/index.cjs

@@ -33,10 +33,11 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   BaseSysAbstraction: () => BaseSysAbstraction,
   BuildURI: () => BuildURI,
   ConstTime: () => ConstTime,
@@ -47,6 +48,7 @@ __export(src_exports, {
   IDMode: () => IDMode,
   IdService: () => IdService,
   IsLogger: () => IsLogger,
+  JSONEnDecoderSingleton: () => JSONEnDecoderSingleton,
   JSONFormatter: () => JSONFormatter,
   Keyed: () => Keyed,
   KeyedResolvOnce: () => KeyedResolvOnce,
@@ -81,7 +83,6 @@ __export(src_exports, {
   TimeUnits: () => TimeUnits,
   TraceNode: () => TraceNode,
   URI: () => URI,
-  Utf8EnDecoder: () => Utf8EnDecoder,
   Utf8EnDecoderSingleton: () => Utf8EnDecoderSingleton,
   VERSION: () => VERSION,
   WrapperSysAbstraction: () => WrapperSysAbstraction,
@@ -96,12 +97,13 @@ __export(src_exports, {
   key: () => key,
   logValue: () => logValue,
   param: () => param2,
+  pathOps: () => pathOps,
   registerEnvAction: () => registerEnvAction,
   runtimeFn: () => runtimeFn,
   toCryptoRuntime: () => toCryptoRuntime,
   utils: () => utils_exports
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/logger-impl.ts
 var import_yaml = __toESM(require("yaml"), 1);
@@ -222,8 +224,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) {
@@ -463,14 +465,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();
     });
@@ -1207,19 +1209,75 @@ var EnvImpl = class {
   }
 };
 
+// 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");
+}
+async function asyncCoerceIntoUint8(raw) {
+  let resolved = await raw;
+  if (resolved instanceof Blob) {
+    resolved = await resolved.arrayBuffer();
+  }
+  return coerceIntoUint8(resolved);
+}
+
 // 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;
 }
 
@@ -3089,13 +3147,90 @@ var HttpHeader = class _HttpHeader {
   }
 };
 
+// src/path-ops.ts
+var _pathOpsImpl_instances, parts_fn;
+var pathOpsImpl = class {
+  constructor() {
+    __privateAdd(this, _pathOpsImpl_instances);
+  }
+  join(...paths) {
+    return paths.map((i) => i.replace(/\/+$/, "")).join("/");
+  }
+  dirname(path) {
+    return __privateMethod(this, _pathOpsImpl_instances, parts_fn).call(this, path).dirname;
+  }
+  basename(path) {
+    return __privateMethod(this, _pathOpsImpl_instances, parts_fn).call(this, path).basename;
+  }
+};
+_pathOpsImpl_instances = new WeakSet();
+parts_fn = function(path) {
+  const splitted = path.split("/");
+  const last = splitted.pop();
+  if (splitted.length && last === "") {
+    return __privateMethod(this, _pathOpsImpl_instances, parts_fn).call(this, this.join(...splitted));
+  }
+  return {
+    dirname: this.join(...splitted),
+    basename: last != null ? last : ""
+  };
+};
+var pathOps = new pathOpsImpl();
+
+// src/json-en-decoder.ts
+var JSONOps = class {
+  constructor(txtOps) {
+    this.txtOps = txtOps;
+  }
+  async asyncStringify(input, replacer, space) {
+    const resolved = await input;
+    return this.stringify(resolved, replacer, space);
+  }
+  async asyncUint8ify(input, replacer, space) {
+    const resolved = await input;
+    return this.uint8ify(resolved, replacer, space);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async asyncParse(input, reviver) {
+    return this.parse(await this.txtOps.asyncDecode(input), reviver);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stringify(input, replacer, space) {
+    return JSON.stringify(Result.Is(input) ? input.unwrap() : input, replacer, space);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  uint8ify(input, replacer, space) {
+    return this.txtOps.encode(this.stringify(input, replacer, space));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  parse(input, reviver) {
+    return exception2Result(() => JSON.parse(this.txtOps.decode(input), reviver));
+  }
+};
+var jsonEnCoder;
+function JSONEnDecoderSingleton(txtEnde) {
+  let needNew = false;
+  if (txtEnde && txtEnde !== Utf8EnDecoderSingleton()) {
+    needNew = !!txtEnde;
+    txtEnde = txtEnde != null ? txtEnde : Utf8EnDecoderSingleton();
+  }
+  if (needNew && txtEnde) {
+    return new JSONOps(txtEnde);
+  }
+  jsonEnCoder = jsonEnCoder != null ? jsonEnCoder : new JSONOps(Utf8EnDecoderSingleton());
+  return jsonEnCoder;
+}
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
   ConsoleWriterStream: () => ConsoleWriterStream,
   ConsoleWriterStreamDefaultWriter: () => ConsoleWriterStreamDefaultWriter,
   FanoutWriteStream: () => FanoutWriteStream,
+  UInt8ArrayEqual: () => UInt8ArrayEqual,
   array2stream: () => array2stream,
+  asyncCoerceIntoUint8: () => asyncCoerceIntoUint8,
+  coerceIntoUint8: () => coerceIntoUint8,
   devnull: () => devnull,
   getParamsResult: () => getParamsResult,
   param: () => param,
@@ -3106,6 +3241,10 @@ __export(utils_exports, {
   stream2uint8array: () => stream2uint8array,
   streamMap: () => streamMap,
   string2stream: () => string2stream,
+  stripper: () => stripper,
+  toSortedArray: () => toSortedArray,
+  toSortedObject: () => toSortedObject,
+  toSortedObjectArray: () => toSortedObjectArray,
   uint8array2stream: () => uint8array2stream
 });
 
@@ -3240,7 +3379,7 @@ async function stream2string(stream, maxSize) {
   }
   const reader = stream.getReader();
   let res = "";
-  const decoder2 = new TextDecoder();
+  const decoder = new TextDecoder();
   let rSize = 0;
   while (typeof maxSize === "undefined" || rSize < maxSize) {
     try {
@@ -3251,7 +3390,7 @@ async function stream2string(stream, maxSize) {
       if (maxSize && rSize + read.value.length > maxSize) {
         read.value = read.value.slice(0, maxSize - rSize);
       }
-      const block = decoder2.decode(read.value, { stream: true });
+      const block = decoder.decode(read.value, { stream: true });
       rSize += read.value.length;
       res += block;
     } catch (err) {
@@ -3293,6 +3432,33 @@ function uint8array2stream(str) {
   });
 }
 
+// src/utils/sorted-object.ts
+function toSortedObjectArray(set) {
+  if (!set) return [];
+  return toSortedArray(set).map(([k, v]) => ({ [k]: v }));
+}
+function toSortedArray(set) {
+  if (!set) return [];
+  return Object.entries(set).sort(([a], [b]) => a.localeCompare(b));
+}
+function toSortedObject(set) {
+  if (!set) return set;
+  return Object.fromEntries(toSortedArray(set));
+}
+
+// src/utils/uint8array-equal.ts
+function UInt8ArrayEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // src/index.ts
 var param2 = param;
 // Annotate the CommonJS export names for ESM import in node:
@@ -3307,6 +3473,7 @@ var param2 = param;
   IDMode,
   IdService,
   IsLogger,
+  JSONEnDecoderSingleton,
   JSONFormatter,
   Keyed,
   KeyedResolvOnce,
@@ -3341,7 +3508,6 @@ var param2 = param;
   TimeUnits,
   TraceNode,
   URI,
-  Utf8EnDecoder,
   Utf8EnDecoderSingleton,
   VERSION,
   WrapperSysAbstraction,
@@ -3356,6 +3522,7 @@ var param2 = param;
   key,
   logValue,
   param,
+  pathOps,
   registerEnvAction,
   runtimeFn,
   toCryptoRuntime,