@terrygonguet/utils 0.11.0 → 0.12.1

package/dist/result.js

@@ -1,153 +0,0 @@
-// src/result.ts
-var Result = class _Result {
-  value;
-  error;
-  constructor(value, error) {
-    this.value = value;
-    this.error = error;
-  }
-  asTuple() {
-    return [this.error, this.value];
-  }
-  asObject() {
-    return { value: this.value, error: this.error };
-  }
-  andThen(f) {
-    if (this.error) return this;
-    try {
-      const newValue = f(this.value);
-      if (newValue instanceof Promise) return new AsyncResult(newValue);
-      else return new _Result(newValue, null);
-    } catch (error) {
-      return new _Result(null, RawError.wrap(error));
-    }
-  }
-  match(onValue, onError) {
-    if (this.error) return onError?.(this.error);
-    else return onError ? onValue(this.value) : void onValue(this.value);
-  }
-  recover(f) {
-    if (!this.error) return this;
-    try {
-      const newValue = f(this.error);
-      if (newValue instanceof Promise) return new AsyncResult(newValue);
-      else return new _Result(newValue, null);
-    } catch (error) {
-      return new _Result(null, RawError.wrap(error));
-    }
-  }
-  unwrap() {
-    if (!this.error) return this.value;
-    else throw new Error("Tried to unwrap a failed Result");
-  }
-  unwrapErr() {
-    if (this.error) return this.error;
-    else throw new Error("Tried to unwrapErr a successful Result");
-  }
-};
-var AsyncResult = class _AsyncResult {
-  promise;
-  constructor(promise) {
-    this.promise = promise;
-  }
-  asTuple() {
-    return this.then((result) => result.asTuple());
-  }
-  asObject() {
-    return this.then((result) => result.asObject());
-  }
-  then(cb) {
-    return this.promise.then(
-      (value) => cb(new Result(value, null)),
-      (error) => cb(new Result(null, RawError.wrap(error)))
-    );
-  }
-  andThen(f) {
-    return new _AsyncResult(this.promise.then((value) => f(value)));
-  }
-  match(onValue, onError) {
-    return this.promise.then(
-      (value) => onError ? onValue(value) : void onValue(value),
-      (error) => onError?.(error)
-    );
-  }
-  recover(f) {
-    return new _AsyncResult(
-      this.promise.then(
-        (value) => value,
-        (error) => f(error)
-      )
-    );
-  }
-  unwrap() {
-    return this.then((result) => result.unwrap());
-  }
-  unwrapErr() {
-    return this.then((result) => result.unwrapErr());
-  }
-};
-var RawError = class _RawError extends Error {
-  name = "RawError";
-  value;
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  static wrap(error) {
-    if (error instanceof Error) return error;
-    else return new _RawError(error);
-  }
-};
-function safe(promiseOrFunction, ...args) {
-  if (promiseOrFunction instanceof Promise) return new AsyncResult(promiseOrFunction);
-  try {
-    const value = promiseOrFunction(...args);
-    if (value instanceof Promise) return new AsyncResult(value);
-    else return new Result(value, null);
-  } catch (error) {
-    return new Result(null, RawError.wrap(error));
-  }
-}
-var SafeFunctionValidationError = class extends Error {
-  name = "SafeFunctionValidationError";
-  issues;
-  constructor(message, issues, options) {
-    super(message, options);
-    this.issues = issues;
-  }
-};
-function makeSafeFn(f, options) {
-  return function(...args) {
-    if (options?.paramsSchema) {
-      const parsed = options.paramsSchema["~standard"].validate(args);
-      if ("then" in parsed)
-        return new Result(
-          null,
-          new TypeError("[makeSafeFn] Parameters check failed: Async schemas are not supported")
-        );
-      else if (parsed.issues)
-        return new Result(
-          null,
-          new SafeFunctionValidationError("[makeSafeFn] Parameters check failed", parsed.issues)
-        );
-      else args = parsed.value;
-    }
-    if (options?.returnSchema)
-      return safe(f, ...args).andThen((returned) => {
-        const parsed = options.returnSchema["~standard"].validate(returned);
-        if ("then" in parsed)
-          throw new TypeError("[makeSafeFn] Return check failed: Async schemas are not supported");
-        else if (parsed.issues)
-          throw new SafeFunctionValidationError("[makeSafeFn] Return check failed", parsed.issues);
-        else return parsed.value;
-      });
-    else return safe(f, ...args);
-  };
-}
-export {
-  AsyncResult,
-  Result,
-  SafeFunctionValidationError,
-  makeSafeFn,
-  safe
-};

package/dist/tableau.d.ts

@@ -1,63 +0,0 @@
-type Predicate<T> = (value: T, index: number, tableau: Tableau<T>) => boolean;
-type AssertPredicate<T, U extends T> = (value: T, index: number, tableau: Tableau<T>) => value is U;
-type Reducer<T, U> = (previousValue: U, currentValue: T, index: number, tableau: Tableau<T>) => U;
-type Mapper<T, U> = (value: T, index: number, tableau: Tableau<T>) => U;
-type Comparer<T> = (a: T, b: T) => number;
-type FlatTableau<Arr, Depth extends number> = {
-    done: Arr;
-    recur: Arr extends Tableau<infer InnerArr> ? FlatTableau<InnerArr, [
-        -1,
-        0,
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-        10,
-        11,
-        12,
-        13,
-        14,
-        15,
-        16,
-        17,
-        18,
-        19,
-        20
-    ][Depth]> : Arr;
-}[Depth extends -1 ? "done" : "recur"];
-declare class Tableau<T> extends Array<T> {
-    constructor(length?: number);
-    i(idx: number): T | undefined;
-    ientries(): IterableIterator<[number, T]>;
-    ievery<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): this is Tableau<U>;
-    ievery(predicate: Predicate<T>, thisArg?: any): boolean;
-    ifilter<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): Tableau<U>;
-    ifilter(predicate: Predicate<T>, thisArg?: any): Tableau<T>;
-    ifind<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): U | undefined;
-    ifind(predicate: Predicate<T>, thisArg?: any): T | undefined;
-    ifindIndex(predicate: Predicate<T>, thisArg?: any): number | undefined;
-    ifindLast<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): U | undefined;
-    ifindLast(predicate: Predicate<T>, thisArg?: any): T | undefined;
-    ifindLastIndex(predicate: Predicate<T>, thisArg?: any): number | undefined;
-    iflat<Depth extends number = 1>(depth?: Depth): FlatTableau<T, Depth>;
-    iflatMap<U>(callback: Mapper<T, U | Tableau<U>>, thisArg?: any): Tableau<U>;
-    iindexOf(searchElement: T, fromIndex?: number): number | undefined;
-    ikeys(): IterableIterator<number>;
-    ilastIndexOf(searchElement: T, fromIndex?: number): number | undefined;
-    imap<U>(callbackFn: Mapper<T, U>, thisArg?: any): Tableau<U>;
-    ireduce<U>(callbackFn: Reducer<T, U>, initialValue: U): U;
-    ireduceRight<U>(callbackFn: Reducer<T, U>, initialValue: U): U;
-    isome(predicate: Predicate<T>, thisArg?: any): boolean;
-    isort(compareFn: Comparer<T>): Tableau<T>;
-    isplice(start: number, deleteCount?: number, ...items: T[]): Tableau<T>;
-    iwith(index: number, value: T): Tableau<T>;
-    static from<T>(source: Iterable<T> | ArrayLike<T>): Tableau<T>;
-    static of<T>(...elements: T[]): Tableau<T>;
-}
-
-export { Tableau };

package/dist/tableau.js

@@ -1,125 +0,0 @@
-// src/tableau.ts
-var Tableau = class _Tableau extends Array {
-  constructor(length) {
-    length == void 0 ? super() : super(length);
-  }
-  i(idx) {
-    if (idx == 0) throw new RangeError("Cannot access index 0 in a Tableau");
-    return this.at(idx - 1);
-  }
-  *ientries() {
-    for (let i = 0; i < this.length; i++) {
-      yield [i + 1, this[i]];
-    }
-  }
-  ievery(predicate, thisArg) {
-    return this.every((value, i) => predicate(value, i + 1, this), thisArg);
-  }
-  ifilter(predicate, thisArg) {
-    return this.filter((value, i) => predicate(value, i + 1, this), thisArg);
-  }
-  ifind(predicate, thisArg) {
-    return this.find((value, i) => predicate(value, i + 1, this), thisArg);
-  }
-  ifindIndex(predicate, thisArg) {
-    const idx = this.findIndex(
-      (value, i) => predicate(value, i + 1, this),
-      thisArg
-    );
-    return idx == -1 ? void 0 : idx + 1;
-  }
-  ifindLast(predicate, thisArg) {
-    return this.findLast(
-      (value, i) => predicate(value, i + 1, this),
-      thisArg
-    );
-  }
-  ifindLastIndex(predicate, thisArg) {
-    const idx = this.findLastIndex(
-      (value, i) => predicate(value, i + 1, this),
-      thisArg
-    );
-    return idx == -1 ? void 0 : idx + 1;
-  }
-  iflat(depth) {
-    return this.flat(depth);
-  }
-  iflatMap(callback, thisArg) {
-    return this.flatMap(
-      (value, i) => callback(value, i + 1, this),
-      thisArg
-    );
-  }
-  iindexOf(searchElement, fromIndex = 1) {
-    if (fromIndex == 0)
-      throw new RangeError("Cannot access index 0 in a Tableau");
-    const idx = this.indexOf(searchElement, fromIndex - 1);
-    return idx == -1 ? void 0 : idx + 1;
-  }
-  *ikeys() {
-    for (const key of this.keys()) {
-      yield key + 1;
-    }
-  }
-  ilastIndexOf(searchElement, fromIndex = this.length) {
-    if (fromIndex == 0)
-      throw new RangeError("Cannot access index 0 in a Tableau");
-    const idx = this.lastIndexOf(searchElement, fromIndex - 1);
-    return idx == -1 ? void 0 : idx + 1;
-  }
-  imap(callbackFn, thisArg) {
-    return this.map(
-      (value, i) => callbackFn(value, i + 1, this),
-      thisArg
-    );
-  }
-  ireduce(callbackFn, initialValue) {
-    return this.reduce(
-      (acc, cur, i) => callbackFn(acc, cur, i + 1, this),
-      initialValue
-    );
-  }
-  ireduceRight(callbackFn, initialValue) {
-    return this.reduceRight(
-      (acc, cur, i) => callbackFn(acc, cur, i + 1, this),
-      initialValue
-    );
-  }
-  isome(predicate, thisArg) {
-    return this.some((value, i) => predicate(value, i + 1, this), thisArg);
-  }
-  isort(compareFn) {
-    return this.toSorted(compareFn);
-  }
-  isplice(start, deleteCount, ...items) {
-    if (start == 0)
-      throw new RangeError("Cannot access index 0 in a Tableau");
-    return this.toSpliced(start - 1, deleteCount, ...items);
-  }
-  iwith(index, value) {
-    if (index == 0)
-      throw new RangeError("Cannot access index 0 in a Tableau");
-    return this.with(index - 1, value);
-  }
-  static from(source) {
-    if ("length" in source) {
-      const litanie = new _Tableau(source.length);
-      for (let i = 0; i < source.length; i++) {
-        litanie[i] = source[i];
-      }
-      return litanie;
-    } else {
-      const litanie = new _Tableau();
-      for (const element of source) {
-        litanie.push(element);
-      }
-      return litanie;
-    }
-  }
-  static of(...elements) {
-    return _Tableau.from(elements);
-  }
-};
-export {
-  Tableau
-};