@terrygonguet/utils 0.0.13 → 0.1.0

package/dist/functional.js

@@ -1,266 +0,0 @@
-var S = Object.defineProperty;
-var v = (r, e, t) => e in r ? S(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var u = (r, e, t) => (v(r, typeof e != "symbol" ? e + "" : e, t), t);
-const a = "@terrygonguet/utils/functional/result", f = "@terrygonguet/utils/functional/result/Success", w = "@terrygonguet/utils/functional/result/Failure";
-class l {
-  constructor(e) {
-    u(this, "value");
-    Object.defineProperties(this, {
-      $_kind: { value: a, enumerable: !1, writable: !1 },
-      $_variant: { value: f, enumerable: !1, writable: !1 },
-      value: { value: e, writable: !1 }
-    });
-  }
-  isSuccess() {
-    return !0;
-  }
-  isFailure() {
-    return !1;
-  }
-  merge(e) {
-    return e(this.value);
-  }
-  match(e) {
-    return e(this.value);
-  }
-  map(e) {
-    return new l(e(this.value));
-  }
-  flatMap(e) {
-    return e(this.value);
-  }
-  toJSON() {
-    return { $_kind: a, $_variant: f, value: this.value };
-  }
-}
-class g {
-  constructor(e) {
-    u(this, "reason");
-    Object.defineProperties(this, {
-      $_kind: { value: a, enumerable: !1, writable: !1 },
-      $_variant: { value: f, enumerable: !1, writable: !1 },
-      reason: { value: e, writable: !1 }
-    });
-  }
-  isSuccess() {
-    return !1;
-  }
-  isFailure() {
-    return !0;
-  }
-  merge(e, t) {
-    return t(this.reason);
-  }
-  match(e, t) {
-    return t(this.reason);
-  }
-  map() {
-    return this;
-  }
-  flatMap() {
-    return this;
-  }
-  toJSON() {
-    return { $_kind: a, $_variant: w, reason: this.reason };
-  }
-}
-function y(r, e) {
-  return e ? r.toResult(e) : r.toResult();
-}
-const c = {
-  Success(r) {
-    return new l(r);
-  },
-  Failure(r) {
-    return new g(r);
-  },
-  try(r) {
-    return new d(r);
-  },
-  fromPromise(r, e, t) {
-    return r.then(
-      b(e, this.Success),
-      b(t, this.Failure)
-    );
-  },
-  fromMaybe: y,
-  JSONReviver(r, e) {
-    if ((e == null ? void 0 : e.$_kind) == a) {
-      const t = e == null ? void 0 : e.$_variant;
-      return t == f ? new l(e == null ? void 0 : e.value) : t == w ? new g(e == null ? void 0 : e.reason) : e;
-    } else
-      return e;
-  }
-};
-class d {
-  constructor(e) {
-    u(this, "tryFn");
-    u(this, "catchFn");
-    this.tryFn = e, this.catchFn = $;
-  }
-  catch(e) {
-    return this.catchFn = e, this;
-  }
-  exec(e) {
-    try {
-      const t = c.Success(this.tryFn());
-      return e == null || e(t), t;
-    } catch (t) {
-      const n = c.Failure(this.catchFn(t));
-      return e == null || e(n), n;
-    }
-  }
-}
-const h = "@terrygonguet/utils/functional/maybe", _ = "@terrygonguet/utils/functional/maybe/Some", p = "@terrygonguet/utils/functional/maybe/None";
-class i {
-  constructor(e) {
-    u(this, "value");
-    Object.defineProperties(this, {
-      $_kind: { value: h, enumerable: !1, writable: !1 },
-      $_variant: { value: _, enumerable: !1, writable: !1 },
-      value: { value: e, writable: !1 }
-    });
-  }
-  isSome() {
-    return !0;
-  }
-  isNone() {
-    return !1;
-  }
-  orDefault() {
-    return this.value;
-  }
-  map(e) {
-    return new i(e(this.value));
-  }
-  flatMap(e) {
-    return e(this.value);
-  }
-  toResult() {
-    return c.Success(this.value);
-  }
-  toJSON() {
-    return { $_kind: h, $_variant: _, value: this.value };
-  }
-}
-class k {
-  constructor() {
-  }
-  isSome() {
-    return !1;
-  }
-  isNone() {
-    return !0;
-  }
-  orDefault(e) {
-    return e;
-  }
-  map() {
-    return this;
-  }
-  flatMap() {
-    return this;
-  }
-  toResult(e) {
-    return e ? c.Failure(e == null ? void 0 : e()) : c.Failure(void 0);
-  }
-  toJSON() {
-    return { $_kind: h, $_variant: p };
-  }
-}
-const N = new k(), s = {
-  Some(r) {
-    return new i(r);
-  },
-  None() {
-    return N;
-  },
-  from(r) {
-    switch (r) {
-      case null:
-      case void 0:
-        return this.None();
-      default:
-        return new i(r);
-    }
-  },
-  /**
-   * CAUTION: this method swallows errors and simply returns None!
-   * Use `Result.fromPromise()` if you need error details.
-   */
-  fromPromise(r, e = $) {
-    return r.then(b(e, s.from), M(this.None()));
-  },
-  JSONReviver(r, e) {
-    if ((e == null ? void 0 : e.$_kind) == h) {
-      const t = e == null ? void 0 : e.$_variant;
-      return t == _ ? new i(e == null ? void 0 : e.value) : t == p ? s.None() : e;
-    } else
-      return e;
-  }
-};
-var b = F;
-function F(r, e) {
-  if (!arguments.length)
-    throw new Error(
-      "expected at least one (and probably more) function arguments"
-    );
-  var t = arguments;
-  return function() {
-    for (var n = t[0].apply(this, arguments), o = t.length, m = 1; m < o; m++)
-      n = t[m].call(this, n);
-    return n;
-  };
-}
-var J = x;
-function x(r, ...e) {
-  if (!arguments.length)
-    throw new Error("expected one value argument and least one function argument");
-  if (!e.length)
-    throw new Error(
-      "expected at least one (and probably more) function arguments"
-    );
-  for (var t = e[0](r), n = e.length, o = 1; o < n; o++)
-    t = e[o](t);
-  return t;
-}
-function $(r) {
-  return r;
-}
-function M(r) {
-  return () => r;
-}
-function j(r, e) {
-  return typeof r == "number" ? (t) => s.from(t.at(r)) : s.from(r.at(e));
-}
-function E(r, e) {
-  return typeof r == "function" ? (t) => s.from(t.find(r)) : s.from(r.find(e));
-}
-function O(r, e) {
-  if (typeof r == "function")
-    return (t) => {
-      const n = t.findIndex(r);
-      return n == -1 ? s.None() : s.Some(n);
-    };
-  {
-    const t = r.findIndex(e);
-    return t == -1 ? s.None() : s.Some(t);
-  }
-}
-function C(r, ...e) {
-  for (const t of e)
-    r = r == null ? void 0 : r[t];
-  return s.from(r);
-}
-export {
-  s as Maybe,
-  c as Result,
-  j as at,
-  b as compose,
-  M as constant,
-  E as find,
-  O as findIndex,
-  $ as identity,
-  J as pipe,
-  C as prop
-};

package/src/async.ts

@@ -1,112 +0,0 @@
-import { findIndex } from "./functional/index.ts"
-
-export function pause(ms: number): Promise<void> {
-	return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-interface RetryOptions {
-	count?: number
-	delay?: number | ((retryCount: number, error: any) => number)
-}
-
-export function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>
-export function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>
-export function retry<T>(
-	providerOrOptions: RetryOptions | (() => Promise<T>),
-	options?: RetryOptions,
-) {
-	if (typeof providerOrOptions == "function") return _retry(providerOrOptions, options)
-	else return (provider: () => Promise<T>) => _retry(provider, providerOrOptions)
-}
-
-async function _retry<T>(
-	provider: () => Promise<T>,
-	{ count = Infinity, delay }: RetryOptions = {},
-): Promise<T> {
-	let retryCount = 0
-	let lastError: any
-	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
-}
-
-interface AsyncMapOptions {
-	concurrent?: number
-}
-
-export function asyncMap<T, U>(
-	f: AsyncMapFn<T, U>,
-	options?: AsyncMapOptions,
-): (data: T[]) => Promise<U[]>
-export function asyncMap<T, U>(
-	data: T[],
-	f: AsyncMapFn<T, U>,
-	options?: AsyncMapOptions,
-): Promise<U[]>
-export function asyncMap<T, U>(
-	dataOrF: T[] | AsyncMapFn<T, U>,
-	ForOptions: AsyncMapFn<T, U> | AsyncMapOptions | undefined,
-	options?: AsyncMapOptions,
-): Promise<U[]> | ((data: T[]) => Promise<U[]>) {
-	if (typeof dataOrF == "function" && typeof ForOptions != "function") {
-		const f = dataOrF
-		const options = ForOptions
-		return (data: T[]) => asyncMap_(data, f, options)
-	} 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")
-}
-
-type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>
-
-async function asyncMap_<T, U>(
-	data: T[],
-	f: AsyncMapFn<T, U>,
-	{ concurrent = 5 }: AsyncMapOptions = {},
-): Promise<U[]> {
-	return new Promise((resolve, reject) => {
-		const resolved: [i: number, result: U][] = []
-		const inFlight: [i: number, promise: Promise<void>][] = []
-
-		let next = 0
-		function queue(i: number) {
-			if (resolved.length == data.length && inFlight.length == 0) return finish()
-			if (i >= data.length) return
-			const el = data[i]
-			inFlight.push([
-				i,
-				f(el, i, data).then(result => {
-					resolved.push([i, result])
-					findIndex(inFlight, ([j]) => i == j).map(j => inFlight.splice(j, 1))
-					queue(next)
-				}, reject),
-			])
-			next++
-		}
-
-		function finish() {
-			const sorted = resolved.sort(([a], [b]) => a - b)
-			resolve(sorted.map(([, value]) => value))
-		}
-
-		for (let i = 0; i < concurrent; i++) {
-			queue(next)
-		}
-	})
-}

package/src/functional/index.ts

@@ -1,80 +0,0 @@
-import { Maybe } from "./maybe.ts"
-
-export * from "./maybe.ts"
-export * from "./result.ts"
-export { default as compose } from "just-compose"
-export { default as pipe } from "just-pipe"
-
-export function identity<T>(value: T) {
-	return value
-}
-
-export function constant<T>(value: T) {
-	return () => value
-}
-
-export function at(idx: number): <T>(data: T[]) => Maybe<T>
-export function at<T>(data: T[], idx: number): Maybe<T>
-export function at<T>(dataOrIdx: T[] | number, idx?: number) {
-	if (typeof dataOrIdx == "number") return (data: T[]) => Maybe.from(data.at(dataOrIdx))
-	else return Maybe.from(dataOrIdx.at(idx!))
-}
-
-type Predicate<T> = (value: T, idx: number, arr: T[]) => boolean
-
-export function find<T>(predicate: Predicate<T>): (data: T[]) => Maybe<T>
-export function find<T>(data: T[], predicate: Predicate<T>): Maybe<T>
-export function find<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Predicate<T>) {
-	if (typeof dataOrPredicate == "function")
-		return (data: T[]) => Maybe.from(data.find(dataOrPredicate))
-	else return Maybe.from(dataOrPredicate.find(predicate!))
-}
-
-export function findIndex<T>(predicate: Predicate<T>): (data: T[]) => Maybe<number>
-export function findIndex<T>(data: T[], predicate: Predicate<T>): Maybe<number>
-export function findIndex<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Predicate<T>) {
-	if (typeof dataOrPredicate == "function") {
-		return (data: T[]) => {
-			const idx = data.findIndex(dataOrPredicate)
-			return idx == -1 ? Maybe.None<number>() : Maybe.Some(idx)
-		}
-	} else {
-		const idx = dataOrPredicate.findIndex(predicate!)
-		return idx == -1 ? Maybe.None<number>() : Maybe.Some(idx)
-	}
-}
-
-export function prop<T extends {}, K1 extends keyof T = keyof T>(data: T, key1: K1): Maybe<T[K1]>
-export function prop<
-	T extends {},
-	K1 extends keyof T = keyof T,
-	K2 extends keyof T[K1] = keyof T[K1],
->(data: T, key1: K1, key2: K2): Maybe<T[K1][K2]>
-export function prop<
-	T extends {},
-	K1 extends keyof T = keyof T,
-	K2 extends keyof T[K1] = keyof T[K1],
-	K3 extends keyof T[K1][K2] = keyof T[K1][K2],
->(data: T, key1: K1, key2: K2, key: K3): Maybe<T[K1][K2][K3]>
-export function prop<
-	T extends {},
-	K1 extends keyof T = keyof T,
-	K2 extends keyof T[K1] = keyof T[K1],
-	K3 extends keyof T[K1][K2] = keyof T[K1][K2],
-	K4 extends keyof T[K1][K2][K3] = keyof T[K1][K2][K3],
->(data: T, key1: K1, key2: K2, key: K3, key4: K4): Maybe<T[K1][K2][K3][K4]>
-export function prop<
-	T extends {},
-	K1 extends keyof T = keyof T,
-	K2 extends keyof T[K1] = keyof T[K1],
-	K3 extends keyof T[K1][K2] = keyof T[K1][K2],
-	K4 extends keyof T[K1][K2][K3] = keyof T[K1][K2][K3],
-	K5 extends keyof T[K1][K2][K3][K4] = keyof T[K1][K2][K3][K4],
->(data: T, key1: K1, key2: K2, key: K3, key4: K4, key5: K5): Maybe<T[K1][K2][K3][K4][K5]>
-
-export function prop(data: any, ...path: string[]) {
-	for (const key of path) {
-		data = data?.[key]
-	}
-	return Maybe.from(data)
-}

package/src/functional/maybe.ts

@@ -1,115 +0,0 @@
-import { compose, constant, identity } from "./index.ts"
-import { Result } from "./result.ts"
-
-const $_kind = "@terrygonguet/utils/functional/maybe"
-const $_variant_Some = "@terrygonguet/utils/functional/maybe/Some"
-const $_variant_None = "@terrygonguet/utils/functional/maybe/None"
-
-export interface Maybe<T> {
-	isSome(): this is Some<T>
-	isNone(): this is None<T>
-	orDefault(defaultValue: T): T
-	map<U>(f: (value: T) => U): Maybe<U>
-	flatMap<U>(f: (value: T) => Maybe<U>): Maybe<U>
-	toResult(): Result<T, undefined>
-	toResult<U>(mapNone: () => U): Result<T, U>
-	toJSON(): Object
-}
-
-class Some<T> implements Maybe<T> {
-	value!: T
-
-	constructor(value: T) {
-		Object.defineProperties(this, {
-			$_kind: { value: $_kind, enumerable: false, writable: false },
-			$_variant: { value: $_variant_Some, enumerable: false, writable: false },
-			value: { value, writable: false },
-		})
-	}
-
-	isSome(): true {
-		return true
-	}
-	isNone(): false {
-		return false
-	}
-	orDefault() {
-		return this.value
-	}
-	map<U>(f: (value: T) => U) {
-		return new Some(f(this.value))
-	}
-	flatMap<U>(f: (value: T) => Maybe<U>) {
-		return f(this.value)
-	}
-	toResult<U>(): Result<T, U> {
-		return Result.Success(this.value)
-	}
-	toJSON(): Object {
-		return { $_kind, $_variant: $_variant_Some, value: this.value }
-	}
-}
-
-class None<T> implements Maybe<T> {
-	constructor() {}
-
-	isSome(): false {
-		return false
-	}
-	isNone(): true {
-		return true
-	}
-	orDefault(defaultValue: T) {
-		return defaultValue
-	}
-	map<U>() {
-		return this as unknown as Maybe<U>
-	}
-	flatMap<U>() {
-		return this as unknown as Maybe<U>
-	}
-	toResult(): Result<T, undefined>
-	toResult<U>(mapNone: () => U): Result<T, U>
-	toResult<U>(mapNone?: () => U) {
-		return mapNone ? Result.Failure<T, U>(mapNone?.()) : Result.Failure<T, undefined>(undefined)
-	}
-	toJSON(): Object {
-		return { $_kind, $_variant: $_variant_None }
-	}
-}
-
-const none = new None()
-export const Maybe = {
-	Some<T>(value: T): Maybe<T> {
-		return new Some(value)
-	},
-	None<T>() {
-		return none as Maybe<T>
-	},
-	from<T>(value: T | undefined | null): Maybe<T> {
-		switch (value) {
-			case null:
-			case undefined:
-				return this.None()
-			default:
-				return new Some(value!)
-		}
-	},
-	/**
-	 * CAUTION: this method swallows errors and simply returns None!
-	 * Use `Result.fromPromise()` if you need error details.
-	 */
-	fromPromise<T>(promise: Promise<T>, onResolve: (value: T) => T = identity): Promise<Maybe<T>> {
-		return promise.then(compose(onResolve, Maybe.from), constant(this.None()))
-	},
-	JSONReviver(_key: string, value: any) {
-		if (value?.$_kind == $_kind) {
-			const $_variant = value?.$_variant
-			if ($_variant == $_variant_Some) return new Some<unknown>(value?.value)
-			else if ($_variant == $_variant_None) return Maybe.None()
-			else return value
-		} else return value
-	},
-}
-
-export type { Some, None }