@terrygonguet/utils 0.0.8 → 0.0.10

package/dist/functional.js

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

package/dist/main.js

@@ -1,22 +1,55 @@
-function o(n, t, r) {
-  return Math.min(Math.max(n, t), r);
+import { constant as r } from "./functional.js";
+function s(n, t, e) {
+  return Math.min(Math.max(n, t), e);
 }
-function c(n, t, r) {
+function a(n, t, e) {
   try {
-    return JSON.parse(n, r);
+    return JSON.parse(n, e);
   } catch {
     return t;
   }
 }
-function f(...n) {
-  return function(t, r) {
-    for (const e of n)
-      r = e(t, r);
-    return r;
+function i(...n) {
+  return function(t, e) {
+    for (const o of n)
+      e = o(t, e);
+    return e;
   };
 }
+function u() {
+  const n = () => o, t = r(!1), e = r(!0), o = new Proxy(() => {
+  }, {
+    get: n,
+    set: n,
+    apply: n,
+    construct: n,
+    deleteProperty: e,
+    has: e,
+    preventExtensions: t,
+    defineProperty: t
+  });
+  return o;
+}
+function f() {
+}
+function p(n) {
+  throw new Error("This should never be called");
+}
+async function h(n) {
+  const e = new TextEncoder().encode(n);
+  return await crypto.subtle.digest("SHA-1", e);
+}
+function* d(n, t, e = 1) {
+  for (let o = n; o < t; o += e)
+    yield o;
+}
 export {
-  o as clamp,
-  f as composeJSONRevivers,
-  c as safeParse
+  s as clamp,
+  i as composeJSONRevivers,
+  u as createNoopProxy,
+  p as exhaustive,
+  h as hash,
+  f as noop,
+  d as range,
+  a as safeParse
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.0.8",
+	"version": "0.0.10",
 	"type": "module",
 	"module": "./dist/main.js",
 	"author": {
@@ -29,18 +29,21 @@
 	],
 	"exports": {
 		".": {
-			"types": "./types/main.d.ts",
 			"import": "./dist/main.js"
 		},
 		"./async": {
-			"types": "./types/async.d.ts",
 			"import": "./dist/async.js"
 		},
 		"./functional": {
-			"types": "./types/functional/index.d.ts",
 			"import": "./dist/functional.js"
 		}
 	},
+	"typesVersions": {
+		"*": {
+			"async": ["./types/async.d.ts"],
+			"functional": ["./types/functional/index.d.ts"]
+		}
+	},
 	"types": "./types/main.d.ts",
 	"dependencies": {
 		"just-compose": "^2.3.0"

package/src/functional/index.ts

@@ -1,3 +1,5 @@
+import { Maybe } from "./maybe.ts"
+
 export * from "./maybe.ts"
 export * from "./result.ts"
 export { default as compose } from "just-compose"
@@ -5,3 +7,20 @@ export { default as compose } from "just-compose"
 export function identity<T>(value: T) {
 	return value
 }
+
+export function constant<T>(value: T) {
+	return () => value
+}
+
+export function at<T>(arr: T[], idx: number) {
+	return Maybe.from(arr.at(idx))
+}
+
+export function find<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean) {
+	return Maybe.from(arr.find(predicate))
+}
+
+export function findIndex<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean): Maybe<number> {
+	const idx = arr.findIndex(predicate)
+	return idx == -1 ? Maybe.None : Maybe.Some(idx)
+}

package/src/functional/maybe.ts

@@ -1,4 +1,5 @@
-import { identity } from "./index.ts"
+import { compose, constant, identity } from "./index.ts"
+import { Result } from "./result.ts"
 
 interface API<T> {
 	isSome(this: Maybe<T>): this is Some<T>
@@ -6,6 +7,7 @@ interface API<T> {
 	orDefault(this: Maybe<T>, defaultValue: T): T
 	map<U>(this: Maybe<T>, f: (value: T) => U): Maybe<U>
 	flatMap<U>(this: Maybe<T>, f: (value: T) => Maybe<U>): Maybe<U>
+	toResult<U>(this: Maybe<T>, mapNone?: () => U): Result<T, U>
 	toJSON(this: Maybe<T>): Object
 }
 
@@ -31,6 +33,9 @@ function Some<T>(value: NonNullable<T>): Some<T> {
 			flatMap(this: Some<T>, f) {
 				return f(this.value)
 			},
+			toResult(this: Some<T>) {
+				return Result.Success(this.value)
+			},
 			toJSON(this: Some<T>) {
 				return { $_kind, $_variant: $_variant_Some, value: this.value }
 			},
@@ -47,9 +52,10 @@ const None: None<any> = Object.create(
 	{
 		isSome: () => false,
 		isNone: () => true,
-		orDefault: identity,
+		orDefault: defaultValue => defaultValue,
 		map: () => None,
 		flatMap: () => None,
+		toResult: mapNone => Result.Failure(mapNone?.()),
 		toJSON: () => ({ $_kind, $_variant: $_variant_None }),
 	} as API<any>,
 	{
@@ -70,6 +76,13 @@ export const Maybe = {
 				return 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(None))
+	},
 	JSONReviver(_key: string, value: any) {
 		if (value?.$_kind == $_kind) {
 			const $_variant = value?.$_variant

package/src/functional/result.ts

@@ -1,4 +1,5 @@
-import { identity } from "./index.ts"
+import { compose, identity } from "./index.ts"
+import { Maybe } from "./maybe.ts"
 
 interface API<S, F> {
 	isSuccess(this: Result<S, F>): this is Success<S, F>
@@ -75,6 +76,16 @@ export const Result = {
 	try<S, F>(tryFn: () => S) {
 		return new TryCatch<S, F>(tryFn)
 	},
+	fromPromise<S, F>(
+		promise: Promise<S>,
+		onResolve: (value: S) => S,
+		onReject: (reason: unknown) => F,
+	): Promise<Result<S, F>> {
+		return promise.then(compose(onResolve, Success<S, F>), compose(onReject, Failure<S, F>))
+	},
+	fromMaybe<S, F>(maybe: Maybe<S>, mapNone?: () => F) {
+		return maybe.toResult(mapNone)
+	},
 	JSONReviver(_key: string, value: any) {
 		if (value?.$_kind == $_kind) {
 			const $_variant = value?.$_variant

package/src/main.ts

@@ -1,3 +1,5 @@
+import { constant } from "./functional/index.ts"
+
 /**
  * Behaviour is undefined when max < min
  */
@@ -23,3 +25,39 @@ export function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver {
 		return value
 	}
 }
+
+export function createNoopProxy<T>() {
+	const noop = () => proxy
+	const no = constant(false)
+	const yes = constant(true)
+	const proxy: any = new Proxy(() => {}, {
+		get: noop,
+		set: noop,
+		apply: noop,
+		construct: noop,
+		deleteProperty: yes,
+		has: yes,
+		preventExtensions: no,
+		defineProperty: no,
+	})
+	return proxy as T
+}
+
+export function noop() {}
+
+export function exhaustive(_: never): never {
+	throw new Error("This should never be called")
+}
+
+export async function hash(message: string) {
+	const encoder = new TextEncoder()
+	const data = encoder.encode(message)
+	const hash = await crypto.subtle.digest("SHA-1", data)
+	return hash
+}
+
+export function* range(start: number, end: number, step = 1) {
+	for (let i = start; i < end; i += step) {
+		yield i
+	}
+}

package/types/functional/index.d.ts

@@ -1,4 +1,9 @@
+import { Maybe } from "./maybe.ts";
 export * from "./maybe.ts";
 export * from "./result.ts";
 export { default as compose } from "just-compose";
 export declare function identity<T>(value: T): T;
+export declare function constant<T>(value: T): () => T;
+export declare function at<T>(arr: T[], idx: number): Maybe<T>;
+export declare function find<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean): Maybe<T>;
+export declare function findIndex<T>(arr: T[], predicate: (value: T, idx: number, arr: T[]) => boolean): Maybe<number>;

package/types/functional/maybe.d.ts

@@ -1,9 +1,11 @@
+import { Result } from "./result.ts";
 interface API<T> {
     isSome(this: Maybe<T>): this is Some<T>;
     isNone(this: Maybe<T>): this is None<T>;
     orDefault(this: Maybe<T>, defaultValue: T): T;
     map<U>(this: Maybe<T>, f: (value: T) => U): Maybe<U>;
     flatMap<U>(this: Maybe<T>, f: (value: T) => Maybe<U>): Maybe<U>;
+    toResult<U>(this: Maybe<T>, mapNone?: () => U): Result<T, U>;
     toJSON(this: Maybe<T>): Object;
 }
 export type Some<T> = {
@@ -16,6 +18,11 @@ export declare const Maybe: {
     Some: typeof Some;
     None: None<any>;
     from<T>(value: T | null | undefined): Maybe<T>;
+    /**
+     * CAUTION: this method swallows errors and simply returns None!
+     * Use `Result.fromPromise()` if you need error details.
+     */
+    fromPromise<T_1>(promise: Promise<T_1>, onResolve?: (value: T_1) => T_1): Promise<Maybe<T_1>>;
     JSONReviver(_key: string, value: any): any;
 };
 export {};

package/types/functional/result.d.ts

@@ -1,3 +1,4 @@
+import { Maybe } from "./maybe.ts";
 interface API<S, F> {
     isSuccess(this: Result<S, F>): this is Success<S, F>;
     isFailure(this: Result<S, F>): this is Failure<S, F>;
@@ -19,6 +20,8 @@ export declare const Result: {
     Success: typeof Success;
     Failure: typeof Failure;
     try<S, F>(tryFn: () => S): TryCatch<S, F>;
+    fromPromise<S_1, F_1>(promise: Promise<S_1>, onResolve: (value: S_1) => S_1, onReject: (reason: unknown) => F_1): Promise<Result<S_1, F_1>>;
+    fromMaybe<S_2, F_2>(maybe: Maybe<S_2>, mapNone?: (() => F_2) | undefined): Result<S_2, F_2>;
     JSONReviver(_key: string, value: any): any;
 };
 declare class TryCatch<S, F> {

package/types/main.d.ts

@@ -5,4 +5,9 @@ export declare function clamp(value: number, min: number, max: number): number;
 type JSONReviver = (key: string, value: any) => any;
 export declare function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver): any;
 export declare function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver;
+export declare function createNoopProxy<T>(): T;
+export declare function noop(): void;
+export declare function exhaustive(_: never): never;
+export declare function hash(message: string): Promise<ArrayBuffer>;
+export declare function range(start: number, end: number, step?: number): Generator<number, void, unknown>;
 export {};