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

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/console-write-stream.ts

@@ -2,17 +2,16 @@ export class ConsoleWriterStreamDefaultWriter implements WritableStreamDefaultWr
   readonly desiredSize: number | null = null;
   readonly decoder: TextDecoder = new TextDecoder();
 
-  closed: Promise<undefined>;
-  ready: Promise<undefined>;
+  closed: Promise<never>;
+  ready: Promise<never>;
   readonly _stream: ConsoleWriterStream;
 
   constructor(private stream: ConsoleWriterStream) {
     this._stream = stream;
-    this.ready = Promise.resolve(undefined);
-    this.closed = Promise.resolve(undefined);
+    this.ready = Promise.resolve() as Promise<never>;
+    this.closed = Promise.resolve() as Promise<never>;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
-  abort(reason?: any): Promise<void> {
+  abort(_reason?: unknown): Promise<void> {
     throw new Error("Method not implemented.");
   }
   async close(): Promise<void> {
@@ -20,44 +19,43 @@ export class ConsoleWriterStreamDefaultWriter implements WritableStreamDefaultWr
   }
   releaseLock(): void {
     this._stream.locked = false;
-    this.ready = Promise.resolve(undefined);
-    this.closed = Promise.resolve(undefined);
+    this.ready = Promise.resolve() as Promise<never>;
+    this.closed = Promise.resolve() as Promise<never>;
   }
-  async write(chunk?: Uint8Array | undefined): Promise<void> {
-    const str = this.decoder.decode(chunk).trimEnd();
+  write(chunk?: Uint8Array): Promise<void> {
+    let strObj: string | { level: string } = this.decoder.decode(chunk).trimEnd();
     let output = "log";
     try {
-      const decode = JSON.parse(str);
-      output = decode.level;
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      strObj = JSON.parse(strObj) as { level: string };
+      output = strObj.level;
     } catch (e) {
       /* noop */
     }
     switch (output) {
       case "error":
         // eslint-disable-next-line no-console
-        console.error(str);
+        console.error(strObj);
         break;
       case "warn":
         // eslint-disable-next-line no-console
-        console.warn(str);
+        console.warn(strObj);
         break;
       default:
         // eslint-disable-next-line no-console
-        console.log(str);
+        console.log(strObj);
     }
+    return Promise.resolve();
   }
 }
 
 export class ConsoleWriterStream implements WritableStream<Uint8Array> {
   locked = false;
   _writer?: WritableStreamDefaultWriter<Uint8Array>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-  abort(reason?: any): Promise<void> {
+  abort(_reason?: unknown): Promise<void> {
     throw new Error("Method not implemented.");
   }
-  async close(): Promise<void> {
-    return;
+  close(): Promise<void> {
+    return Promise.resolve();
   }
   getWriter(): WritableStreamDefaultWriter<Uint8Array> {
     if (this.locked) {

package/src/utils/fanout-write-stream.ts

@@ -1,16 +1,15 @@
 export class FanoutWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
   readonly _writers: WritableStreamDefaultWriter<Uint8Array>[];
-  readonly ready: Promise<undefined>;
-  readonly closed: Promise<undefined>;
+  readonly ready: Promise<never>;
+  readonly closed: Promise<never>;
   readonly desiredSize: number | null = null;
   constructor(writers: WritableStreamDefaultWriter<Uint8Array>[]) {
     this._writers = writers;
-    this.ready = Promise.all(this._writers.map((w) => w.ready)).then(() => undefined);
-    this.closed = Promise.all(this._writers.map((w) => w.closed)).then(() => undefined);
+    this.ready = Promise.all(this._writers.map((w) => w.ready)) as Promise<never>;
+    this.closed = Promise.all(this._writers.map((w) => w.closed)) as Promise<never>;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  abort(reason?: any): Promise<void> {
+  abort(reason?: unknown): Promise<void> {
     return Promise.all(this._writers.map((w) => w.abort(reason))).then(() => {
       /* do nothing */
     });
@@ -24,7 +23,7 @@ export class FanoutWriteStream implements WritableStreamDefaultWriter<Uint8Array
     this._writers.map((w) => w.releaseLock());
   }
 
-  write(chunk?: Uint8Array | undefined): Promise<void> {
+  write(chunk?: Uint8Array): Promise<void> {
     return Promise.all(this._writers.map((w) => w.write(chunk))).then(() => {
       /* do nothing */
     });

package/src/utils/get-params-result.ts

@@ -0,0 +1,55 @@
+import { Result } from "../result.js";
+import { param } from "../types.js";
+
+export type MsgFn = (...keys: string[]) => string;
+export type KeysParam = (string | MsgFn | Record<string, param | number | string | boolean | undefined | null>)[];
+
+export function getParamsResult(
+  keys: KeysParam,
+  getParam: { getParam: (key: string) => string | undefined },
+): Result<Record<string, string>> {
+  const keyDef = keys.flat().reduce(
+    (acc, i) => {
+      if (typeof i === "string") {
+        acc.push({ key: i, def: undefined, isOptional: false });
+      } else if (typeof i === "object") {
+        acc.push(
+          ...Object.keys(i).map((k) => ({
+            key: k,
+            def: typeof i[k] === "string" ? i[k] : undefined,
+            isOptional: i[k] === param.OPTIONAL,
+          })),
+        );
+      }
+      return acc;
+    },
+    [] as { key: string; def?: string; isOptional: boolean }[],
+  );
+  //.filter((k) => typeof k === "string");
+  const msgFn =
+    keys.find((k) => typeof k === "function") ||
+    ((...keys: string[]): string => {
+      const msg = keys.join(",");
+      return `missing parameters: ${msg}`;
+    });
+  const errors: string[] = [];
+  const result: Record<string, string> = {};
+  for (const kd of keyDef) {
+    const val = getParam.getParam(kd.key);
+    if (val === undefined) {
+      if (typeof kd.def === "string") {
+        result[kd.key] = kd.def;
+      } else {
+        if (!kd.isOptional) {
+          errors.push(kd.key);
+        }
+      }
+    } else {
+      result[kd.key] = val;
+    }
+  }
+  if (errors.length) {
+    return Result.Err(msgFn(...errors));
+  }
+  return Result.Ok(result);
+}

package/src/utils/index.ts

@@ -4,3 +4,8 @@ export * from "./stream2string.js";
 export * from "./string2stream.js";
 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/rebuffer.ts

@@ -33,29 +33,35 @@ interface pumpState {
 }
 
 function pump(ps: pumpState, controller: ReadableStreamDefaultController<Uint8Array>, next: () => void): void {
-  ps.reader.read().then(({ done, value }) => {
-    if (done) {
-      if (ps.tmpLen > 0) {
-        controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+  ps.reader
+    .read()
+    .then(({ done, value }) => {
+      if (done) {
+        if (ps.tmpLen > 0) {
+          controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+        }
+        controller.close();
+        next();
+        return;
       }
-      controller.close();
-      next();
-      return;
-    }
-    if (ps.tmpLen + value.length > ps.chunkSize) {
-      ps.tmp.push(value);
-      const res = reChunk(ps.tmp, ps.chunkSize);
-      controller.enqueue(res.chunk);
-      ps.tmp = [res.rest];
-      ps.tmpLen = res.rest.length;
+      if (ps.tmpLen + value.length > ps.chunkSize) {
+        ps.tmp.push(value);
+        const res = reChunk(ps.tmp, ps.chunkSize);
+        controller.enqueue(res.chunk);
+        ps.tmp = [res.rest];
+        ps.tmpLen = res.rest.length;
+        next();
+        return;
+      } else if (value.length) {
+        ps.tmp.push(value);
+        ps.tmpLen += value.length;
+      }
+      pump(ps, controller, next);
+    })
+    .catch((err) => {
+      controller.error(err);
       next();
-      return;
-    } else if (value.length) {
-      ps.tmp.push(value);
-      ps.tmpLen += value.length;
-    }
-    pump(ps, controller, next);
-  });
+    });
 }
 
 export function rebuffer(a: ReadableStream<Uint8Array>, chunkSize: number): ReadableStream<Uint8Array> {

package/src/utils/relative-path.ts

@@ -0,0 +1,163 @@
+export const PartType = {
+  Slash: 0x1,
+  Root: 0x3,
+  Up: 0x4 /* /../ */,
+  Noop: 0x8 /* ./ */,
+  // RootUp = 0x8 /* ../ */,
+};
+
+export type PartType = (typeof PartType)[keyof typeof PartType];
+
+export type PathItem = string | PartType;
+
+export class Path {
+  readonly parts: PathItem[];
+  constructor(parts: PathItem[] = []) {
+    this.parts = parts;
+  }
+
+  toString(): string {
+    return this.parts
+      .map((part) => {
+        if (typeof part === "string") {
+          return part;
+        } else {
+          switch (part) {
+            case PartType.Slash:
+            case PartType.Root:
+              return "/";
+            case PartType.Up:
+              return "..";
+            default:
+              return part;
+          }
+        }
+      })
+      .join("");
+  }
+
+  add(part: PathItem): void {
+    if (this.parts.includes(PartType.Root) && part === PartType.Root) {
+      throw new Error("Cannot add absolute part to absolute path");
+    }
+    const last = this.parts[this.parts.length - 1] as PartType;
+    if (last & PartType.Slash && part === PartType.Slash) {
+      return;
+    }
+    switch (part) {
+      case ".":
+        this.parts.push(PartType.Noop);
+        return;
+      case "..":
+        part = PartType.Up;
+    }
+
+    // if (part === PartType.Up && last === PartType.Slash) {
+    //     this.parts[this.parts.length - 1] = PartType.Up
+    //     return
+    // }
+    if (last === PartType.Noop && part === PartType.Slash) {
+      if (last === PartType.Noop) {
+        this.parts.pop();
+      }
+      return;
+    }
+    this.parts.push(part);
+  }
+}
+
+export function splitPath(path: string): Path {
+  const p = new Path();
+  if (path === "") {
+    return p;
+  }
+  for (let count = 0; path.length; count++) {
+    // const ipath = path
+    if (path.match(/^\/+/)) {
+      if (count === 0) {
+        p.add(PartType.Root);
+      } else {
+        p.add(PartType.Slash);
+      }
+      path = path.replace(/^\/+/, "");
+    } else {
+      const part = path.replace(/\/.*$/, "");
+      p.add(part);
+      path = path.replace(/^[^/]+/, "");
+    }
+  }
+  return p;
+}
+
+export function pathJoin(...paths: string[]): string {
+  let prev = "";
+  const res: string[] = [];
+  // eslint-disable-next-line @typescript-eslint/prefer-for-of
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path === "") {
+      continue;
+    }
+    // i + 1 !== paths.length &&
+    if (!(prev.endsWith("/") || path.startsWith("/"))) {
+      if (prev !== "") {
+        res.push("/");
+      }
+      res.push(path);
+    } else {
+      res.push(path);
+    }
+    prev = path;
+  }
+  return res.join("");
+}
+
+export function relativePath(path: string, relative: string): string {
+  const relativeParts = splitPath(relative);
+  let result: string;
+  if (relativeParts.parts[0] === PartType.Root) {
+    result = relative;
+  } else {
+    result = pathJoin(path, relative);
+  }
+  const unoptPath = splitPath(result);
+  // console.log("What", result, unoptPath.parts)
+  const out: PathItem[] = [];
+  let topUp = false;
+  for (const part of unoptPath.parts) {
+    switch (part) {
+      case PartType.Root:
+        out.push(PartType.Root);
+        break;
+      case PartType.Up:
+        if (out.length && !topUp) {
+          const last = out.length - 1;
+          if (typeof out[last] === "string" && (out[last - 1] as PartType) == PartType.Root) {
+            out.pop();
+          } else {
+            out.pop();
+            out.pop();
+          }
+          if (out.length === 0) {
+            topUp = !topUp ? true : topUp;
+            out.push(PartType.Up);
+          }
+        } else {
+          out.push(PartType.Up);
+        }
+        break;
+      case PartType.Slash:
+        if (!((out[out.length - 1] as PartType) & PartType.Slash)) {
+          out.push(PartType.Slash);
+        }
+        break;
+      default:
+        out.push(part);
+        break;
+    }
+  }
+  return new Path(out).toString();
+  // return pathParts
+  //     .filter((part, index) => part !== relativeParts[index])
+  //     .join("")
+}

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 | undefined {
+  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/stream-map.ts

@@ -1,3 +1,5 @@
+import { isPromise } from "../is-promise.js";
+
 export interface StreamMap<T, U> {
   Map(s: T, idx: number): U | Promise<U>;
   readonly Close?: () => void;
@@ -16,7 +18,7 @@ export function streamMap<T, U>(s: ReadableStream<T>, sm: StreamMap<T, U>): Read
       }
       const promiseOrU = state.streamMap.Map(value, state.idx++);
       let mapped: U;
-      if (promiseOrU instanceof Promise || typeof (promiseOrU as { then: () => void }).then === "function") {
+      if (isPromise(promiseOrU)) {
         mapped = await promiseOrU;
       } else {
         mapped = promiseOrU;

package/src/utils/stream2string.ts

@@ -19,7 +19,7 @@ export async function stream2string(stream?: ReadableStream<Uint8Array> | null,
       rSize += read.value.length;
       res += block;
     } catch (err) {
-      return Promise.reject(err);
+      return Promise.reject(err as Error);
     }
   }
   return Promise.resolve(res);
@@ -40,7 +40,7 @@ export async function stream2uint8array(stream?: ReadableStream<Uint8Array> | nu
       }
       res = new Uint8Array([...res, ...value]);
     } catch (err) {
-      return Promise.reject(err);
+      return Promise.reject(err as Error);
     }
   }
   return Promise.resolve(res);

package/src/utils/string2stream.ts

@@ -1,6 +1,6 @@
-import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 
-export function string2stream(str: string, ende: TxtEnDecoder = Utf8EnDecoderSingleton()): ReadableStream<Uint8Array> {
+export function string2stream(str: string, ende: TxtEnDecoder = TxtEnDecoderSingleton()): ReadableStream<Uint8Array> {
   return uint8array2stream(ende.encode(str));
 }
 

package/src/utils/stripper.ts

@@ -0,0 +1,67 @@
+export type StripCommand = string | RegExp;
+
+export function stripper<T extends ArrayLike<S> | S, S>(
+  strip: StripCommand | StripCommand[],
+  obj: T,
+): T extends ArrayLike<unknown> ? Record<string, unknown>[] : Record<string, unknown> {
+  const strips = Array.isArray(strip) ? strip : [strip];
+  const restrips = strips.map((s) => {
+    if (typeof s === "string") {
+      const escaped = s.replace(/[-\\[\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\^\\$\\|]/g, "\\$&");
+      return new RegExp(`^${escaped}$`);
+    }
+    return s;
+  });
+  return localStripper(undefined, restrips, obj) as T extends ArrayLike<unknown>
+    ? Record<string, unknown>[]
+    : Record<string, unknown>;
+}
+
+function localStripper<T>(path: string | undefined, restrips: RegExp[], obj: T): unknown {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((i) => localStripper(path, restrips, i));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ret = { ...obj } as Record<string, any>;
+  const matcher = (key: string, nextPath: string): boolean => {
+    for (const re of restrips) {
+      if (re.test(key) || re.test(nextPath)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  for (const key in ret) {
+    if (Object.prototype.hasOwnProperty.call(ret, key)) {
+      let nextPath: string;
+      if (path) {
+        nextPath = [path, key].join(".");
+      } else {
+        nextPath = key;
+      }
+      if (matcher(key, nextPath)) {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete ret[key];
+        continue;
+      }
+      if (typeof ret[key] === "object") {
+        if (Array.isArray(ret[key])) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          ret[key] = ret[key].reduce((acc: unknown[], v, i) => {
+            const toDelete = matcher(key, `${nextPath}[${i}]`);
+            if (!toDelete) {
+              acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
+            }
+            return acc;
+          }, []);
+        } else {
+          ret[key] = localStripper(nextPath, restrips, ret[key]);
+        }
+      }
+    }
+  }
+  return ret;
+}

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/src/version.ts

@@ -1,3 +1,3 @@
-export const VERSION = Object.keys({
+export const VERSION: string = Object.keys({
   __packageVersion__: "xxxx",
-})[0] as string;
+})[0];

package/src/web/index.ts

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