@terrygonguet/utils 0.0.12 → 0.0.14

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 Terry Gonguet
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 Terry Gonguet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,2 +1,2 @@
-# utils
-Okay fine I'll make my own
+# utils
+Okay fine I'll make my own

package/package.json

@@ -1,63 +1,55 @@
-{
-	"name": "@terrygonguet/utils",
-	"version": "0.0.12",
-	"type": "module",
-	"module": "./dist/index.js",
-	"author": {
-		"email": "terry@gonguet.com",
-		"name": "Terry Gonguet",
-		"url": "https://terry.gonguet.com/"
-	},
-	"scripts": {
-		"dev": "vite",
-		"build": "tsc && vite build",
-		"test": "vitest test --ui --watch --update",
-		"coverage": "vitest run --coverage"
-	},
-	"devDependencies": {
-		"@vitest/coverage-v8": "^0.32.0",
-		"@vitest/ui": "^0.32.0",
-		"prettier": "^2.8.8",
-		"typescript": "^5.0.2",
-		"vite": "^4.3.9",
-		"vitest": "^0.32.0"
-	},
-	"files": [
-		"dist/**/*.js",
-		"src/**/!(*.test).ts",
-		"types/**/!(*.test).d.ts"
-	],
-	"exports": {
-		".": {
-			"import": "./dist/index.js"
-		},
-		"./async": {
-			"import": "./dist/async.js"
-		},
-		"./functional": {
-			"import": "./dist/functional.js"
-		}
-	},
-	"typesVersions": {
-		"*": {
-			"async": [
-				"./types/async.d.ts"
-			],
-			"functional": [
-				"./types/functional/index.d.ts"
-			]
-		}
-	},
-	"types": "./types/index.d.ts",
-	"dependencies": {
-		"just-compose": "^2.3.0",
-		"just-pipe": "^1.0.0"
-	},
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/terrygonguet/utils.git"
-	},
-	"bugs": {
-		"url": "https://github.com/terrygonguet/utils/issues"
-	}
-}
+{
+	"name": "@terrygonguet/utils",
+	"version": "0.0.14",
+	"type": "module",
+	"module": "./dist/index.js",
+	"author": {
+		"email": "terry@gonguet.com",
+		"name": "Terry Gonguet",
+		"url": "https://terry.gonguet.com/"
+	},
+	"scripts": {
+		"dev": "vite",
+		"build": "tsc && vite build",
+		"test": "vitest test --ui --watch --update",
+		"coverage": "vitest run --coverage"
+	},
+	"devDependencies": {
+		"@vitest/coverage-v8": "^0.32.0",
+		"@vitest/ui": "^0.32.0",
+		"prettier": "^2.8.8",
+		"typescript": "^5.0.2",
+		"vite": "^4.3.9",
+		"vitest": "^0.32.0"
+	},
+	"files": [
+		"dist/**/*.js",
+		"src/**/!(*.test).ts",
+		"types/**/!(*.test).d.ts"
+	],
+	"exports": {
+		".": {
+			"types": "./types/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./async": {
+			"types": "./types/async.d.ts",
+			"import": "./dist/async.js"
+		},
+		"./functional": {
+			"types": "./types/functional/index.d.ts",
+			"import": "./dist/functional.js"
+		}
+	},
+	"dependencies": {
+		"just-compose": "^2.3.0",
+		"just-pipe": "^1.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/terrygonguet/utils.git"
+	},
+	"bugs": {
+		"url": "https://github.com/terrygonguet/utils/issues"
+	}
+}

package/src/functional/index.ts

@@ -43,3 +43,38 @@ export function findIndex<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Pr
 		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/index.ts

@@ -1,63 +1,63 @@
-import { constant } from "./functional/index.ts"
-
-/**
- * Behaviour is undefined when max < min
- */
-export function clamp(value: number, min: number, max: number) {
-	return Math.min(Math.max(value, min), max)
-}
-
-type JSONReviver = (key: string, value: any) => any
-
-export function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver) {
-	try {
-		return JSON.parse(str, reviver)
-	} catch (_) {
-		return defaultValue
-	}
-}
-
-export function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver {
-	return function (key, value) {
-		for (const reviver of revivers) {
-			value = reviver(key, value)
-		}
-		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
-	}
-}
+import { constant } from "./functional/index.ts"
+
+/**
+ * Behaviour is undefined when max < min
+ */
+export function clamp(value: number, min: number, max: number) {
+	return Math.min(Math.max(value, min), max)
+}
+
+type JSONReviver = (key: string, value: any) => any
+
+export function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver) {
+	try {
+		return JSON.parse(str, reviver)
+	} catch (_) {
+		return defaultValue
+	}
+}
+
+export function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver {
+	return function (key, value) {
+		for (const reviver of revivers) {
+			value = reviver(key, value)
+		}
+		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/src/vite-env.d.ts

@@ -1 +1 @@
-/// <reference types="vite/client" />
+/// <reference types="vite/client" />

package/types/async.d.ts

@@ -1,14 +1,14 @@
-export declare function pause(ms: number): Promise<void>;
-interface RetryOptions {
-    count?: number;
-    delay?: number | ((retryCount: number, error: any) => number);
-}
-export declare function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>;
-export declare function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>;
-interface AsyncMapOptions {
-    concurrent?: number;
-}
-export declare function asyncMap<T, U>(f: AsyncMapFn<T, U>, options?: AsyncMapOptions): (data: T[]) => Promise<U[]>;
-export declare function asyncMap<T, U>(data: T[], f: AsyncMapFn<T, U>, options?: AsyncMapOptions): Promise<U[]>;
-type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>;
-export {};
+export declare function pause(ms: number): Promise<void>;
+interface RetryOptions {
+    count?: number;
+    delay?: number | ((retryCount: number, error: any) => number);
+}
+export declare function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>;
+export declare function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>;
+interface AsyncMapOptions {
+    concurrent?: number;
+}
+export declare function asyncMap<T, U>(f: AsyncMapFn<T, U>, options?: AsyncMapOptions): (data: T[]) => Promise<U[]>;
+export declare function asyncMap<T, U>(data: T[], f: AsyncMapFn<T, U>, options?: AsyncMapOptions): Promise<U[]>;
+type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>;
+export {};

package/types/functional/index.d.ts

@@ -1,14 +1,19 @@
-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 declare function identity<T>(value: T): T;
-export declare function constant<T>(value: T): () => T;
-export declare function at(idx: number): <T>(data: T[]) => Maybe<T>;
-export declare function at<T>(data: T[], idx: number): Maybe<T>;
-type Predicate<T> = (value: T, idx: number, arr: T[]) => boolean;
-export declare function find<T>(predicate: Predicate<T>): (data: T[]) => Maybe<T>;
-export declare function find<T>(data: T[], predicate: Predicate<T>): Maybe<T>;
-export declare function findIndex<T>(predicate: Predicate<T>): (data: T[]) => Maybe<number>;
-export declare function findIndex<T>(data: T[], predicate: Predicate<T>): Maybe<number>;
+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 declare function identity<T>(value: T): T;
+export declare function constant<T>(value: T): () => T;
+export declare function at(idx: number): <T>(data: T[]) => Maybe<T>;
+export declare function at<T>(data: T[], idx: number): Maybe<T>;
+type Predicate<T> = (value: T, idx: number, arr: T[]) => boolean;
+export declare function find<T>(predicate: Predicate<T>): (data: T[]) => Maybe<T>;
+export declare function find<T>(data: T[], predicate: Predicate<T>): Maybe<T>;
+export declare function findIndex<T>(predicate: Predicate<T>): (data: T[]) => Maybe<number>;
+export declare function findIndex<T>(data: T[], predicate: Predicate<T>): Maybe<number>;
+export declare function prop<T extends {}, K1 extends keyof T = keyof T>(data: T, key1: K1): Maybe<T[K1]>;
+export declare 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 declare 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 declare 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 declare 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]>;

package/types/functional/maybe.d.ts

@@ -1,45 +1,45 @@
-import { Result } from "./result.ts";
-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;
-}
-declare class Some<T> implements Maybe<T> {
-    value: T;
-    constructor(value: T);
-    isSome(): true;
-    isNone(): false;
-    orDefault(): T;
-    map<U>(f: (value: T) => U): Some<U>;
-    flatMap<U>(f: (value: T) => Maybe<U>): Maybe<U>;
-    toResult<U>(): Result<T, U>;
-    toJSON(): Object;
-}
-declare class None<T> implements Maybe<T> {
-    constructor();
-    isSome(): false;
-    isNone(): true;
-    orDefault(defaultValue: T): T;
-    map<U>(): Maybe<U>;
-    flatMap<U>(): Maybe<U>;
-    toResult(): Result<T, undefined>;
-    toResult<U>(mapNone: () => U): Result<T, U>;
-    toJSON(): Object;
-}
-export declare const Maybe: {
-    Some<T>(value: T): Maybe<T>;
-    None<T_1>(): Maybe<T_1>;
-    from<T_2>(value: T_2 | null | undefined): Maybe<T_2>;
-    /**
-     * CAUTION: this method swallows errors and simply returns None!
-     * Use `Result.fromPromise()` if you need error details.
-     */
-    fromPromise<T_3>(promise: Promise<T_3>, onResolve?: (value: T_3) => T_3): Promise<Maybe<T_3>>;
-    JSONReviver(_key: string, value: any): any;
-};
-export type { Some, None };
+import { Result } from "./result.ts";
+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;
+}
+declare class Some<T> implements Maybe<T> {
+    value: T;
+    constructor(value: T);
+    isSome(): true;
+    isNone(): false;
+    orDefault(): T;
+    map<U>(f: (value: T) => U): Some<U>;
+    flatMap<U>(f: (value: T) => Maybe<U>): Maybe<U>;
+    toResult<U>(): Result<T, U>;
+    toJSON(): Object;
+}
+declare class None<T> implements Maybe<T> {
+    constructor();
+    isSome(): false;
+    isNone(): true;
+    orDefault(defaultValue: T): T;
+    map<U>(): Maybe<U>;
+    flatMap<U>(): Maybe<U>;
+    toResult(): Result<T, undefined>;
+    toResult<U>(mapNone: () => U): Result<T, U>;
+    toJSON(): Object;
+}
+export declare const Maybe: {
+    Some<T>(value: T): Maybe<T>;
+    None<T_1>(): Maybe<T_1>;
+    from<T_2>(value: T_2 | null | undefined): Maybe<T_2>;
+    /**
+     * CAUTION: this method swallows errors and simply returns None!
+     * Use `Result.fromPromise()` if you need error details.
+     */
+    fromPromise<T_3>(promise: Promise<T_3>, onResolve?: (value: T_3) => T_3): Promise<Maybe<T_3>>;
+    JSONReviver(_key: string, value: any): any;
+};
+export type { Some, None };

package/types/functional/result.d.ts

@@ -1,58 +1,58 @@
-import { Maybe } from "./maybe.ts";
-export interface Result<S, F> {
-    isSuccess(): this is Success<S, F>;
-    isFailure(): this is Failure<S, F>;
-    merge<T>(whenSuccess: (value: S) => T, whenFailure: (reason: F) => T): T;
-    match(onSuccess: (value: S) => void, onFailure: (reason: F) => void): void;
-    map<S2>(f: (value: S) => S2): Result<S2, F>;
-    flatMap<S2, F2>(f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>;
-    toJSON(): Object;
-}
-declare class Success<S, F> implements Result<S, F> {
-    value: S;
-    constructor(value: S);
-    isSuccess(): true;
-    isFailure(): false;
-    merge<T>(whenSuccess: (value: S) => T): T;
-    match(onSuccess: (value: S) => void): void;
-    map<S2>(f: (value: S) => S2): Success<S2, F>;
-    flatMap<S2, F2>(f: (value: S) => Result<S2, F2>): Result<S2, F | F2>;
-    toJSON(this: Success<S, F>): {
-        $_kind: string;
-        $_variant: string;
-        value: S;
-    };
-}
-declare class Failure<S, F> implements Result<S, F> {
-    reason: F;
-    constructor(reason: F);
-    isSuccess(): false;
-    isFailure(): true;
-    merge<T>(_: (value: S) => T, whenFailure: (reason: F) => T): T;
-    match(_: (value: S) => void, onFailure: (reason: F) => void): void;
-    map<S2>(): Result<S2, F>;
-    flatMap<S2, F2>(): Result<S2, F | F2>;
-    toJSON(): {
-        $_kind: string;
-        $_variant: string;
-        reason: F;
-    };
-}
-declare function resultFromMaybe<S>(maybe: Maybe<S>): Result<S, undefined>;
-declare function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone: () => F): Result<S, F>;
-export declare const Result: {
-    Success<S, F>(value: S): Result<S, F>;
-    Failure<S_1, F_1>(reason: F_1): Result<S_1, F_1>;
-    try<S_2, F_2>(tryFn: () => S_2): TryCatch<S_2, F_2>;
-    fromPromise<S_3, F_3>(promise: Promise<S_3>, onResolve: (value: S_3) => S_3, onReject: (reason: unknown) => F_3): Promise<Result<S_3, F_3>>;
-    fromMaybe: typeof resultFromMaybe;
-    JSONReviver(_key: string, value: any): any;
-};
-declare class TryCatch<S, F> {
-    tryFn: () => S;
-    catchFn: (err: unknown) => F;
-    constructor(tryFn: () => S);
-    catch(catchFn: (err: unknown) => F): this;
-    exec(finallyFn?: (result: Result<S, F>) => void): Result<S, F>;
-}
-export type { Success, Failure };
+import { Maybe } from "./maybe.ts";
+export interface Result<S, F> {
+    isSuccess(): this is Success<S, F>;
+    isFailure(): this is Failure<S, F>;
+    merge<T>(whenSuccess: (value: S) => T, whenFailure: (reason: F) => T): T;
+    match(onSuccess: (value: S) => void, onFailure: (reason: F) => void): void;
+    map<S2>(f: (value: S) => S2): Result<S2, F>;
+    flatMap<S2, F2>(f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>;
+    toJSON(): Object;
+}
+declare class Success<S, F> implements Result<S, F> {
+    value: S;
+    constructor(value: S);
+    isSuccess(): true;
+    isFailure(): false;
+    merge<T>(whenSuccess: (value: S) => T): T;
+    match(onSuccess: (value: S) => void): void;
+    map<S2>(f: (value: S) => S2): Success<S2, F>;
+    flatMap<S2, F2>(f: (value: S) => Result<S2, F2>): Result<S2, F | F2>;
+    toJSON(this: Success<S, F>): {
+        $_kind: string;
+        $_variant: string;
+        value: S;
+    };
+}
+declare class Failure<S, F> implements Result<S, F> {
+    reason: F;
+    constructor(reason: F);
+    isSuccess(): false;
+    isFailure(): true;
+    merge<T>(_: (value: S) => T, whenFailure: (reason: F) => T): T;
+    match(_: (value: S) => void, onFailure: (reason: F) => void): void;
+    map<S2>(): Result<S2, F>;
+    flatMap<S2, F2>(): Result<S2, F | F2>;
+    toJSON(): {
+        $_kind: string;
+        $_variant: string;
+        reason: F;
+    };
+}
+declare function resultFromMaybe<S>(maybe: Maybe<S>): Result<S, undefined>;
+declare function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone: () => F): Result<S, F>;
+export declare const Result: {
+    Success<S, F>(value: S): Result<S, F>;
+    Failure<S_1, F_1>(reason: F_1): Result<S_1, F_1>;
+    try<S_2, F_2>(tryFn: () => S_2): TryCatch<S_2, F_2>;
+    fromPromise<S_3, F_3>(promise: Promise<S_3>, onResolve: (value: S_3) => S_3, onReject: (reason: unknown) => F_3): Promise<Result<S_3, F_3>>;
+    fromMaybe: typeof resultFromMaybe;
+    JSONReviver(_key: string, value: any): any;
+};
+declare class TryCatch<S, F> {
+    tryFn: () => S;
+    catchFn: (err: unknown) => F;
+    constructor(tryFn: () => S);
+    catch(catchFn: (err: unknown) => F): this;
+    exec(finallyFn?: (result: Result<S, F>) => void): Result<S, F>;
+}
+export type { Success, Failure };

package/types/index.d.ts

@@ -1,13 +1,13 @@
-/**
- * Behaviour is undefined when max < min
- */
-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 {};
+/**
+ * Behaviour is undefined when max < min
+ */
+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 {};

package/dist/async.js

@@ -1,65 +0,0 @@
-import { findIndex as g } from "./functional.js";
-function h(n) {
-  return new Promise((t) => setTimeout(t, n));
-}
-function x(n, t) {
-  return typeof n == "function" ? p(n, t) : (r) => p(r, n);
-}
-async function p(n, { count: t = 1 / 0, delay: r } = {}) {
-  let o = 0, s;
-  do
-    try {
-      return await n();
-    } catch (c) {
-      switch (s = c, o++, typeof r) {
-        case "number":
-          await h(r);
-          break;
-        case "function":
-          await h(r(o, c));
-          break;
-      }
-    }
-  while (o <= t);
-  throw s;
-}
-function I(n, t, r) {
-  if (typeof n == "function" && typeof t != "function") {
-    const o = n, s = t;
-    return (c) => w(c, o, s);
-  } else {
-    if (Array.isArray(n) && typeof t == "function")
-      return w(n, t, r);
-    throw new Error("Invalid arguments passed to asyncMap");
-  }
-}
-async function w(n, t, { concurrent: r = 5 } = {}) {
-  return new Promise((o, s) => {
-    const c = [], u = [];
-    let i = 0;
-    function y(e) {
-      if (c.length == n.length && u.length == 0)
-        return m();
-      if (e >= n.length)
-        return;
-      const f = n[e];
-      u.push([
-        e,
-        t(f, e, n).then((a) => {
-          c.push([e, a]), g(u, ([l]) => e == l).map((l) => u.splice(l, 1)), y(i);
-        }, s)
-      ]), i++;
-    }
-    function m() {
-      const e = c.sort(([f], [a]) => f - a);
-      o(e.map(([, f]) => f));
-    }
-    for (let e = 0; e < r; e++)
-      y(i);
-  });
-}
-export {
-  I as asyncMap,
-  h as pause,
-  x as retry
-};

package/dist/functional.js

@@ -1,260 +0,0 @@
-var d = Object.defineProperty;
-var S = (r, e, t) => e in r ? d(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var u = (r, e, t) => (S(r, typeof e != "symbol" ? e + "" : e, t), t);
-const a = "@terrygonguet/utils/functional/result", l = "@terrygonguet/utils/functional/result/Success", w = "@terrygonguet/utils/functional/result/Failure";
-class f {
-  constructor(e) {
-    u(this, "value");
-    Object.defineProperties(this, {
-      $_kind: { value: a, enumerable: !1, writable: !1 },
-      $_variant: { value: l, 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 f(e(this.value));
-  }
-  flatMap(e) {
-    return e(this.value);
-  }
-  toJSON() {
-    return { $_kind: a, $_variant: l, value: this.value };
-  }
-}
-class g {
-  constructor(e) {
-    u(this, "reason");
-    Object.defineProperties(this, {
-      $_kind: { value: a, enumerable: !1, writable: !1 },
-      $_variant: { value: l, 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 v(r, e) {
-  return e ? r.toResult(e) : r.toResult();
-}
-const c = {
-  Success(r) {
-    return new f(r);
-  },
-  Failure(r) {
-    return new g(r);
-  },
-  try(r) {
-    return new y(r);
-  },
-  fromPromise(r, e, t) {
-    return r.then(
-      b(e, this.Success),
-      b(t, this.Failure)
-    );
-  },
-  fromMaybe: v,
-  JSONReviver(r, e) {
-    if ((e == null ? void 0 : e.$_kind) == a) {
-      const t = e == null ? void 0 : e.$_variant;
-      return t == l ? new f(e == null ? void 0 : e.value) : t == w ? new g(e == null ? void 0 : e.reason) : e;
-    } else
-      return e;
-  }
-};
-class y {
-  constructor(e) {
-    u(this, "tryFn");
-    u(this, "catchFn");
-    this.tryFn = e, this.catchFn = p;
-  }
-  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", $ = "@terrygonguet/utils/functional/maybe/None";
-class o {
-  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 o(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: $ };
-  }
-}
-const N = new k(), s = {
-  Some(r) {
-    return new o(r);
-  },
-  None() {
-    return N;
-  },
-  from(r) {
-    switch (r) {
-      case null:
-      case void 0:
-        return this.None();
-      default:
-        return new o(r);
-    }
-  },
-  /**
-   * CAUTION: this method swallows errors and simply returns None!
-   * Use `Result.fromPromise()` if you need error details.
-   */
-  fromPromise(r, e = p) {
-    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 o(e == null ? void 0 : e.value) : t == $ ? 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), i = t.length, m = 1; m < i; 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, i = 1; i < n; i++)
-    t = e[i](t);
-  return t;
-}
-function p(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);
-  }
-}
-export {
-  s as Maybe,
-  c as Result,
-  j as at,
-  b as compose,
-  M as constant,
-  E as find,
-  O as findIndex,
-  p as identity,
-  J as pipe
-};

package/dist/index.js

@@ -1,55 +0,0 @@
-import { constant as r } from "./functional.js";
-function s(n, t, e) {
-  return Math.min(Math.max(n, t), e);
-}
-function a(n, t, e) {
-  try {
-    return JSON.parse(n, e);
-  } catch {
-    return t;
-  }
-}
-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 {
-  s as clamp,
-  i as composeJSONRevivers,
-  u as createNoopProxy,
-  p as exhaustive,
-  h as hash,
-  f as noop,
-  d as range,
-  a as safeParse
-};