@tempots/std 0.11.0 → 0.12.0

package/array.js

@@ -1,223 +1,219 @@
-import { Maybe as v } from "./maybe.js";
-import { keys as w } from "./object.js";
-function _(n, e) {
-  return Array.from({ length: n.length }, (t, r) => e(n[r], r));
+import { objectKeys as v } from "./object.js";
+function q(n, r) {
+  return Array.from({ length: n.length }, (t, e) => r(n[e], e));
 }
-function q(n, e) {
+function B(n, r) {
   const t = [];
-  for (let r = 0; r < n.length; r++) {
-    const u = e(n[r], r);
-    u != null && t.push(u);
-  }
-  return t;
-}
-function y(n, e) {
-  const t = [];
-  for (const r of n)
-    t.push(...e(r));
+  for (const e of n)
+    t.push(...r(e));
   return t;
 }
-function B(n) {
-  return n.length > 0 ? v.just(n[0]) : v.nothing;
+function _(n) {
+  return n.length > 0 ? n[0] : void 0;
 }
-function I(n) {
+function k(n) {
   return n.slice(1);
 }
-function A(n, e, t) {
-  if (n.length !== e.length) return !1;
-  for (let r = 0; r < n.length; r++)
-    if (!t(n[r], e[r])) return !1;
+function F(n, r, t) {
+  if (n.length !== r.length) return !1;
+  for (let e = 0; e < n.length; e++)
+    if (!t(n[e], r[e])) return !1;
   return !0;
 }
-function N(n) {
-  return function(e, t) {
-    return A(e, t, n);
-  };
-}
-function O(n) {
+function I(n) {
   return n.length === 0;
 }
-function j(n) {
+function M(n) {
   return n.length > 0;
 }
-function E(n, e) {
+function x(n, r) {
   const t = [];
-  for (const r of n) e(r) && t.push(r);
+  for (const e of n) r(e) && t.push(e);
   return t;
 }
-function P(n, e) {
+function b(n, r) {
   const t = [];
-  for (let r = 0; r < n.length; r++) {
-    const u = e(n[r], r);
+  for (let e = 0; e < n.length; e++) {
+    const u = r(n[e], e);
     u != null && t.push(u);
   }
   return t;
 }
-function S(n) {
-  return E(n, (e) => e != null);
+function j(n) {
+  return x(n, (r) => r != null);
 }
-function $(n) {
+function D(n) {
   return [].concat(...n);
 }
-function C(n, e, t) {
-  for (const r of n)
-    t = e(t, r);
+function P(n, r, t) {
+  for (const e of n)
+    t = r(t, e);
   return t;
 }
-function D(n, e) {
+function S(n, r) {
   for (const t of n)
-    if (!e(t))
+    if (!r(t))
       return !1;
   return !0;
 }
-function R(n, e) {
+function N(n, r) {
   for (const t of n)
-    if (e(t))
+    if (r(t))
       return !0;
   return !1;
 }
-function T(n, e) {
-  for (const t of n) e(t);
+function T(n, r) {
+  for (const t of n) r(t);
 }
-function L(...n) {
+function $(...n) {
   return [].concat(...n);
 }
-function V(n, e = !0) {
-  return function(t, r) {
-    if (t.length < r.length)
-      return -1 * (e ? 1 : -1);
-    if (t.length > r.length)
-      return 1 * (e ? 1 : -1);
-    for (let u = 0; u < t.length; u++) {
-      const s = n(t[u], r[u]);
-      if (s !== 0) return s;
-    }
-    return 0;
-  };
+function H(n, r, t, e = !0) {
+  if (n.length < r.length)
+    return -1 * (e ? 1 : -1);
+  if (n.length > r.length)
+    return 1 * (e ? 1 : -1);
+  for (let u = 0; u < n.length; u++) {
+    const l = t(n[u], r[u]);
+    if (l !== 0) return l;
+  }
+  return 0;
 }
-function W(n, e) {
-  return e.slice().sort(n);
+function C(n, r) {
+  return n.slice().sort(r);
 }
-function x(n, e) {
-  return Array.from({ length: n }, (t, r) => e(r));
+function g(n, r) {
+  return Array.from({ length: n }, (t, e) => r(e));
 }
-function z(n, e = 0) {
-  return x(n, (t) => e + t);
+function L(n, r = 0) {
+  return g(n, (t) => r + t);
 }
-function G(n, e) {
-  return x(n, () => e);
+function R(n, r) {
+  return g(n, () => r);
 }
-function H(n) {
+function V(n) {
   return Array.from(new Set(n));
 }
-function J(n, e) {
+function W(n, r) {
   const t = {};
-  return n.forEach((r) => {
-    t[e(r)] = r;
-  }), w(t).map((r) => t[r]);
+  return n.forEach((e) => {
+    t[r(e)] = e;
+  }), v(t).map((e) => t[e]);
 }
-function Q(n, e) {
-  const t = n.indexOf(e);
+function E(n, r) {
+  const t = n.indexOf(r);
   return t < 0 ? !1 : (n.splice(t, 1), !0);
 }
-function U(n, e) {
-  const t = n.findIndex(e);
+function z(n, r) {
+  let t = !1;
+  for (; E(n, r); )
+    t = !0;
+  return t;
+}
+function w(n, r) {
+  const t = n.findIndex(r);
   return t < 0 ? !1 : (n.splice(t, 1), !0);
 }
-function X(n) {
-  const e = [];
+function G(n, r) {
+  let t = !1;
+  for (; w(n, r); )
+    t = !0;
+  return t;
+}
+function J(n) {
+  const r = [];
   for (let t = n.next(); !(t.done ?? !1); t = n.next())
-    e.push(t.value);
-  return e;
+    r.push(t.value);
+  return r;
 }
-function Y(n, e, t) {
-  const r = {
+function Q(n, r, t) {
+  const e = {
     removals: [],
     swaps: [],
     inserts: []
-  }, { removals: u, inserts: s, swaps: a } = r, i = /* @__PURE__ */ new Map();
-  e.forEach((o, f) => i.set(t(o), f));
-  const l = n.map((o, f) => [o, f]).filter(([o]) => !i.has(t(o))).map(([o, f]) => f);
-  for (let o = l.length - 1; o >= 0; o--) {
-    const f = l[o], c = u.length > 0 ? u[u.length - 1] : void 0;
-    c != null && c.at === f + 1 ? (c.at--, c.qt++) : u.push({ at: f, qt: 1 });
+  }, { removals: u, inserts: l, swaps: c } = e, s = /* @__PURE__ */ new Map();
+  r.forEach((o, f) => s.set(t(o), f));
+  const a = n.map((o, f) => [o, f]).filter(([o]) => !s.has(t(o))).map(([o, f]) => f);
+  for (let o = a.length - 1; o >= 0; o--) {
+    const f = a[o], i = u.length > 0 ? u[u.length - 1] : void 0;
+    i != null && i.at === f + 1 ? (i.at--, i.qt++) : u.push({ at: f, qt: 1 });
   }
   const h = /* @__PURE__ */ new Map();
   n.forEach((o, f) => h.set(t(o), f));
-  const g = e.map((o, f) => [o, f]).filter(([o]) => !h.has(t(o))).map(([o, f]) => f);
-  for (const o of g) {
-    const f = s.length > 0 ? s[s.length - 1] : void 0;
-    f != null && f.at + f.values.length === o ? f.values.push(e[o]) : s.push({ at: o, values: [e[o]] });
+  const y = r.map((o, f) => [o, f]).filter(([o]) => !h.has(t(o))).map(([o, f]) => f);
+  for (const o of y) {
+    const f = l.length > 0 ? l[l.length - 1] : void 0;
+    f != null && f.at + f.values.length === o ? f.values.push(r[o]) : l.push({ at: o, values: [r[o]] });
   }
-  const p = n.filter((o, f) => !l.includes(f)), m = /* @__PURE__ */ new Map();
+  const p = n.filter((o, f) => !a.includes(f)), m = /* @__PURE__ */ new Map();
   for (let o = 0; o < p.length; o++)
     m.set(t(p[o]), o);
-  const d = e.filter((o, f) => !g.includes(f));
-  for (let o = 0; o < d.length; o++) {
-    const f = t(d[o]), c = m.get(f);
-    if (c == null || o === c) continue;
-    const k = t(p[o]);
-    m.delete(k), a.push({ from: o, to: c });
+  const A = r.filter((o, f) => !y.includes(f));
+  for (let o = 0; o < A.length; o++) {
+    const f = t(A[o]), i = m.get(f);
+    if (i == null || o === i) continue;
+    const d = t(p[o]);
+    m.delete(d), c.push({ from: o, to: i });
   }
-  return r;
+  return e;
 }
-function Z(n, e) {
-  const t = [...e];
-  for (const { at: r, qt: u } of n.removals)
-    t.splice(r, u);
-  for (const { from: r, to: u } of n.swaps) {
-    const s = t[u];
-    t[u] = t[r], t[r] = s;
+function U(n, r) {
+  const t = [...r];
+  for (const { at: e, qt: u } of n.removals)
+    t.splice(e, u);
+  for (const { from: e, to: u } of n.swaps) {
+    const l = t[u];
+    t[u] = t[e], t[e] = l;
   }
-  for (const r of n.inserts)
-    t.splice(r.at, 0, ...r.values);
+  for (const e of n.inserts)
+    t.splice(e.at, 0, ...e.values);
   return t;
 }
-function F(n, e = " and ", t = ", ") {
-  return n.length === 0 ? "" : n.length === 1 ? String(n[0]) : `${n.slice(0, -1).join(t)}${e}${String(n[n.length - 1])}`;
-}
-function K(n, e, t = !0) {
-  const r = n.map((i, l) => [i, l]);
-  r.sort((i, l) => e(i[0], l[0]));
-  const u = new Array(r.length);
-  let s = 0, a = r[0][0];
-  for (let i = 0; i < r.length; i++) {
-    const [l, h] = r[i];
-    e(l, a) !== 0 && (s = i, a = l), u[h] = s, t && s++;
+function X(n, r = " and ", t = ", ") {
+  return n.length === 0 ? "" : n.length === 1 ? String(n[0]) : `${n.slice(0, -1).join(t)}${r}${String(n[n.length - 1])}`;
+}
+function Y(n, r, t = !0) {
+  const e = n.map((s, a) => [s, a]);
+  e.sort((s, a) => r(s[0], a[0]));
+  const u = new Array(e.length);
+  let l = 0, c = e[0][0];
+  for (let s = 0; s < e.length; s++) {
+    const [a, h] = e[s];
+    r(a, c) !== 0 && (l = s, c = a), u[h] = l, t && l++;
   }
   return u;
 }
 export {
-  D as all,
-  R as any,
-  Z as applyOperations,
-  L as concat,
-  Y as diffOperations,
-  J as distinctByPredicate,
-  H as distinctPrimitive,
-  T as each,
-  A as equals,
-  G as fill,
-  E as filter,
-  P as filterMap,
-  S as filterNulls,
-  y as flatMap,
-  $ as flatten,
-  C as foldLeft,
-  j as hasValues,
-  B as head,
-  O as isEmpty,
-  F as joinWithConjunction,
-  V as makeCompare,
-  N as makeEquals,
-  _ as map,
-  q as mapNotNull,
-  z as numbersRange,
-  X as ofIterableIterator,
-  x as range,
-  K as rank,
-  Q as remove,
-  U as removeByPredicate,
-  W as sort,
-  I as tail
+  S as allElements,
+  N as anyElement,
+  U as applyArrayDiffOperations,
+  F as areArraysEqual,
+  Q as arrayDiffOperations,
+  M as arrayHasValues,
+  _ as arrayHead,
+  J as arrayOfIterableIterator,
+  k as arrayTail,
+  H as compareArrays,
+  $ as concatArrays,
+  R as createFilledArray,
+  x as filterArray,
+  b as filterMapArray,
+  j as filterNullsFromArray,
+  B as flatMapArray,
+  D as flattenArray,
+  P as foldLeftArray,
+  T as forEachElement,
+  g as generateArray,
+  L as generateSequenceArray,
+  I as isArrayEmpty,
+  X as joinArrayWithConjunction,
+  q as mapArray,
+  Y as rankArray,
+  z as removeAllFromArray,
+  G as removeAllFromArrayByPredicate,
+  E as removeOneFromArray,
+  w as removeOneFromArrayByPredicate,
+  C as sortArray,
+  W as uniqueByPredicate,
+  V as uniquePrimitives
 };

package/async-result.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u={notAsked:{type:"NotAsked"},loading(e=void 0){return{type:"Loading",previousValue:e}},success(e){return{type:"Success",value:e}},failure(e){return{type:"Failure",error:e}},isSuccess(e){return e.type==="Success"},isFailure(e){return e.type==="Failure"},isNotAsked(e){return e.type==="NotAsked"},isLoading(e){return e.type==="Loading"},getOrElse(e,s){return u.isSuccess(e)?e.value:s},getOrElseLazy(e,s){return u.isSuccess(e)?e.value:s()},getOrNull(e){return u.isSuccess(e)?e.value:null},getOrUndefined(e){return u.isSuccess(e)?e.value:void 0},cmatch:(e,s,t,i=t)=>r=>u.isSuccess(r)?e(r.value):u.isFailure(r)?s(r.error):u.isNotAsked(r)?i():t(r.previousValue),match:(e,s,t,i,r=i)=>u.isSuccess(e)?s(e.value):u.isFailure(e)?t(e.error):u.isNotAsked(e)?r():i(e.previousValue),whenSuccess:e=>s=>(u.isSuccess(s)&&e(s.value),s),whenFailure:e=>s=>(u.isFailure(s)&&e(s.error),s)};exports.AsyncResult=u;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s={notAsked:{type:"NotAsked"},loading(e=void 0){return{type:"Loading",previousValue:e}},success(e){return{type:"AsyncSuccess",value:e}},failure(e){return{type:"AsyncFailure",error:e}},isSuccess(e){return e.type==="AsyncSuccess"},isFailure(e){return e.type==="AsyncFailure"},isNotAsked(e){return e.type==="NotAsked"},isLoading(e){return e.type==="Loading"},getOrElse(e,u){return s.isSuccess(e)?e.value:u},getOrElseLazy(e,u){return s.isSuccess(e)?e.value:u()},getOrNull(e){return s.isSuccess(e)?e.value:null},getOrUndefined(e){return s.isSuccess(e)?e.value:void 0},match:(e,{success:u,failure:r,loading:t,notAsked:i=t})=>s.isSuccess(e)?u(e.value):s.isFailure(e)?r(e.error):s.isNotAsked(e)?i():t(e.previousValue),whenSuccess:(e,u)=>(s.isSuccess(e)&&u(e.value),e),whenFailure:(e,u)=>(s.isFailure(e)&&u(e.error),e)};exports.AsyncResult=s;

package/async-result.d.ts

@@ -1,36 +1,175 @@
+import { Maybe } from './domain';
+
+/**
+ * Represents the state when a result has not been requested yet.
+ * @public
+ */
 export interface NotAsked {
     type: 'NotAsked';
 }
+/**
+ * Represents a loading state in an asynchronous result.
+ * @public
+ */
 export interface Loading<V> {
     type: 'Loading';
     previousValue?: V;
 }
-export interface Success<V> {
-    type: 'Success';
+/**
+ * Represents a successful result.
+ * @typeParam V - The type of the value.
+ * @public
+ */
+export interface AsyncSuccess<V> {
+    type: 'AsyncSuccess';
     value: V;
 }
-export interface Failure<E> {
-    type: 'Failure';
+/**
+ * Represents a failure result.
+ * @typeParam E - - The type of the error.
+ * @public
+ */
+export interface AsyncFailure<E> {
+    type: 'AsyncFailure';
     error: E;
 }
-export type AsyncResult<V, E> = NotAsked | Loading<V> | Success<V> | Failure<E>;
+/**
+ * Represents the result of an asynchronous operation that can be in one of the following states:
+ * - `NotAsked`: The operation has not been requested yet.
+ * - `Loading`: The operation is currently in progress.
+ * - `Success`: The operation has completed successfully and contains a value of type `V`.
+ * - `Failure`: The operation has completed with an error and contains an error of type `E`.
+ *
+ * @typeParam V - The type of the value on success.
+ * @typeParam E - The type of the error on failure.
+ * @public
+ */
+export type AsyncResult<V, E> = NotAsked | Loading<V> | AsyncSuccess<V> | AsyncFailure<E>;
+/**
+ * A set of utility functions for working with `AsyncResult`.
+ * @public
+ */
 export declare const AsyncResult: {
+    /**
+     * Creates a loading state.
+     * @param previousValue - The previous value.
+     * @returns A loading state.
+     * @public
+     */
     notAsked: {
         type: "NotAsked";
     };
-    loading<V>(previousValue?: V | undefined): AsyncResult<V, never>;
+    /**
+     * Creates a loading state.
+     * @param previousValue - The previous value.
+     * @returns A loading state.
+     * @public
+     */
+    loading<V>(previousValue?: Maybe<V>): AsyncResult<V, never>;
+    /**
+     * Creates a successful state.
+     * @param value - The value.
+     * @returns A successful state.
+     * @public
+     */
     success<V>(value: V): AsyncResult<V, never>;
+    /**
+     * Creates a failure state.
+     * @param error - The error.
+     * @returns A failure state.
+     * @public
+     */
     failure<E>(error: E): AsyncResult<never, E>;
-    isSuccess<V, E>(r: AsyncResult<V, E>): r is Success<V>;
-    isFailure<V, E>(r: AsyncResult<V, E>): r is Failure<E>;
+    /**
+     * Checks if the result is a success.
+     * @param r - The result.
+     * @returns `true` if the result is a success; otherwise, `false`.
+     * @public
+     */
+    isSuccess<V, E>(r: AsyncResult<V, E>): r is AsyncSuccess<V>;
+    /**
+     * Checks if the result is a failure.
+     * @param r - The result.
+     * @returns `true` if the result is a failure; otherwise, `false`.
+     * @public
+     */
+    isFailure<V, E>(r: AsyncResult<V, E>): r is AsyncFailure<E>;
+    /**
+     * Checks if the result is a not-asked.
+     * @param r - The result.
+     * @returns `true` if the result is not-asked; otherwise, `false`.
+     * @public
+     */
     isNotAsked<V, E>(r: AsyncResult<V, E>): r is NotAsked;
+    /**
+     * Checks if the result is a loading.
+     * @param r - The result.
+     * @returns `true` if the result is loading; otherwise, `false`.
+     * @public
+     */
     isLoading<V, E>(r: AsyncResult<V, E>): r is Loading<V>;
+    /**
+     * Gets the value if the result is a success; otherwise, returns the alternative value.
+     * @param r - The result.
+     * @param alt - The alternative value.
+     * @returns The value if the result is a success; otherwise, the alternative value.
+     * @public
+     */
     getOrElse<V, E>(r: AsyncResult<V, E>, alt: V): V;
+    /**
+     * Gets the value if the result is a success; otherwise, returns the value from the alternative function.
+     * @param r - The result.
+     * @param altf - The alternative function.
+     * @returns The value if the result is a success; otherwise, the value from the alternative
+     * @public
+     * function.
+     */
     getOrElseLazy<V, E>(r: AsyncResult<V, E>, altf: () => V): V;
+    /**
+     * Gets the value if the result is a success; otherwise, returns `null`.
+     * @param r - The result.
+     * @returns The value if the result is a success; otherwise, `null`.
+     * @public
+     */
     getOrNull<V, E>(r: AsyncResult<V, E>): V | null;
-    getOrUndefined<V, E>(r: AsyncResult<V, E>): V | undefined;
-    cmatch: <V1, V2, E>(success: (value: V1) => V2, failure: (error: E) => V2, loading: (previousValue?: V1) => V2, idle?: () => V2) => (r: AsyncResult<V1, E>) => V2;
-    match: <V1, V2, E>(r: AsyncResult<V1, E>, success: (value: V1) => V2, failure: (error: E) => V2, loading: (previousValue?: V1) => V2, idle?: () => V2) => V2;
-    whenSuccess: <V, E>(apply: (v: V) => void) => (r: AsyncResult<V, E>) => AsyncResult<V, E>;
-    whenFailure: <V, E>(apply: (e: E) => void) => (r: AsyncResult<V, E>) => AsyncResult<V, E>;
+    /**
+     * Gets the value if the result is a success; otherwise, returns `undefined`.
+     * @param r - The result.
+     * @returns The value if the result is a success; otherwise, `undefined`.
+     * @public
+     */
+    getOrUndefined<V, E>(r: AsyncResult<V, E>): Maybe<V>;
+    /**
+     * Based on the state of the result, it picks the appropriate function to call and returns the result.
+     * @param success - The function to call if the result is a success.
+     * @param failure - The function to call if the result is a failure.
+     * @param loading - The function to call if the result is loading.
+     * @param notAsked - The function to call if the result is not-asked.
+     * @returns The result of calling the appropriate function based on the state of the result.
+     * @public
+     */
+    match: <V1, V2, E>(r: AsyncResult<V1, E>, { success, failure, loading, notAsked, }: {
+        success: (value: V1) => V2;
+        failure: (error: E) => V2;
+        loading: (previousValue?: V1) => V2;
+        notAsked: () => V2;
+    }) => V2;
+    /**
+     * When the result is a success, it applies the function to the value.
+     *
+     * @param r - The result.
+     * @param apply - The function to apply.
+     * @returns The result that was passed in.
+     * @public
+     */
+    whenSuccess: <V, E>(r: AsyncResult<V, E>, apply: (v: V) => void) => AsyncResult<V, E>;
+    /**
+     * When the result is a failure, it applies the function to the error.
+     *
+     * @param r - The result.
+     * @param apply - The function to apply.
+     * @returns The result that was passed in.
+     * @public
+     */
+    whenFailure: <V, E>(r: AsyncResult<V, E>, apply: (e: E) => void) => AsyncResult<V, E>;
 };