@terrygonguet/utils 0.0.13 → 0.1.0

package/src/functional/result.ts

@@ -1,151 +0,0 @@
-import { compose, identity } from "./index.ts"
-import { Maybe } from "./maybe.ts"
-
-const $_kind = "@terrygonguet/utils/functional/result"
-const $_variant_Success = "@terrygonguet/utils/functional/result/Success"
-const $_variant_Failure = "@terrygonguet/utils/functional/result/Failure"
-
-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
-}
-
-class Success<S, F> implements Result<S, F> {
-	value!: S
-
-	constructor(value: S) {
-		Object.defineProperties(this, {
-			$_kind: { value: $_kind, enumerable: false, writable: false },
-			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
-			value: { value, writable: false },
-		})
-	}
-
-	isSuccess(): true {
-		return true
-	}
-	isFailure(): false {
-		return false
-	}
-	merge<T>(whenSuccess: (value: S) => T) {
-		return whenSuccess(this.value)
-	}
-	match(onSuccess: (value: S) => void) {
-		return onSuccess(this.value)
-	}
-	map<S2>(f: (value: S) => S2) {
-		return new Success<S2, F>(f(this.value))
-	}
-	flatMap<S2, F2>(f: (value: S) => Result<S2, F2>): Result<S2, F | F2> {
-		return f(this.value)
-	}
-	toJSON(this: Success<S, F>) {
-		return { $_kind, $_variant: $_variant_Success, value: this.value }
-	}
-}
-
-class Failure<S, F> implements Result<S, F> {
-	reason!: F
-
-	constructor(reason: F) {
-		Object.defineProperties(this, {
-			$_kind: { value: $_kind, enumerable: false, writable: false },
-			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
-			reason: { value: reason, writable: false },
-		})
-	}
-
-	isSuccess(): false {
-		return false
-	}
-	isFailure(): true {
-		return true
-	}
-	merge<T>(_: (value: S) => T, whenFailure: (reason: F) => T) {
-		return whenFailure(this.reason)
-	}
-	match(_: (value: S) => void, onFailure: (reason: F) => void) {
-		return onFailure(this.reason)
-	}
-	map<S2>() {
-		return this as unknown as Result<S2, F>
-	}
-	flatMap<S2, F2>() {
-		return this as unknown as Result<S2, F | F2>
-	}
-	toJSON() {
-		return { $_kind, $_variant: $_variant_Failure, reason: this.reason }
-	}
-}
-
-function resultFromMaybe<S>(maybe: Maybe<S>): Result<S, undefined>
-function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone: () => F): Result<S, F>
-function resultFromMaybe<S, F>(maybe: Maybe<S>, mapNone?: () => F) {
-	return mapNone ? maybe.toResult(mapNone) : maybe.toResult()
-}
-
-export const Result = {
-	Success<S, F>(value: S): Result<S, F> {
-		return new Success<S, F>(value)
-	},
-	Failure<S, F>(reason: F): Result<S, F> {
-		return new Failure<S, F>(reason)
-	},
-	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, this.Success<S, F>),
-			compose(onReject, this.Failure<S, F>),
-		)
-	},
-	fromMaybe: resultFromMaybe,
-	JSONReviver(_key: string, value: any) {
-		if (value?.$_kind == $_kind) {
-			const $_variant = value?.$_variant
-			if ($_variant == $_variant_Success) return new Success<unknown, unknown>(value?.value)
-			else if ($_variant == $_variant_Failure)
-				return new Failure<unknown, unknown>(value?.reason)
-			else return value
-		} else return value
-	},
-}
-
-class TryCatch<S, F> {
-	tryFn: () => S
-	catchFn: (err: unknown) => F
-
-	constructor(tryFn: () => S) {
-		this.tryFn = tryFn
-		this.catchFn = identity as any
-	}
-
-	catch(catchFn: (err: unknown) => F) {
-		this.catchFn = catchFn
-		return this
-	}
-
-	exec(finallyFn?: (result: Result<S, F>) => void): Result<S, F> {
-		try {
-			const result = Result.Success<S, F>(this.tryFn())
-			finallyFn?.(result)
-			return result
-		} catch (error) {
-			const result = Result.Failure<S, F>(this.catchFn(error))
-			finallyFn?.(result)
-			return result
-		}
-	}
-}
-
-export type { Success, Failure }

package/src/index.ts

@@ -1,63 +0,0 @@
-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 +0,0 @@
-/// <reference types="vite/client" />

package/types/async.d.ts

@@ -1,14 +0,0 @@
-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,19 +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 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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-/**
- * 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 {};