@terrygonguet/utils 0.11.0 → 0.12.1

package/dist/async.js

@@ -1,105 +0,0 @@
-// src/async.ts
-function pause(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function retry(providerOrOptions, options) {
-  if (typeof providerOrOptions == "function")
-    return _retry(providerOrOptions, options);
-  else
-    return (provider) => _retry(provider, providerOrOptions);
-}
-async function _retry(provider, { count = Infinity, delay } = {}) {
-  let retryCount = 0;
-  let lastError;
-  do {
-    try {
-      return await provider();
-    } catch (error) {
-      lastError = error;
-      retryCount++;
-      switch (typeof delay) {
-        case "number":
-          await pause(delay);
-          break;
-        case "function":
-          await pause(delay(retryCount, error));
-          break;
-      }
-    }
-  } while (retryCount <= count);
-  throw lastError;
-}
-function asyncMap(dataOrF, ForOptions, options) {
-  if (typeof dataOrF == "function" && typeof ForOptions != "function") {
-    const f = dataOrF;
-    const options2 = ForOptions;
-    return (data) => asyncMap_(data, f, options2);
-  } else if (Array.isArray(dataOrF) && typeof ForOptions == "function") {
-    const data = dataOrF;
-    const f = ForOptions;
-    return asyncMap_(data, f, options);
-  } else throw new Error("Invalid arguments passed to asyncMap");
-}
-async function asyncMap_(data, f, {
-  concurrent = 5,
-  failFast = false,
-  withSourceIndexes = false
-} = {}) {
-  return new Promise((resolve, reject) => {
-    const resolved = [];
-    const errors = [];
-    const inFlight = /* @__PURE__ */ new Map();
-    let next = 0;
-    let stop = false;
-    function queue(i) {
-      if (!stop && i > 0 && inFlight.size == 0) return finish();
-      if (stop || i >= data.length) return;
-      inFlight.set(
-        i,
-        f(data[i], i, data).then(
-          (result) => void resolved.push([i, result]),
-          (error) => {
-            if (!failFast) errors.push([i, error]);
-            else {
-              stop = true;
-              reject(error);
-            }
-          }
-        ).finally(() => {
-          inFlight.delete(i);
-          queue(next);
-        })
-      );
-      next++;
-    }
-    function finish() {
-      resolved.sort(([a], [b]) => a - b);
-      if (failFast) {
-        if (withSourceIndexes) resolve(resolved);
-        else resolve(resolved.map(([, value]) => value));
-      } else {
-        errors.sort(([a], [b]) => a - b);
-        if (withSourceIndexes)
-          resolve({
-            results: resolved,
-            errors
-          });
-        else
-          resolve({
-            results: resolved.map(([, value]) => value),
-            errors: errors.map(([, error]) => error)
-          });
-      }
-    }
-    if (data.length == 0) finish();
-    else
-      for (let i = 0; i < concurrent; i++) {
-        queue(next);
-      }
-  });
-}
-export {
-  asyncMap,
-  pause,
-  retry
-};

package/dist/index.js

@@ -1,85 +0,0 @@
-// src/index.ts
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-function createNoopProxy() {
-  const noop2 = () => proxy;
-  const no = () => false;
-  const yes = () => true;
-  const proxy = new Proxy(() => {
-  }, {
-    get: noop2,
-    set: noop2,
-    apply: noop2,
-    construct: noop2,
-    deleteProperty: yes,
-    has: yes,
-    preventExtensions: no,
-    defineProperty: no
-  });
-  return proxy;
-}
-function noop() {
-}
-function exhaustive(_) {
-  throw new Error("This should never be called");
-}
-async function hash(message) {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(message);
-  const hash2 = await crypto.subtle.digest("SHA-1", data);
-  return hash2;
-}
-function* range(start, end, step = 1) {
-  for (let i = start; i < end; i += step) {
-    yield i;
-  }
-}
-function yesno(value) {
-  switch (value?.toLowerCase()) {
-    case "1":
-    case "y":
-    case "yes":
-    case "true":
-    case "on":
-      return true;
-    default:
-      return false;
-  }
-}
-function mapListPush(map, key, value) {
-  const arr = map.get(key) ?? [];
-  arr.push(value);
-  return map.set(key, arr);
-}
-function recordListPush(record, key, value) {
-  const arr = record[key] ?? [];
-  arr.push(value);
-  record[key] = arr;
-  return record;
-}
-function tryCatch(f, ...args) {
-  try {
-    const promiseOrResult = f(...args);
-    if (promiseOrResult instanceof Promise)
-      return promiseOrResult.then(
-        (result) => [null, result],
-        (error) => [error, null]
-      );
-    else return [null, promiseOrResult];
-  } catch (error) {
-    return [error, null];
-  }
-}
-export {
-  clamp,
-  createNoopProxy,
-  exhaustive,
-  hash,
-  mapListPush,
-  noop,
-  range,
-  recordListPush,
-  tryCatch,
-  yesno
-};

package/dist/json.js

@@ -1,63 +0,0 @@
-// src/json.ts
-function safeParse(str, defaultValue, reviver) {
-  try {
-    return JSON.parse(str, reviver);
-  } catch (_) {
-    return defaultValue;
-  }
-}
-function schemaParse(schema, str, options) {
-  try {
-    const parsed = JSON.parse(str, options?.reviver);
-    const result = schema["~standard"].validate(parsed);
-    if (options?.async) {
-      if (result instanceof Promise) {
-        return result.then(
-          (result2) => result2.issues ? [null, result2, null] : [null, null, result2.value],
-          (err) => [err, null, null]
-        );
-      } else {
-        return Promise.resolve(
-          result.issues ? [null, result, null] : [null, null, result.value]
-        );
-      }
-    } else {
-      if (result instanceof Promise)
-        throw new Error(
-          "Function schemaParse() whas called with an async schema but without the async flag"
-        );
-      else if (result.issues) return [null, result, null];
-      else return [null, null, result.value];
-    }
-  } catch (error) {
-    return [error, null, null];
-  }
-}
-function schemaParseWithDefault(schema, str, defaultValue, options) {
-  const result = schemaParse(schema, str, options);
-  if (result instanceof Promise) {
-    return result.then(([error, failure, value]) => {
-      if (failure) {
-        options?.out_validationFailure?.push(failure);
-        return defaultValue;
-      } else if (error) {
-        options?.out_parseError?.push(error);
-        return defaultValue;
-      } else return value;
-    });
-  } else {
-    const [error, failure, value] = result;
-    if (failure) {
-      options?.out_validationFailure?.push(failure);
-      return defaultValue;
-    } else if (error) {
-      options?.out_parseError?.push(error);
-      return defaultValue;
-    } else return value;
-  }
-}
-export {
-  safeParse,
-  schemaParse,
-  schemaParseWithDefault
-};

package/dist/option.d.ts

@@ -1,45 +0,0 @@
-declare class Option<T> {
-    #private;
-    readonly _kind: "Some" | "None";
-    readonly value: T;
-    private constructor();
-    [Symbol.iterator](): Iterator<Option<T>, T>;
-    static do<T>(f: () => Iterator<Option<any>, T, any>): Option<T>;
-    static from<T>(maybeValue: unknown, { allowOptionLikePOJO }?: {
-        allowOptionLikePOJO?: boolean | undefined;
-    }): Option<T>;
-    static wrapFunction<T, Args extends any[]>(f: (...args: Args) => T | undefined | null, { allowOptionLikePOJO }?: {
-        allowOptionLikePOJO?: boolean | undefined;
-    }): (...args: Args) => Option<T>;
-    static isOption<T>(maybeOption: unknown): maybeOption is Option<T>;
-    static Some<T>(value: T): Option<T>;
-    static None<T>(): Option<T>;
-    [Symbol.toPrimitive](): string;
-    isSome(): boolean;
-    isNone(): boolean;
-    equals(other: Option<T>): boolean;
-    map<U>(f: (value: T) => U, { coalesce }?: {
-        coalesce?: boolean | undefined;
-    }): Option<U>;
-    flatMap<U>(f: (value: T) => Option<U>): Option<U>;
-    flatten(): T extends Option<infer U> ? Option<U> : Option<T>;
-    orDefault(defaultValue: T): T;
-    orNull(): T | null;
-    orUndefined(): T | undefined;
-    or<U>(other: Option<U>): Option<T> | Option<U>;
-    unwrap(): T;
-    filter<U extends T>(predicate: (value: T) => value is U): Option<U>;
-    filter(predicate: (value: T) => boolean): Option<T>;
-    toString(): string;
-}
-declare function arrayGet<T>(arr: T[], i: number): Option<T>;
-declare function arrayFind<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<T>;
-declare function arrayFindLast<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<T>;
-declare function arrayFindIndex<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<number>;
-declare function arrayFindLastIndex<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<number>;
-declare function arrayIndexOf<T>(arr: T[], item: T, fromIndex?: number): Option<number>;
-declare function arrayLastIndexOf<T>(arr: T[], item: T, fromIndex?: number): Option<number>;
-declare function arrPop<T>(arr: T[]): Option<T>;
-declare function arrShift<T>(arr: T[]): Option<T>;
-
-export { Option, arrPop, arrShift, arrayFind, arrayFindIndex, arrayFindLast, arrayFindLastIndex, arrayGet, arrayIndexOf, arrayLastIndexOf };

package/dist/option.js

@@ -1,163 +0,0 @@
-// src/option.ts
-var Option = class _Option {
-  _kind;
-  value;
-  constructor(_kind, value = void 0) {
-    this._kind = _kind;
-    this.value = value;
-  }
-  *[Symbol.iterator]() {
-    yield this;
-    if (this.isNone())
-      throw new Error("Tried to unwrap a None() via its iterator");
-    else return this.value;
-  }
-  static do(f) {
-    const gen = f();
-    let iter = gen.next();
-    while (!iter.done) {
-      switch (iter.value._kind) {
-        case "Some":
-          iter = gen.next(iter.value.value);
-          break;
-        case "None":
-          gen.return?.(void 0);
-          return _Option.None();
-      }
-    }
-    return _Option.Some(iter.value);
-  }
-  static from(maybeValue, { allowOptionLikePOJO = false } = {}) {
-    if (maybeValue === void 0 || maybeValue === null)
-      return _Option.None();
-    else if (_Option.isOption(maybeValue)) return maybeValue;
-    else if (allowOptionLikePOJO && maybeValue && typeof maybeValue == "object" && "_kind" in maybeValue && (maybeValue._kind == "Some" || maybeValue._kind == "None"))
-      return new _Option(
-        maybeValue._kind,
-        maybeValue.value
-      );
-    else return _Option.Some(maybeValue);
-  }
-  static wrapFunction(f, { allowOptionLikePOJO = false } = {}) {
-    return (...args) => _Option.from(f(...args), { allowOptionLikePOJO });
-  }
-  static isOption(maybeOption) {
-    return maybeOption instanceof _Option;
-  }
-  static Some(value) {
-    return new _Option("Some", value);
-  }
-  static #None = new _Option("None");
-  static None() {
-    return this.#None;
-  }
-  [Symbol.toPrimitive]() {
-    return this.toString();
-  }
-  isSome() {
-    return this._kind == "Some";
-  }
-  isNone() {
-    return this._kind == "None";
-  }
-  equals(other) {
-    if (this.isNone()) return other.isNone();
-    else if (other.isNone()) return false;
-    else return this.value == other.value;
-  }
-  map(f, { coalesce = false } = {}) {
-    if (this.isNone()) return _Option.None();
-    else if (coalesce) return _Option.from(f(this.value));
-    else return _Option.Some(f(this.value));
-  }
-  flatMap(f) {
-    if (this.isNone()) return _Option.None();
-    else return f(this.value);
-  }
-  flatten() {
-    if (this.isNone()) return _Option.None();
-    else return _Option.isOption(this.value) ? this.value : this;
-  }
-  orDefault(defaultValue) {
-    if (this.isNone()) return defaultValue;
-    else return this.value;
-  }
-  orNull() {
-    if (this.isNone()) return null;
-    else return this.value;
-  }
-  orUndefined() {
-    if (this.isNone()) return void 0;
-    else return this.value;
-  }
-  or(other) {
-    if (this.isNone()) return other;
-    else return this;
-  }
-  unwrap() {
-    if (this.isNone()) throw new Error("Tried to unwrap a None()");
-    else return this.value;
-  }
-  filter(predicate) {
-    if (this.isNone()) return this;
-    else return predicate(this.value) ? this : _Option.None();
-  }
-  toString() {
-    if (this.isNone()) return "None()";
-    switch (typeof this.value) {
-      case "string":
-        return `Some("${this.value}")`;
-      case "function":
-      case "object":
-        return `Some(${JSON.stringify(this.value)})`;
-      default:
-        return `Some(${this.value})`;
-    }
-  }
-};
-function arrayGet(arr, i) {
-  if (i >= arr.length || i < 0) return Option.None();
-  else return Option.Some(arr[i]);
-}
-function arrayFind(arr, predicate, thisArg) {
-  return Option.from(arr.find(predicate, thisArg));
-}
-function arrayFindLast(arr, predicate, thisArg) {
-  return Option.from(arr.findLast(predicate, thisArg));
-}
-function arrayFindIndex(arr, predicate, thisArg) {
-  const idx = arr.findIndex(predicate, thisArg);
-  return idx == -1 ? Option.None() : Option.Some(idx);
-}
-function arrayFindLastIndex(arr, predicate, thisArg) {
-  const idx = arr.findLastIndex(predicate, thisArg);
-  return idx == -1 ? Option.None() : Option.Some(idx);
-}
-function arrayIndexOf(arr, item, fromIndex) {
-  const idx = arr.indexOf(item, fromIndex);
-  return idx == -1 ? Option.None() : Option.Some(idx);
-}
-function arrayLastIndexOf(arr, item, fromIndex) {
-  const idx = arr.lastIndexOf(item, fromIndex);
-  return idx == -1 ? Option.None() : Option.Some(idx);
-}
-function arrPop(arr) {
-  if (arr.length == 0) return Option.None();
-  else return Option.Some(arr.pop());
-}
-function arrShift(arr) {
-  if (arr.length == 0) return Option.None();
-  else return Option.Some(arr.shift());
-}
-export {
-  Option,
-  arrPop,
-  arrShift,
-  arrayFind,
-  arrayFindIndex,
-  arrayFindLast,
-  arrayFindLastIndex,
-  arrayGet,
-  arrayIndexOf,
-  arrayLastIndexOf
-};

package/dist/random.js

@@ -1,86 +0,0 @@
-// src/random.ts
-var base_randi = make_randi(Math.random);
-function randi(minOrMax, max) {
-  if (typeof max == "number") return base_randi(minOrMax, max);
-  else return base_randi(minOrMax);
-}
-var base_randf = make_randf(Math.random);
-function randf(minOrMax, max) {
-  if (typeof max == "number") return base_randf(minOrMax, max);
-  else return base_randf(minOrMax);
-}
-var shuffle = make_shuffle(Math.random);
-function make_randi(prng) {
-  return function randi2(minOrMax, max) {
-    if (typeof max == "number") {
-      const min = minOrMax;
-      const delta = max - min;
-      return min + Math.floor(prng() * delta);
-    } else return Math.floor(prng() * minOrMax);
-  };
-}
-function make_randf(prng) {
-  return function randf2(minOrMax, max) {
-    if (typeof max == "number") {
-      const min = minOrMax;
-      const delta = max - min;
-      return min + prng() * delta;
-    } else return prng() * minOrMax;
-  };
-}
-function make_shuffle(prng) {
-  const randi2 = make_randi(prng);
-  return function shuffle2(arr) {
-    const clone = Array.from(arr);
-    for (let i = 0; i < clone.length - 2; i++) {
-      const j = randi2(i, clone.length);
-      const temp = clone[i];
-      clone[i] = clone[j];
-      clone[j] = temp;
-    }
-    return clone;
-  };
-}
-function seeded(seed) {
-  if (typeof seed == "string") seed = cyrb128(seed);
-  else seed ^= 3735928559;
-  const prng = splitmix32(seed);
-  for (let i = 0; i < 15; i++) prng();
-  return prng;
-}
-function cyrb128(str) {
-  let h1 = 1779033703, h2 = 3144134277, h3 = 1013904242, h4 = 2773480762;
-  for (let i = 0, k; i < str.length; i++) {
-    k = str.charCodeAt(i);
-    h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
-    h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
-    h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
-    h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
-  }
-  h1 = Math.imul(h3 ^ h1 >>> 18, 597399067);
-  h2 = Math.imul(h4 ^ h2 >>> 22, 2869860233);
-  h3 = Math.imul(h1 ^ h3 >>> 17, 951274213);
-  h4 = Math.imul(h2 ^ h4 >>> 19, 2716044179);
-  h1 ^= h2 ^ h3 ^ h4;
-  return h1 >>> 0;
-}
-function splitmix32(a) {
-  return function() {
-    a |= 0;
-    a = a + 2654435769 | 0;
-    let t = a ^ a >>> 16;
-    t = Math.imul(t, 569420461);
-    t = t ^ t >>> 15;
-    t = Math.imul(t, 1935289751);
-    return ((t = t ^ t >>> 15) >>> 0) / 4294967296;
-  };
-}
-export {
-  make_randf,
-  make_randi,
-  make_shuffle,
-  randf,
-  randi,
-  seeded,
-  shuffle
-};

package/dist/result.d.ts

@@ -1,56 +0,0 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
-
-declare class Result<Err extends Error, T> {
-    value: T | null;
-    error: Err | null;
-    constructor(value: null, error: Err);
-    constructor(value: T, error: null);
-    asTuple(): [Err, null] | [null, T];
-    asObject(): {
-        value: null;
-        error: Err;
-    } | {
-        value: T;
-        error: null;
-    };
-    andThen<Err2 extends Error, F extends (value: T) => any>(f: F): ReturnType<F> extends Promise<infer U> ? AsyncResult<Err | Err2, U> : Result<Err | Err2, ReturnType<F>>;
-    match(onValue: (value: T) => void): void;
-    match<U>(onValue: (value: T) => U, onError: (error: Err) => U): U;
-    recover<Err2 extends Error, F extends (error: Err) => T | Promise<T>>(f: F): ReturnType<F> extends Promise<T> ? AsyncResult<Err2, T> : Result<Err2, T>;
-    unwrap(): T;
-    unwrapErr(): Err;
-}
-declare class AsyncResult<Err extends Error, T> {
-    promise: Promise<T>;
-    constructor(promise: Promise<T>);
-    asTuple(): Promise<[Err, null] | [null, T]>;
-    asObject(): Promise<{
-        value: null;
-        error: Err;
-    } | {
-        value: T;
-        error: null;
-    }>;
-    then<U>(cb: (value: Result<Err, T>) => U | Promise<U>): Promise<U>;
-    andThen<Err2 extends Error, F extends (value: T) => any>(f: F): AsyncResult<Err | Err2, Awaited<ReturnType<F>>>;
-    match(onValue: (value: T) => void): Promise<void>;
-    match<U>(onValue: (value: T) => U, onError: (error: Err) => U): Promise<U>;
-    recover<Err2 extends Error, F extends (error: Err) => T | Promise<T>>(f: F): AsyncResult<Err2, T>;
-    unwrap(): Promise<T>;
-    unwrapErr(): Promise<Err>;
-}
-declare function safe<Err extends Error, T>(promise: Promise<T>): AsyncResult<Error, T>;
-declare function safe<Err extends Error, F extends (...args: any) => Promise<any>>(f: F, ...args: Parameters<F>): AsyncResult<Err, Awaited<ReturnType<F>>>;
-declare function safe<Err extends Error, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): Result<Err, ReturnType<F>>;
-declare class SafeFunctionValidationError extends Error {
-    name: string;
-    issues: StandardSchemaV1.FailureResult["issues"];
-    constructor(message: string, issues: StandardSchemaV1.FailureResult["issues"], options?: ErrorOptions);
-}
-interface MakeSafeFnOptions<ParamsSchema extends StandardSchemaV1 | undefined, ReturnSchema extends StandardSchemaV1 | undefined> {
-    paramsSchema?: ParamsSchema;
-    returnSchema?: ReturnSchema;
-}
-declare function makeSafeFn<Err extends Error, ParamsSchema extends StandardSchemaV1 | undefined, ReturnSchema extends StandardSchemaV1 | undefined, F extends (...args: ParamsSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ParamsSchema> : any) => ReturnSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ReturnSchema> : any>(f: F, options?: MakeSafeFnOptions<ParamsSchema, ReturnSchema>): (...args: Parameters<F>) => Result<Err, ReturnType<F>>;
-
-export { AsyncResult, Result, SafeFunctionValidationError, makeSafeFn, safe };