@adviser/cement 0.3.6 → 0.3.7

package/{index-TZQHtEZo.d.cts → index-C6hvxtE7.d.cts}

@@ -1,4 +1,4 @@
-import { T as TxtEnDecoder, K as KeysParam, M as MsgFn, P as Param, g as getParamsResult, p as param } from './get-params-result-Bhy5997x.cjs';
+import { T as TxtEnDecoder, A as AsyncToUInt8, K as KeysParam, M as MsgFn, P as Param, a as ToUInt8, b as ToUInt8Async, c as ToUInt8Plain, d as asyncCoerceIntoUint8, e as coerceIntoUint8, g as getParamsResult, p as param } from './get-params-result-CXYbMEcV.cjs';
 import { S as StripCommand, s as stripper } from './stripper-BpBUUZ9p.cjs';
 
 declare function rebufferArray(a: Uint8Array[], chunkSize: number): Promise<Uint8Array[]>;
@@ -52,6 +52,13 @@ declare class FanoutWriteStream implements WritableStreamDefaultWriter<Uint8Arra
     write(chunk?: Uint8Array): Promise<void>;
 }
 
+declare function toSortedObjectArray<T>(set?: T): Record<string, unknown>[];
+declare function toSortedArray<T>(set?: T): [string, unknown][];
+declare function toSortedObject<S, T extends NonNullable<S>>(set?: T): T;
+
+declare function UInt8ArrayEqual(a: Uint8Array, b: Uint8Array): boolean;
+
+declare const utils_AsyncToUInt8: typeof AsyncToUInt8;
 type utils_ConsoleWriterStream = ConsoleWriterStream;
 declare const utils_ConsoleWriterStream: typeof ConsoleWriterStream;
 type utils_ConsoleWriterStreamDefaultWriter = ConsoleWriterStreamDefaultWriter;
@@ -63,7 +70,13 @@ declare const utils_MsgFn: typeof MsgFn;
 declare const utils_Param: typeof Param;
 type utils_StreamMap<T, U> = StreamMap<T, U>;
 declare const utils_StripCommand: typeof StripCommand;
+declare const utils_ToUInt8: typeof ToUInt8;
+declare const utils_ToUInt8Async: typeof ToUInt8Async;
+declare const utils_ToUInt8Plain: typeof ToUInt8Plain;
+declare const utils_UInt8ArrayEqual: typeof UInt8ArrayEqual;
 declare const utils_array2stream: typeof array2stream;
+declare const utils_asyncCoerceIntoUint8: typeof asyncCoerceIntoUint8;
+declare const utils_coerceIntoUint8: typeof coerceIntoUint8;
 declare const utils_devnull: typeof devnull;
 declare const utils_getParamsResult: typeof getParamsResult;
 declare const utils_param: typeof param;
@@ -75,9 +88,12 @@ declare const utils_stream2uint8array: typeof stream2uint8array;
 declare const utils_streamMap: typeof streamMap;
 declare const utils_string2stream: typeof string2stream;
 declare const utils_stripper: typeof stripper;
+declare const utils_toSortedArray: typeof toSortedArray;
+declare const utils_toSortedObject: typeof toSortedObject;
+declare const utils_toSortedObjectArray: typeof toSortedObjectArray;
 declare const utils_uint8array2stream: typeof uint8array2stream;
 declare namespace utils {
-  export { utils_ConsoleWriterStream as ConsoleWriterStream, utils_ConsoleWriterStreamDefaultWriter as ConsoleWriterStreamDefaultWriter, utils_FanoutWriteStream as FanoutWriteStream, utils_KeysParam as KeysParam, utils_MsgFn as MsgFn, utils_Param as Param, type utils_StreamMap as StreamMap, utils_StripCommand as StripCommand, utils_array2stream as array2stream, utils_devnull as devnull, utils_getParamsResult as getParamsResult, utils_param as param, utils_rebuffer as rebuffer, utils_rebufferArray as rebufferArray, utils_stream2array as stream2array, utils_stream2string as stream2string, utils_stream2uint8array as stream2uint8array, utils_streamMap as streamMap, utils_string2stream as string2stream, utils_stripper as stripper, utils_uint8array2stream as uint8array2stream };
+  export { utils_AsyncToUInt8 as AsyncToUInt8, utils_ConsoleWriterStream as ConsoleWriterStream, utils_ConsoleWriterStreamDefaultWriter as ConsoleWriterStreamDefaultWriter, utils_FanoutWriteStream as FanoutWriteStream, utils_KeysParam as KeysParam, utils_MsgFn as MsgFn, utils_Param as Param, type utils_StreamMap as StreamMap, utils_StripCommand as StripCommand, utils_ToUInt8 as ToUInt8, utils_ToUInt8Async as ToUInt8Async, utils_ToUInt8Plain as ToUInt8Plain, utils_UInt8ArrayEqual as UInt8ArrayEqual, utils_array2stream as array2stream, utils_asyncCoerceIntoUint8 as asyncCoerceIntoUint8, utils_coerceIntoUint8 as coerceIntoUint8, utils_devnull as devnull, utils_getParamsResult as getParamsResult, utils_param as param, utils_rebuffer as rebuffer, utils_rebufferArray as rebufferArray, utils_stream2array as stream2array, utils_stream2string as stream2string, utils_stream2uint8array as stream2uint8array, utils_streamMap as streamMap, utils_string2stream as string2stream, utils_stripper as stripper, utils_toSortedArray as toSortedArray, utils_toSortedObject as toSortedObject, utils_toSortedObjectArray as toSortedObjectArray, utils_uint8array2stream as uint8array2stream };
 }
 
-export { ConsoleWriterStreamDefaultWriter as C, FanoutWriteStream as F, type StreamMap as S, rebuffer as a, array2stream as b, stream2array as c, devnull as d, stream2string as e, stream2uint8array as f, string2stream as g, uint8array2stream as h, ConsoleWriterStream as i, rebufferArray as r, streamMap as s, utils as u };
+export { ConsoleWriterStreamDefaultWriter as C, FanoutWriteStream as F, type StreamMap as S, UInt8ArrayEqual as U, rebuffer as a, array2stream as b, stream2array as c, devnull as d, stream2string as e, stream2uint8array as f, string2stream as g, uint8array2stream as h, ConsoleWriterStream as i, toSortedArray as j, toSortedObject as k, rebufferArray as r, streamMap as s, toSortedObjectArray as t, utils as u };

package/index.cjs

@@ -33,6 +33,7 @@ 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 index_exports = {};
@@ -47,6 +48,7 @@ __export(index_exports, {
   IDMode: () => IDMode,
   IdService: () => IdService,
   IsLogger: () => IsLogger,
+  JSONEnDecoderSingleton: () => JSONEnDecoderSingleton,
   JSONFormatter: () => JSONFormatter,
   Keyed: () => Keyed,
   KeyedResolvOnce: () => KeyedResolvOnce,
@@ -81,7 +83,6 @@ __export(index_exports, {
   TimeUnits: () => TimeUnits,
   TraceNode: () => TraceNode,
   URI: () => URI,
-  Utf8EnDecoder: () => Utf8EnDecoder,
   Utf8EnDecoderSingleton: () => Utf8EnDecoderSingleton,
   VERSION: () => VERSION,
   WrapperSysAbstraction: () => WrapperSysAbstraction,
@@ -96,6 +97,7 @@ __export(index_exports, {
   key: () => key,
   logValue: () => logValue,
   param: () => param2,
+  pathOps: () => pathOps,
   registerEnvAction: () => registerEnvAction,
   runtimeFn: () => runtimeFn,
   toCryptoRuntime: () => toCryptoRuntime,
@@ -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,
@@ -3107,6 +3242,9 @@ __export(utils_exports, {
   streamMap: () => streamMap,
   string2stream: () => string2stream,
   stripper: () => stripper,
+  toSortedArray: () => toSortedArray,
+  toSortedObject: () => toSortedObject,
+  toSortedObjectArray: () => toSortedObjectArray,
   uint8array2stream: () => uint8array2stream
 });
 
@@ -3241,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 {
@@ -3252,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) {
@@ -3294,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:
@@ -3308,6 +3473,7 @@ var param2 = param;
   IDMode,
   IdService,
   IsLogger,
+  JSONEnDecoderSingleton,
   JSONFormatter,
   Keyed,
   KeyedResolvOnce,
@@ -3342,7 +3508,6 @@ var param2 = param;
   TimeUnits,
   TraceNode,
   URI,
-  Utf8EnDecoder,
   Utf8EnDecoderSingleton,
   VERSION,
   WrapperSysAbstraction,
@@ -3357,6 +3522,7 @@ var param2 = param;
   key,
   logValue,
   param,
+  pathOps,
   registerEnvAction,
   runtimeFn,
   toCryptoRuntime,