@tempots/std 0.10.5 → 0.10.6

package/async-result.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u={idle:{type:"idle"},loading:{type:"loading"},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"},isIdle(e){return e.type==="idle"},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.isIdle(r)?i():t(),match:(e,s,t,i,r=i)=>u.isSuccess(e)?s(e.value):u.isFailure(e)?t(e.error):u.isIdle(e)?r():i(),whenSuccess:e=>s=>(u.isSuccess(s)&&e(s.value),s),whenFailure:e=>s=>(u.isFailure(s)&&e(s.error),s)};exports.AsyncResult=u;

package/async-result.d.ts

@@ -0,0 +1,37 @@
+export interface Idle {
+    type: 'idle';
+}
+export interface Loading {
+    type: 'loading';
+}
+export interface Success<V> {
+    type: 'success';
+    value: V;
+}
+export interface Failure<E> {
+    type: 'failure';
+    error: E;
+}
+export type AsyncResult<V, E> = Idle | Loading | Success<V> | Failure<E>;
+export declare const AsyncResult: {
+    idle: {
+        type: "idle";
+    };
+    loading: {
+        type: "loading";
+    };
+    success<V>(value: V): AsyncResult<V, never>;
+    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>;
+    isIdle<V, E>(r: AsyncResult<V, E>): r is Idle;
+    isLoading<V, E>(r: AsyncResult<V, E>): r is Loading;
+    getOrElse<V, E>(r: AsyncResult<V, E>, alt: V): V;
+    getOrElseLazy<V, E>(r: AsyncResult<V, E>, altf: () => V): V;
+    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: () => 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: () => 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>;
+};

package/async-result.js

@@ -0,0 +1,41 @@
+const u = {
+  idle: { type: "idle" },
+  loading: { type: "loading" },
+  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";
+  },
+  isIdle(e) {
+    return e.type === "idle";
+  },
+  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, i, t = i) => (r) => u.isSuccess(r) ? e(r.value) : u.isFailure(r) ? s(r.error) : u.isIdle(r) ? t() : i(),
+  match: (e, s, i, t, r = t) => u.isSuccess(e) ? s(e.value) : u.isFailure(e) ? i(e.error) : u.isIdle(e) ? r() : t(),
+  whenSuccess: (e) => (s) => (u.isSuccess(s) && e(s.value), s),
+  whenFailure: (e) => (s) => (u.isFailure(s) && e(s.error), s)
+};
+export {
+  u as AsyncResult
+};

package/function.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function u(...r){return t=>r.reduce((e,n)=>n(e),t)}function i(r){return r}function c(r){return t=>(...e)=>r(t,...e)}function o(r){return(...t)=>e=>r(...t.concat([e]))}function f(r){return(...t)=>r(...t.reverse())}function y(r){return r}exports.compose=u;exports.curryLeft=c;exports.curryRight=o;exports.flip=f;exports.id=y;exports.identity=i;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function i(...e){return r=>e.reduce((t,n)=>n(t),r)}function u(e){return e}function o(e){return r=>(...t)=>e(r,...t)}function c(e){return(...r)=>t=>e(...r.concat([t]))}function f(e){return(...r)=>e(...r.reverse())}function d(e){return e}function y(e){let r;return()=>(r===void 0&&(r=e()),r)}exports.compose=i;exports.curryLeft=o;exports.curryRight=c;exports.flip=f;exports.id=d;exports.identity=u;exports.memoize=y;

package/function.d.ts

@@ -18,3 +18,4 @@ export declare function flip<A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E): (
 export declare function flip<A, B, C, D, E, F>(f: (a: A, b: B, c: C, d: D, e: E) => F): (e: E, d: D, c: C, b: B, a: A) => F;
 export declare function flip<A, B, C, D, E, F, G>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => G): (f: F, e: E, d: D, c: C, b: B, a: A) => G;
 export declare function id<T>(v: T): T;
+export declare function memoize<T>(f: () => NonNullable<T>): () => NonNullable<T>;

package/function.js

@@ -1,10 +1,10 @@
 function u(...n) {
   return (r) => n.reduce((t, e) => e(t), r);
 }
-function c(n) {
+function i(n) {
   return n;
 }
-function i(n) {
+function c(n) {
   return (r) => (...t) => n(r, ...t);
 }
 function o(n) {
@@ -19,11 +19,16 @@ function f(n) {
 function d(n) {
   return n;
 }
+function l(n) {
+  let r;
+  return () => (r === void 0 && (r = n()), r);
+}
 export {
   u as compose,
-  i as curryLeft,
+  c as curryLeft,
   o as curryRight,
   f as flip,
   d as id,
-  c as identity
+  i as identity,
+  l as memoize
 };

package/json.cjs

@@ -0,0 +1 @@
+"use strict";

package/json.d.ts

@@ -0,0 +1,6 @@
+export type JSONPrimitive = string | boolean | number | null | undefined;
+export interface JSONObject {
+    [k: string]: JSONValue;
+}
+export type JSONArray = JSONValue[];
+export type JSONValue = JSONPrimitive | JSONObject | JSONArray;

package/json.js

@@ -0,0 +1 @@
+

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@tempots/std",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "type": "module",
   "exports": {
     "./array": {
       "import": "./array.js",
       "require": "./array.cjs"
     },
+    "./async-result": {
+      "import": "./async-result.js",
+      "require": "./async-result.cjs"
+    },
     "./bigint": {
       "import": "./bigint.js",
       "require": "./bigint.cjs"
@@ -31,6 +35,10 @@
       "import": "./index.js",
       "require": "./index.cjs"
     },
+    "./json": {
+      "import": "./json.js",
+      "require": "./json.cjs"
+    },
     "./maybe": {
       "import": "./maybe.js",
       "require": "./maybe.cjs"
@@ -47,9 +55,17 @@
       "import": "./regexp.js",
       "require": "./regexp.cjs"
     },
+    "./result": {
+      "import": "./result.js",
+      "require": "./result.cjs"
+    },
     "./string": {
       "import": "./string.js",
       "require": "./string.cjs"
+    },
+    "./validation": {
+      "import": "./validation.js",
+      "require": "./validation.cjs"
     }
   },
   "license": "Apache-2.0",
@@ -66,6 +82,9 @@
       "array": [
         "./array.d.ts"
       ],
+      "async-result": [
+        "./async-result.d.ts"
+      ],
       "bigint": [
         "./bigint.d.ts"
       ],
@@ -84,6 +103,9 @@
       "index": [
         "./index.d.ts"
       ],
+      "json": [
+        "./json.d.ts"
+      ],
       "maybe": [
         "./maybe.d.ts"
       ],
@@ -96,8 +118,14 @@
       "regexp": [
         "./regexp.d.ts"
       ],
+      "result": [
+        "./result.d.ts"
+      ],
       "string": [
         "./string.d.ts"
+      ],
+      "validation": [
+        "./validation.d.ts"
       ]
     }
   }

package/result.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u={success(e){return{type:"success",value:e}},failure(e){return{type:"failure",error:e}},cmap:e=>s=>s.type==="success"?u.success(e(s.value)):s,map:(e,s)=>e.type==="success"?u.success(s(e.value)):e,cflatMap:e=>s=>s.type==="success"?e(s.value):s,flatMap:(e,s)=>e.type==="success"?s(e.value):e,toAsync(e){return e},isSuccess(e){return e.type==="success"},isFailure(e){return e.type==="failure"},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=>u.isSuccess(t)?e(t.value):s(t.error),match:(e,s,t)=>u.isSuccess(e)?s(e.value):t(e.error),whenSuccess:e=>s=>(u.isSuccess(s)&&e(s.value),s),whenFailure:e=>s=>(u.isFailure(s)&&e(s.error),s),combine:(e,s,t,l)=>u.match(e,r=>u.match(s,c=>u.success(t(r,c)),c=>u.failure(c)),r=>u.match(s,c=>u.failure(r),c=>u.failure(l(r,c))))};exports.Result=u;

package/result.d.ts

@@ -0,0 +1,32 @@
+import { AsyncResult } from './async-result';
+
+export interface Success<V> {
+    type: 'success';
+    value: V;
+}
+export interface Failure<E> {
+    type: 'failure';
+    error: E;
+}
+export type Result<V, E> = Success<V> | Failure<E>;
+export type PromiseResult<V, E> = PromiseLike<Result<V, E>>;
+export declare const Result: {
+    success<V>(value: V): Result<V, any>;
+    failure<E>(error: E): Result<any, E>;
+    cmap: <V1, V2, E>(f: (value: V1) => V2) => (r: Result<V1, E>) => Result<V2, E>;
+    map: <V1, V2, E>(r: Result<V1, E>, f: (value: V1) => V2) => Result<V2, E>;
+    cflatMap: <V1, V2, E>(f: (value: V1) => Result<V2, E>) => (r: Result<V1, E>) => Result<V2, E>;
+    flatMap: <V1, V2, E>(r: Result<V1, E>, f: (value: V1) => Result<V2, E>) => Result<V2, E>;
+    toAsync<V, E>(r: Result<V, E>): AsyncResult<V, E>;
+    isSuccess<V, E>(r: Result<V, E>): r is Success<V>;
+    isFailure<V, E>(r: Result<V, E>): r is Failure<E>;
+    getOrElse<V, E>(r: Result<V, E>, alt: V): V;
+    getOrElseLazy<V, E>(r: Result<V, E>, altf: () => V): V;
+    getOrNull<V, E>(r: Result<V, E>): V | null;
+    getOrUndefined<V, E>(r: Result<V, E>): V | undefined;
+    cmatch: <V1, V2, E>(success: (value: V1) => V2, failure: (error: E) => V2) => (r: Result<V1, E>) => V2;
+    match: <V1, V2, E>(r: Result<V1, E>, success: (value: V1) => V2, failure: (error: E) => V2) => V2;
+    whenSuccess: <V, E>(apply: (v: V) => void) => (r: Result<V, E>) => Result<V, E>;
+    whenFailure: <V, E>(apply: (e: E) => void) => (r: Result<V, E>) => Result<V, E>;
+    combine: <V, E>(r1: Result<V, E>, r2: Result<V, E>, combineV: (v1: V, v2: V) => V, combineE: (e1: E, e2: E) => E) => Result<V, E>;
+};

package/result.js

@@ -0,0 +1,56 @@
+const u = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  success(e) {
+    return { type: "success", value: e };
+  },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  failure(e) {
+    return { type: "failure", error: e };
+  },
+  cmap: (e) => (s) => s.type === "success" ? u.success(e(s.value)) : s,
+  map: (e, s) => e.type === "success" ? u.success(s(e.value)) : e,
+  cflatMap: (e) => (s) => s.type === "success" ? e(s.value) : s,
+  flatMap: (e, s) => e.type === "success" ? s(e.value) : e,
+  toAsync(e) {
+    return e;
+  },
+  isSuccess(e) {
+    return e.type === "success";
+  },
+  isFailure(e) {
+    return e.type === "failure";
+  },
+  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) => (c) => u.isSuccess(c) ? e(c.value) : s(c.error),
+  match: (e, s, c) => u.isSuccess(e) ? s(e.value) : c(e.error),
+  whenSuccess: (e) => (s) => (u.isSuccess(s) && e(s.value), s),
+  whenFailure: (e) => (s) => (u.isFailure(s) && e(s.error), s),
+  combine: (e, s, c, l) => u.match(
+    e,
+    (t) => u.match(
+      s,
+      (r) => u.success(c(t, r)),
+      (r) => u.failure(r)
+    ),
+    (t) => u.match(
+      s,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (r) => u.failure(t),
+      (r) => u.failure(l(t, r))
+    )
+  )
+};
+export {
+  u as Result
+};

package/validation.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("./result.cjs"),t={valid:{type:"valid"},invalid(e){return{type:"invalid",error:e}},isValid(e){return e.type==="valid"},isInvalid(e){return e.type==="invalid"},cmatch:(e,i)=>r=>t.isValid(r)?e():i(r.error),match:(e,i,r)=>t.isValid(e)?i():r(e.error),toResult:e=>t.cmatch(()=>l.Result.success(e),i=>l.Result.failure(i)),whenValid:e=>i=>(t.isValid(i)&&e(),i),whenInvalid:e=>i=>(t.isInvalid(i)&&e(i.error),i)};exports.Validation=t;

package/validation.d.ts

@@ -0,0 +1,24 @@
+import { Result } from './result';
+
+export interface Valid {
+    type: 'valid';
+}
+export interface Invalid<E> {
+    type: 'invalid';
+    error: E;
+}
+export type Validation<E> = Valid | Invalid<E>;
+export type PromiseValidation<E> = PromiseLike<Validation<E>>;
+export declare const Validation: {
+    valid: {
+        type: "valid";
+    };
+    invalid<E>(error: E): Validation<E>;
+    isValid<E>(r: Validation<E>): r is Valid;
+    isInvalid<E>(r: Validation<E>): r is Invalid<E>;
+    cmatch: <V, E>(valid: () => V, invalid: (error: E) => V) => (r: Validation<E>) => V;
+    match: <V, E>(r: Validation<E>, valid: () => V, invalid: (error: E) => V) => V;
+    toResult: <T, E>(value: T) => ((validation: Validation<E>) => Result<T, E>);
+    whenValid: <E>(apply: () => void) => (r: Validation<E>) => Validation<E>;
+    whenInvalid: <E>(apply: (e: E) => void) => (r: Validation<E>) => Validation<E>;
+};

package/validation.js

@@ -0,0 +1,25 @@
+import { Result as a } from "./result.js";
+const r = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  valid: { type: "valid" },
+  invalid(i) {
+    return { type: "invalid", error: i };
+  },
+  isValid(i) {
+    return i.type === "valid";
+  },
+  isInvalid(i) {
+    return i.type === "invalid";
+  },
+  cmatch: (i, e) => (t) => r.isValid(t) ? i() : e(t.error),
+  match: (i, e, t) => r.isValid(i) ? e() : t(i.error),
+  toResult: (i) => r.cmatch(
+    () => a.success(i),
+    (e) => a.failure(e)
+  ),
+  whenValid: (i) => (e) => (r.isValid(e) && i(), e),
+  whenInvalid: (i) => (e) => (r.isInvalid(e) && i(e.error), e)
+};
+export {
+  r as Validation
+};