@ls-stack/utils 1.0.0

package/dist/main.js

@@ -0,0 +1,3 @@
+// src/main.ts
+throw new Error("do not use this file");
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/main.ts"],"sourcesContent":["throw new Error('do not use this file');\n"],"mappings":";AAAA,MAAM,IAAI,MAAM,sBAAsB;","names":[]}

package/dist/mathUtils.d.ts

@@ -0,0 +1,4 @@
+declare function clampMax(value: number, max: number): number;
+declare function clampMin(value: number, min: number): number;
+
+export { clampMax, clampMin };

package/dist/mathUtils.js

@@ -0,0 +1,9 @@
+import {
+  clampMax,
+  clampMin
+} from "./chunk-J66LUDLH.js";
+export {
+  clampMax,
+  clampMin
+};
+//# sourceMappingURL=mathUtils.js.map

package/dist/mathUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/objUtils.d.ts

@@ -0,0 +1,7 @@
+declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
+declare function pick<T, K extends keyof T>(obj: T | undefined, keys: K[], rename?: Partial<Record<K, string>>): Record<string, unknown>;
+declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;
+declare function mapObjectToObject<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+
+export { mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick };

package/dist/objUtils.js

@@ -0,0 +1,15 @@
+import {
+  mapArrayToObject,
+  mapObjectToObject,
+  objectTypedEntries,
+  omit,
+  pick
+} from "./chunk-SNAAKCTH.js";
+export {
+  mapArrayToObject,
+  mapObjectToObject,
+  objectTypedEntries,
+  omit,
+  pick
+};
+//# sourceMappingURL=objUtils.js.map

package/dist/objUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/parallelAsyncResultCalls.d.ts

@@ -0,0 +1,76 @@
+import { Result, NormalizedError } from './rsResult.js';
+
+type ValidMetadata = string | number | boolean | Record<string, unknown>;
+type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {
+    metadata: infer M;
+    fn: () => Promise<Result<infer V>>;
+} ? Succeeded<V, M> : never;
+type TupleRunAllFailed<T> = T extends () => Promise<Result<any>> ? {
+    metadata: undefined;
+    error: NormalizedError;
+} : T extends {
+    metadata: infer M extends ValidMetadata;
+} ? {
+    metadata: M;
+    error: NormalizedError;
+} : never;
+type TupleRunAllSettled<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> | Failed<undefined> : T extends {
+    metadata: infer M;
+    fn: () => Promise<Result<infer V>>;
+} ? Succeeded<V, M> | Failed<M> : never;
+type RunProps = {
+    delayStart?: (index: number) => number;
+};
+type Failed<M> = {
+    metadata: M;
+    error: NormalizedError;
+};
+type Succeeded<R, M> = {
+    value: R;
+    metadata: M;
+};
+declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = undefined, R = unknown> {
+    private pendingCalls;
+    alreadyRun: boolean;
+    constructor();
+    add(call: M extends undefined ? () => Promise<Result<R>> : {
+        metadata: M;
+        fn: () => Promise<Result<R>>;
+    }): this;
+    /** adds calls return tuples with infered results */
+    addTuple<T extends (M extends undefined ? () => Promise<Result<R>> : {
+        metadata: M;
+        fn: () => Promise<Result<R>>;
+    })[]>(...calls: T): {
+        runAllSettled: (props?: RunProps) => Promise<{
+            results: {
+                [I in keyof T]: TupleRunAllSettled<T[I]>;
+            };
+            allFailed: boolean;
+        }>;
+        runAll: (props?: RunProps) => Promise<Result<{
+            [I in keyof T]: TupleRunAllSuccess<T[I]>;
+        }, TupleRunAllFailed<T[number]>>>;
+    };
+    runAllSettled({ delayStart }?: RunProps): Promise<{
+        failed: Failed<M>[];
+        succeeded: Succeeded<R, M>[];
+        allFailed: boolean;
+        results: (Succeeded<R, M> | Failed<M>)[];
+    }>;
+    runAll({ delayStart, }?: {
+        delayStart?: (index: number) => number;
+    }): Promise<Result<Succeeded<R, M>[], {
+        metadata: M;
+        error: NormalizedError;
+    }>>;
+}
+/**
+ * Executes multiple asynchronous calls in parallel and collects the results in a easier to use format.
+ *
+ * @template R - The type of the result value.
+ * @template M - The type of the call metadata.
+ */
+declare function parallelAsyncResultCalls<M extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M, R>;
+
+export { parallelAsyncResultCalls };

package/dist/parallelAsyncResultCalls.js

@@ -0,0 +1,126 @@
+import {
+  sleep
+} from "./chunk-HLFWWIDK.js";
+import {
+  Result,
+  normalizeError
+} from "./chunk-HYFUWQ2E.js";
+import "./chunk-4DRNU53E.js";
+import {
+  invariant,
+  isObject
+} from "./chunk-JT3EBBCA.js";
+
+// src/parallelAsyncResultCalls.ts
+var ParallelAsyncResultCalls = class {
+  pendingCalls = [];
+  alreadyRun = false;
+  constructor() {
+  }
+  add(call) {
+    this.pendingCalls.push(
+      isObject(call) ? call : { metadata: void 0, fn: call }
+    );
+    return this;
+  }
+  /** adds calls return tuples with infered results */
+  addTuple(...calls) {
+    for (const call of calls) {
+      this.pendingCalls.push(
+        isObject(call) ? call : { metadata: void 0, fn: call }
+      );
+    }
+    return {
+      runAll: this.runAll.bind(this),
+      runAllSettled: this.runAllSettled.bind(this)
+    };
+  }
+  async runAllSettled({ delayStart } = {}) {
+    invariant(!this.alreadyRun, "Already run");
+    const asyncResults = await Promise.allSettled(
+      this.pendingCalls.map(async (call, i) => {
+        try {
+          if (delayStart) {
+            await sleep(delayStart(i));
+          }
+          const result = await call.fn();
+          return { result, callMetadata: call.metadata };
+        } catch (exception) {
+          return {
+            result: Result.normalizedUnknownErr(exception),
+            callMetadata: call.metadata
+          };
+        }
+      })
+    );
+    const failed = [];
+    const succeeded = [];
+    const results = [];
+    for (const asyncResult of asyncResults) {
+      invariant(asyncResult.status === "fulfilled");
+      const { result, callMetadata } = asyncResult.value;
+      if (result.ok) {
+        const success = { value: result.value, metadata: callMetadata };
+        results.push(success);
+        succeeded.push(success);
+      } else {
+        const fail = { metadata: callMetadata, error: result.error };
+        results.push(fail);
+        failed.push(fail);
+      }
+    }
+    const allFailed = failed.length === this.pendingCalls.length;
+    this.alreadyRun = true;
+    this.pendingCalls = [];
+    return {
+      failed,
+      succeeded,
+      allFailed,
+      results
+    };
+  }
+  async runAll({
+    delayStart
+  } = {}) {
+    invariant(!this.alreadyRun, "Already run");
+    try {
+      const asyncResults = await Promise.all(
+        this.pendingCalls.map(async (call, i) => {
+          try {
+            if (delayStart) {
+              await sleep(delayStart(i));
+            }
+            const result = await call.fn();
+            if (!result.ok) {
+              throw result.error;
+            }
+            return {
+              value: result.value,
+              metadata: call.metadata
+            };
+          } catch (exception) {
+            throw {
+              metadata: call.metadata,
+              error: normalizeError(exception)
+            };
+          }
+        })
+      );
+      return Result.ok(asyncResults);
+    } catch (exception) {
+      return Result.err(
+        exception
+      );
+    } finally {
+      this.alreadyRun = true;
+      this.pendingCalls = [];
+    }
+  }
+};
+function parallelAsyncResultCalls() {
+  return new ParallelAsyncResultCalls();
+}
+export {
+  parallelAsyncResultCalls
+};
+//# sourceMappingURL=parallelAsyncResultCalls.js.map

package/dist/parallelAsyncResultCalls.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parallelAsyncResultCalls.ts"],"sourcesContent":["import { invariant, isObject } from './assertions';\nimport { NormalizedError, Result, normalizeError } from './rsResult';\nimport { sleep } from './sleep';\n\ntype ValidMetadata = string | number | boolean | Record<string, unknown>;\n\ntype TupleRunAllSuccess<T> =\n  T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined>\n  : T extends { metadata: infer M; fn: () => Promise<Result<infer V>> } ?\n    Succeeded<V, M>\n  : never;\n\ntype TupleRunAllFailed<T> =\n  T extends () => Promise<Result<any>> ?\n    { metadata: undefined; error: NormalizedError }\n  : T extends { metadata: infer M extends ValidMetadata } ?\n    { metadata: M; error: NormalizedError }\n  : never;\n\ntype TupleRunAllSettled<T> =\n  T extends () => Promise<Result<infer V>> ?\n    Succeeded<V, undefined> | Failed<undefined>\n  : T extends { metadata: infer M; fn: () => Promise<Result<infer V>> } ?\n    Succeeded<V, M> | Failed<M>\n  : never;\n\ntype RunProps = {\n  delayStart?: (index: number) => number;\n};\n\ntype Failed<M> = {\n  metadata: M;\n  error: NormalizedError;\n};\ntype Succeeded<R, M> = {\n  value: R;\n  metadata: M;\n};\n\nclass ParallelAsyncResultCalls<\n  M extends ValidMetadata | undefined = undefined,\n  R = unknown,\n> {\n  private pendingCalls: {\n    metadata: M;\n    fn: () => Promise<Result<R>>;\n  }[] = [];\n  alreadyRun = false;\n\n  constructor() {}\n\n  add(\n    call: M extends undefined ? () => Promise<Result<R>>\n    : { metadata: M; fn: () => Promise<Result<R>> },\n  ) {\n    this.pendingCalls.push(\n      isObject(call) ? call : { metadata: undefined as any, fn: call },\n    );\n\n    return this;\n  }\n\n  /** adds calls return tuples with infered results */\n  addTuple<\n    T extends (M extends undefined ? () => Promise<Result<R>>\n    : { metadata: M; fn: () => Promise<Result<R>> })[],\n  >(\n    ...calls: T\n  ): {\n    runAllSettled: (props?: RunProps) => Promise<{\n      results: {\n        [I in keyof T]: TupleRunAllSettled<T[I]>;\n      };\n      allFailed: boolean;\n    }>;\n    runAll: (props?: RunProps) => Promise<\n      Result<\n        {\n          [I in keyof T]: TupleRunAllSuccess<T[I]>;\n        },\n        TupleRunAllFailed<T[number]>\n      >\n    >;\n  } {\n    for (const call of calls) {\n      this.pendingCalls.push(\n        isObject(call) ? call : { metadata: undefined as any, fn: call },\n      );\n    }\n\n    return {\n      runAll: this.runAll.bind(this) as any,\n      runAllSettled: this.runAllSettled.bind(this) as any,\n    };\n  }\n\n  async runAllSettled({ delayStart }: RunProps = {}) {\n    invariant(!this.alreadyRun, 'Already run');\n\n    const asyncResults = await Promise.allSettled(\n      this.pendingCalls.map(async (call, i) => {\n        try {\n          if (delayStart) {\n            await sleep(delayStart(i));\n          }\n\n          const result = await call.fn();\n\n          return { result, callMetadata: call.metadata };\n        } catch (exception) {\n          return {\n            result: Result.normalizedUnknownErr(exception),\n            callMetadata: call.metadata,\n          };\n        }\n      }),\n    );\n\n    const failed: Failed<M>[] = [];\n    const succeeded: Succeeded<R, M>[] = [];\n    const results: (Failed<M> | Succeeded<R, M>)[] = [];\n\n    for (const asyncResult of asyncResults) {\n      invariant(asyncResult.status === 'fulfilled');\n\n      const { result, callMetadata } = asyncResult.value;\n\n      if (result.ok) {\n        const success = { value: result.value, metadata: callMetadata };\n        results.push(success);\n        succeeded.push(success);\n      } else {\n        const fail = { metadata: callMetadata, error: result.error };\n        results.push(fail);\n        failed.push(fail);\n      }\n    }\n\n    const allFailed = failed.length === this.pendingCalls.length;\n\n    this.alreadyRun = true;\n    this.pendingCalls = [];\n\n    return {\n      failed,\n      succeeded,\n      allFailed,\n      results,\n    };\n  }\n\n  async runAll({\n    delayStart,\n  }: { delayStart?: (index: number) => number } = {}): Promise<\n    Result<\n      Succeeded<R, M>[],\n      {\n        metadata: M;\n        error: NormalizedError;\n      }\n    >\n  > {\n    invariant(!this.alreadyRun, 'Already run');\n\n    try {\n      const asyncResults = await Promise.all(\n        this.pendingCalls.map(async (call, i) => {\n          try {\n            if (delayStart) {\n              await sleep(delayStart(i));\n            }\n\n            const result = await call.fn();\n\n            if (!result.ok) {\n              throw result.error;\n            }\n\n            return {\n              value: result.value,\n              metadata: call.metadata,\n            };\n          } catch (exception) {\n            throw {\n              metadata: call.metadata,\n              error: normalizeError(exception),\n            };\n          }\n        }),\n      );\n\n      return Result.ok(asyncResults);\n    } catch (exception) {\n      return Result.err(\n        exception as {\n          metadata: M;\n          error: NormalizedError;\n        },\n      );\n    } finally {\n      this.alreadyRun = true;\n      this.pendingCalls = [];\n    }\n  }\n}\n\n/**\n * Executes multiple asynchronous calls in parallel and collects the results in a easier to use format.\n *\n * @template R - The type of the result value.\n * @template M - The type of the call metadata.\n */\nexport function parallelAsyncResultCalls<\n  M extends ValidMetadata | undefined = undefined,\n  R = unknown,\n>() {\n  return new ParallelAsyncResultCalls<M, R>();\n}\n"],"mappings":"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","names":[]}

package/dist/promiseUtils.d.ts

@@ -0,0 +1,8 @@
+type Deferred<T> = {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason: unknown) => void;
+    promise: Promise<T>;
+};
+declare function defer<T = void>(): Deferred<T>;
+
+export { defer };

package/dist/promiseUtils.js

@@ -0,0 +1,14 @@
+// src/promiseUtils.ts
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { resolve, reject, promise };
+}
+export {
+  defer
+};
+//# sourceMappingURL=promiseUtils.js.map

package/dist/promiseUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/promiseUtils.ts"],"sourcesContent":["type Deferred<T> = {\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (reason: unknown) => void;\n  promise: Promise<T>;\n};\n\nexport function defer<T = void>(): Deferred<T> {\n  let resolve!: (value: T | PromiseLike<T>) => void;\n  let reject!: (reason: unknown) => void;\n  const promise = new Promise<T>((_resolve, _reject) => {\n    resolve = _resolve;\n    reject = _reject;\n  });\n  return { resolve, reject, promise };\n}\n"],"mappings":";AAMO,SAAS,QAA+B;AAC7C,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI,QAAW,CAAC,UAAU,YAAY;AACpD,cAAU;AACV,aAAS;AAAA,EACX,CAAC;AACD,SAAO,EAAE,SAAS,QAAQ,QAAQ;AACpC;","names":[]}

package/dist/rsResult.d.ts

@@ -0,0 +1,118 @@
+type Ok<T> = {
+    ok: true;
+    error: false;
+    value: T;
+};
+type NormalizedErrorResultProps = {
+    id: string;
+    message: string;
+    code?: number;
+    metadata?: ValidErrorMetadata;
+};
+type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+type Err<E extends ResultValidErrors> = {
+    ok: false;
+    error: E;
+    errorResult: () => Result<any, E>;
+    normalizedErrorResult: (normalizedErr: E extends NormalizedError ? {
+        withMetadata: ValidErrorMetadata;
+    } | NormalizedErrorResultProps : NormalizedErrorResultProps) => Result<any, NormalizedError>;
+};
+type Unwrap<E, T> = IsExactlyAny<E> extends true ? any : E extends Error ? () => T : unknown;
+type ResultMethods<T, E> = {
+    /** Returns the value if the result is Ok, otherwise returns null */
+    unwrapOrNull: () => T | null;
+    /** Returns the value if the result is Ok, otherwise returns the provided default value */
+    unwrapOr: <R extends T>(defaultValue: R) => T | R;
+    unwrap: Unwrap<E, T>;
+};
+type OkResult<T, E extends ResultValidErrors, M = any> = Ok<T> & ResultMethods<M, E>;
+type ResultValidErrors = Error | Record<string, unknown> | [string];
+declare function ok(): OkResult<void, any>;
+declare function ok<T>(value: T): OkResult<T, any>;
+type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T, E>;
+declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
+declare function normalizedUnknownErr(error: unknown): ErrResult<NormalizedError<string>, any>;
+declare function normalizedErr(message: string): ErrResult<NormalizedError>;
+declare function normalizedErr<T extends string>(id: T, message: string): ErrResult<NormalizedError<T>>;
+declare function normalizedErr<T extends string>(errorProps: {
+    id: T;
+    message: string;
+    code?: number;
+    cause?: Error;
+    metadata?: ValidErrorMetadata;
+}): ErrResult<NormalizedError<T>>;
+/** Unwraps a promise result */
+declare function unwrap<T>(result: Promise<Result<T, Error>>): Promise<T>;
+/**
+ * Util for implementing something similar to Result<T, E> in Rust, for better error handling.
+ *
+ * Usage:
+ *
+ * @example
+ * function doSomething(): Result<string, Error> {
+ *  if (something) {
+ *    return ok('success');
+ *  }
+ *
+ *  return err(new Error('something went wrong'));
+ * }
+ *
+ * const result = doSomething();
+ *
+ * if (result.ok) {
+ *   // result.value is a string
+ * } else {
+ *   // result.error is an Error
+ * }
+ */
+type Result<T, E extends ResultValidErrors = NormalizedError> = OkResult<T, E, T> | ErrResult<E, T>;
+declare const Result: {
+    ok: typeof ok;
+    err: typeof err;
+    normalizedErr: typeof normalizedErr;
+    normalizedUnknownErr: typeof normalizedUnknownErr;
+    unwrap: typeof unwrap;
+};
+/** transfor a function in a result function */
+declare function resultify<T, E extends ResultValidErrors = NormalizedError>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
+/** transform a async function in a result function */
+declare function asyncResultify<T, E extends Error = NormalizedError>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+type ValidErrorMetadata = Record<string, unknown> | undefined;
+declare function setNormalizedErrorSideEffects(callback: (normalizedError: NormalizedError) => void): void;
+declare class NormalizedError<T = string> extends Error {
+    id: T;
+    metadata?: ValidErrorMetadata;
+    cause?: Error;
+    code: number;
+    constructor({ id, message, metadata, cause, code, }: {
+        id: T;
+        message: string;
+        metadata?: ValidErrorMetadata;
+        cause?: Error;
+        code?: number;
+    });
+    toString(): string;
+    toJSON(): {
+        id: T;
+        message: string;
+        metadata: ValidErrorMetadata;
+        code: number;
+        cause: string | (Error & Record<"toJSON", unknown>) | undefined;
+    };
+}
+declare class NormalizedErrorWithMetadata<M extends ValidErrorMetadata, T = string> extends NormalizedError<T> {
+    metadata: M;
+    constructor(props: {
+        id: T;
+        message: string;
+        metadata: M;
+        cause?: Error;
+    } | {
+        error: NormalizedError<T>;
+        metadata: M;
+    });
+}
+declare function normalizeError(error: unknown): NormalizedError;
+
+export { NormalizedError, NormalizedErrorWithMetadata, Result, type ValidErrorMetadata, asyncResultify, normalizeError, resultify, setNormalizedErrorSideEffects };

package/dist/rsResult.js

@@ -0,0 +1,21 @@
+import {
+  NormalizedError,
+  NormalizedErrorWithMetadata,
+  Result,
+  asyncResultify,
+  normalizeError,
+  resultify,
+  setNormalizedErrorSideEffects
+} from "./chunk-HYFUWQ2E.js";
+import "./chunk-4DRNU53E.js";
+import "./chunk-JT3EBBCA.js";
+export {
+  NormalizedError,
+  NormalizedErrorWithMetadata,
+  Result,
+  asyncResultify,
+  normalizeError,
+  resultify,
+  setNormalizedErrorSideEffects
+};
+//# sourceMappingURL=rsResult.js.map

package/dist/rsResult.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runShellCmd.d.ts

@@ -0,0 +1,15 @@
+type CmdResult = {
+    label: string | null;
+    out: string;
+    error: boolean;
+    stdout: string;
+    stderr: string;
+};
+declare function runCmd(label: string | null, command: string | string[], { mock, silent, cwd, }?: {
+    mock?: CmdResult;
+    silent?: boolean;
+    cwd?: string;
+}): Promise<CmdResult>;
+declare function concurrentCmd(label: string, cmd: string, onResult: (result: CmdResult) => void): Promise<() => void>;
+
+export { concurrentCmd, runCmd };

package/dist/runShellCmd.js

@@ -0,0 +1,71 @@
+// src/runShellCmd.ts
+import { spawn } from "child_process";
+process.env.FORCE_COLOR = true;
+function runCmd(label, command, {
+  mock,
+  silent,
+  cwd = process.cwd()
+} = {}) {
+  if (mock)
+    return Promise.resolve(mock);
+  if (label && !silent) {
+    console.log(`----${label}----`);
+    console.time("\u2705");
+  }
+  return new Promise((resolve) => {
+    const [cmd = "", ...args] = Array.isArray(command) ? command : command.split(" ");
+    const child = spawn(cmd, args, {
+      cwd
+    });
+    let stdout = "";
+    let stderr = "";
+    let out = "";
+    child.stdout.on("data", (data) => {
+      stdout += String(data);
+      out += String(data);
+      if (!silent) {
+        console.log(String(data));
+      }
+    });
+    child.stderr.on("data", (data) => {
+      stderr += String(data);
+      out += String(data);
+      if (!silent) {
+        console.log(String(data));
+      }
+    });
+    child.on("close", (code) => {
+      const hasError = code !== 0;
+      if (!silent && label) {
+        if (!hasError) {
+          console.timeEnd("\u2705");
+        }
+        console.log("\n");
+      }
+      resolve({ label, out, stderr, stdout, error: hasError });
+    });
+  });
+}
+async function concurrentCmd(label, cmd, onResult) {
+  const start = Date.now();
+  const result = await runCmd(label, cmd, { silent: true });
+  onResult(result);
+  const ellapsedSeconds = (Date.now() - start) / 1e3;
+  console.log(
+    `${result.error ? "\u{1F534}" : "\u2705"} ${result.label} (${ellapsedSeconds.toFixed(
+      1
+    )}s)`
+  );
+  return () => {
+    if (result.error) {
+      console.log(`\u274C ${result.label} errors:`);
+      console.log(result.out);
+      console.log("\n");
+    }
+  };
+}
+export {
+  concurrentCmd,
+  runCmd
+};
+//# sourceMappingURL=runShellCmd.js.map

package/dist/runShellCmd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runShellCmd.ts"],"sourcesContent":["/* eslint-disable no-console -- we need console here to print errors */\n\ntype CmdResult = {\n  label: string | null;\n  out: string;\n  error: boolean;\n  stdout: string;\n  stderr: string;\n};\n\nimport { spawn } from 'child_process';\n\n(process.env as any).FORCE_COLOR = true;\n\nexport function runCmd(\n  label: string | null,\n  command: string | string[],\n  {\n    mock,\n    silent,\n    cwd = process.cwd(),\n  }: { mock?: CmdResult; silent?: boolean; cwd?: string } = {},\n): Promise<CmdResult> {\n  if (mock) return Promise.resolve(mock);\n\n  if (label && !silent) {\n    console.log(`----${label}----`);\n    console.time('✅');\n  }\n\n  return new Promise((resolve) => {\n    const [cmd = '', ...args] =\n      Array.isArray(command) ? command : command.split(' ');\n    const child = spawn(cmd, args, {\n      cwd,\n    });\n\n    let stdout = '';\n    let stderr = '';\n    let out = '';\n\n    child.stdout.on('data', (data) => {\n      stdout += String(data);\n      out += String(data);\n\n      if (!silent) {\n        console.log(String(data));\n      }\n    });\n\n    child.stderr.on('data', (data) => {\n      stderr += String(data);\n      out += String(data);\n\n      if (!silent) {\n        console.log(String(data));\n      }\n    });\n\n    child.on('close', (code) => {\n      const hasError = code !== 0;\n\n      if (!silent && label) {\n        if (!hasError) {\n          console.timeEnd('✅');\n        }\n\n        console.log('\\n');\n      }\n\n      resolve({ label, out, stderr, stdout, error: hasError });\n    });\n  });\n}\n\nexport async function concurrentCmd(\n  label: string,\n  cmd: string,\n  onResult: (result: CmdResult) => void,\n) {\n  const start = Date.now();\n\n  const result = await runCmd(label, cmd, { silent: true });\n\n  onResult(result);\n\n  const ellapsedSeconds = (Date.now() - start) / 1000;\n\n  console.log(\n    `${result.error ? '🔴' : '✅'} ${result.label} (${ellapsedSeconds.toFixed(\n      1,\n    )}s)`,\n  );\n\n  return () => {\n    if (result.error) {\n      console.log(`❌ ${result.label} errors:`);\n      console.log(result.out);\n      console.log('\\n');\n    }\n  };\n}\n"],"mappings":";AAUA,SAAS,aAAa;AAErB,QAAQ,IAAY,cAAc;AAE5B,SAAS,OACd,OACA,SACA;AAAA,EACE;AAAA,EACA;AAAA,EACA,MAAM,QAAQ,IAAI;AACpB,IAA0D,CAAC,GACvC;AACpB,MAAI;AAAM,WAAO,QAAQ,QAAQ,IAAI;AAErC,MAAI,SAAS,CAAC,QAAQ;AACpB,YAAQ,IAAI,OAAO,KAAK,MAAM;AAC9B,YAAQ,KAAK,QAAG;AAAA,EAClB;AAEA,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,CAAC,MAAM,IAAI,GAAG,IAAI,IACtB,MAAM,QAAQ,OAAO,IAAI,UAAU,QAAQ,MAAM,GAAG;AACtD,UAAM,QAAQ,MAAM,KAAK,MAAM;AAAA,MAC7B;AAAA,IACF,CAAC;AAED,QAAI,SAAS;AACb,QAAI,SAAS;AACb,QAAI,MAAM;AAEV,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAS;AAChC,gBAAU,OAAO,IAAI;AACrB,aAAO,OAAO,IAAI;AAElB,UAAI,CAAC,QAAQ;AACX,gBAAQ,IAAI,OAAO,IAAI,CAAC;AAAA,MAC1B;AAAA,IACF,CAAC;AAED,UAAM,OAAO,GAAG,QAAQ,CAAC,SAAS;AAChC,gBAAU,OAAO,IAAI;AACrB,aAAO,OAAO,IAAI;AAElB,UAAI,CAAC,QAAQ;AACX,gBAAQ,IAAI,OAAO,IAAI,CAAC;AAAA,MAC1B;AAAA,IACF,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,SAAS;AAC1B,YAAM,WAAW,SAAS;AAE1B,UAAI,CAAC,UAAU,OAAO;AACpB,YAAI,CAAC,UAAU;AACb,kBAAQ,QAAQ,QAAG;AAAA,QACrB;AAEA,gBAAQ,IAAI,IAAI;AAAA,MAClB;AAEA,cAAQ,EAAE,OAAO,KAAK,QAAQ,QAAQ,OAAO,SAAS,CAAC;AAAA,IACzD,CAAC;AAAA,EACH,CAAC;AACH;AAEA,eAAsB,cACpB,OACA,KACA,UACA;AACA,QAAM,QAAQ,KAAK,IAAI;AAEvB,QAAM,SAAS,MAAM,OAAO,OAAO,KAAK,EAAE,QAAQ,KAAK,CAAC;AAExD,WAAS,MAAM;AAEf,QAAM,mBAAmB,KAAK,IAAI,IAAI,SAAS;AAE/C,UAAQ;AAAA,IACN,GAAG,OAAO,QAAQ,cAAO,QAAG,IAAI,OAAO,KAAK,KAAK,gBAAgB;AAAA,MAC/D;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO,MAAM;AACX,QAAI,OAAO,OAAO;AAChB,cAAQ,IAAI,UAAK,OAAO,KAAK,UAAU;AACvC,cAAQ,IAAI,OAAO,GAAG;AACtB,cAAQ,IAAI,IAAI;AAAA,IAClB;AAAA,EACF;AACF;","names":[]}

package/dist/shallowEqual.d.ts

@@ -0,0 +1,4 @@
+/** shallow equal version of https://github.com/lukeed/dequal */
+declare function shallowEqual(foo: any, bar: any): boolean;
+
+export { shallowEqual };

package/dist/shallowEqual.js

@@ -0,0 +1,74 @@
+// src/shallowEqual.ts
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+  for (key of iter.keys()) {
+    if (key === tar)
+      return key;
+  }
+}
+function shallowEqual(foo, bar) {
+  var ctor, len, tmp;
+  if (foo === bar)
+    return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date)
+      return shallowEqual(foo.getTime(), bar.getTime());
+    if (ctor === RegExp)
+      return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && foo[len] === bar[len])
+          ;
+      }
+      return len === -1;
+    }
+    if (ctor === Set) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len;
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp)
+            return false;
+        }
+        if (!bar.has(tmp))
+          return false;
+      }
+      return true;
+    }
+    if (ctor === Map) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len[0];
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp);
+          if (!tmp)
+            return false;
+        }
+        if (len[1] !== bar.get(tmp)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (!ctor || typeof foo === "object") {
+      len = 0;
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor))
+          return false;
+        if (!(ctor in bar) || !(foo[ctor] === bar[ctor]))
+          return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
+export {
+  shallowEqual
+};
+//# sourceMappingURL=shallowEqual.js.map

package/dist/shallowEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shallowEqual.ts"],"sourcesContent":["/* eslint-disable */\nvar has = Object.prototype.hasOwnProperty;\n\nfunction find(iter: any[], tar: any, key?: any) {\n  for (key of iter.keys()) {\n    if (key === tar) return key;\n  }\n}\n\n/** shallow equal version of https://github.com/lukeed/dequal */\nexport function shallowEqual(foo: any, bar: any): boolean {\n  var ctor, len, tmp;\n  if (foo === bar) return true;\n\n  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {\n    if (ctor === Date) return shallowEqual(foo.getTime(), bar.getTime());\n    if (ctor === RegExp) return foo.toString() === bar.toString();\n\n    if (ctor === Array) {\n      if ((len = foo.length) === bar.length) {\n        while (len-- && foo[len] === bar[len]);\n      }\n      return len === -1;\n    }\n\n    if (ctor === Set) {\n      if (foo.size !== bar.size) {\n        return false;\n      }\n      for (len of foo) {\n        tmp = len;\n        if (tmp && typeof tmp === 'object') {\n          tmp = find(bar, tmp);\n          if (!tmp) return false;\n        }\n        if (!bar.has(tmp)) return false;\n      }\n      return true;\n    }\n\n    if (ctor === Map) {\n      if (foo.size !== bar.size) {\n        return false;\n      }\n      for (len of foo) {\n        tmp = len[0];\n        if (tmp && typeof tmp === 'object') {\n          tmp = find(bar, tmp);\n          if (!tmp) return false;\n        }\n        if (len[1] !== bar.get(tmp)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    if (!ctor || typeof foo === 'object') {\n      len = 0;\n      for (ctor in foo) {\n        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;\n        if (!(ctor in bar) || !(foo[ctor] === bar[ctor])) return false;\n      }\n      return Object.keys(bar).length === len;\n    }\n  }\n\n  return foo !== foo && bar !== bar;\n}\n"],"mappings":";AACA,IAAI,MAAM,OAAO,UAAU;AAE3B,SAAS,KAAK,MAAa,KAAU,KAAW;AAC9C,OAAK,OAAO,KAAK,KAAK,GAAG;AACvB,QAAI,QAAQ;AAAK,aAAO;AAAA,EAC1B;AACF;AAGO,SAAS,aAAa,KAAU,KAAmB;AACxD,MAAI,MAAM,KAAK;AACf,MAAI,QAAQ;AAAK,WAAO;AAExB,MAAI,OAAO,QAAQ,OAAO,IAAI,iBAAiB,IAAI,aAAa;AAC9D,QAAI,SAAS;AAAM,aAAO,aAAa,IAAI,QAAQ,GAAG,IAAI,QAAQ,CAAC;AACnE,QAAI,SAAS;AAAQ,aAAO,IAAI,SAAS,MAAM,IAAI,SAAS;AAE5D,QAAI,SAAS,OAAO;AAClB,WAAK,MAAM,IAAI,YAAY,IAAI,QAAQ;AACrC,eAAO,SAAS,IAAI,GAAG,MAAM,IAAI,GAAG;AAAE;AAAA,MACxC;AACA,aAAO,QAAQ;AAAA,IACjB;AAEA,QAAI,SAAS,KAAK;AAChB,UAAI,IAAI,SAAS,IAAI,MAAM;AACzB,eAAO;AAAA,MACT;AACA,WAAK,OAAO,KAAK;AACf,cAAM;AACN,YAAI,OAAO,OAAO,QAAQ,UAAU;AAClC,gBAAM,KAAK,KAAK,GAAG;AACnB,cAAI,CAAC;AAAK,mBAAO;AAAA,QACnB;AACA,YAAI,CAAC,IAAI,IAAI,GAAG;AAAG,iBAAO;AAAA,MAC5B;AACA,aAAO;AAAA,IACT;AAEA,QAAI,SAAS,KAAK;AAChB,UAAI,IAAI,SAAS,IAAI,MAAM;AACzB,eAAO;AAAA,MACT;AACA,WAAK,OAAO,KAAK;AACf,cAAM,IAAI,CAAC;AACX,YAAI,OAAO,OAAO,QAAQ,UAAU;AAClC,gBAAM,KAAK,KAAK,GAAG;AACnB,cAAI,CAAC;AAAK,mBAAO;AAAA,QACnB;AACA,YAAI,IAAI,CAAC,MAAM,IAAI,IAAI,GAAG,GAAG;AAC3B,iBAAO;AAAA,QACT;AAAA,MACF;AACA,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,QAAQ,OAAO,QAAQ,UAAU;AACpC,YAAM;AACN,WAAK,QAAQ,KAAK;AAChB,YAAI,IAAI,KAAK,KAAK,IAAI,KAAK,EAAE,OAAO,CAAC,IAAI,KAAK,KAAK,IAAI;AAAG,iBAAO;AACjE,YAAI,EAAE,QAAQ,QAAQ,EAAE,IAAI,IAAI,MAAM,IAAI,IAAI;AAAI,iBAAO;AAAA,MAC3D;AACA,aAAO,OAAO,KAAK,GAAG,EAAE,WAAW;AAAA,IACrC;AAAA,EACF;AAEA,SAAO,QAAQ,OAAO,QAAQ;AAChC;","names":[]}

package/dist/sleep.d.ts

@@ -0,0 +1,3 @@
+declare function sleep(ms: number): Promise<unknown>;
+
+export { sleep };

package/dist/sleep.js

@@ -0,0 +1,7 @@
+import {
+  sleep
+} from "./chunk-HLFWWIDK.js";
+export {
+  sleep
+};
+//# sourceMappingURL=sleep.js.map

package/dist/sleep.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}