@terrygonguet/utils 0.0.14 → 0.1.1

package/dist/async.d.ts

@@ -0,0 +1,15 @@
+declare function pause(ms: number): Promise<void>;
+interface RetryOptions {
+    count?: number;
+    delay?: number | ((retryCount: number, error: any) => number);
+}
+declare function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>;
+declare function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>;
+interface AsyncMapOptions {
+    concurrent?: number;
+}
+declare function asyncMap<T, U>(f: AsyncMapFn<T, U>, options?: AsyncMapOptions): (data: T[]) => Promise<U[]>;
+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 { asyncMap, pause, retry };

package/dist/async.js

@@ -0,0 +1,77 @@
+// src/async.ts
+function pause(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retry(providerOrOptions, options) {
+  if (typeof providerOrOptions == "function")
+    return _retry(providerOrOptions, options);
+  else
+    return (provider) => _retry(provider, providerOrOptions);
+}
+async function _retry(provider, { count = Infinity, delay } = {}) {
+  let retryCount = 0;
+  let lastError;
+  do {
+    try {
+      return await provider();
+    } catch (error) {
+      lastError = error;
+      retryCount++;
+      switch (typeof delay) {
+        case "number":
+          await pause(delay);
+          break;
+        case "function":
+          await pause(delay(retryCount, error));
+          break;
+      }
+    }
+  } while (retryCount <= count);
+  throw lastError;
+}
+function asyncMap(dataOrF, ForOptions, options) {
+  if (typeof dataOrF == "function" && typeof ForOptions != "function") {
+    const f = dataOrF;
+    const options2 = ForOptions;
+    return (data) => asyncMap_(data, f, options2);
+  } else if (Array.isArray(dataOrF) && typeof ForOptions == "function") {
+    const data = dataOrF;
+    const f = ForOptions;
+    return asyncMap_(data, f, options);
+  } else throw new Error("Invalid arguments passed to asyncMap");
+}
+async function asyncMap_(data, f, { concurrent = 5 } = {}) {
+  return new Promise((resolve, reject) => {
+    const resolved = [];
+    const inFlight = [];
+    let next = 0;
+    function queue(i) {
+      if (resolved.length == data.length && inFlight.length == 0)
+        return finish();
+      if (i >= data.length) return;
+      const el = data[i];
+      inFlight.push([
+        i,
+        f(el, i, data).then((result) => {
+          resolved.push([i, result]);
+          const j = inFlight.findIndex(([j2]) => i == j2);
+          inFlight.splice(j, 1);
+          queue(next);
+        }, reject)
+      ]);
+      next++;
+    }
+    function finish() {
+      const sorted = resolved.sort(([a], [b]) => a - b);
+      resolve(sorted.map(([, value]) => value));
+    }
+    for (let i = 0; i < concurrent; i++) {
+      queue(next);
+    }
+  });
+}
+export {
+  asyncMap,
+  pause,
+  retry
+};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Behaviour is undefined when max < min
+ */
+declare function clamp(value: number, min: number, max: number): number;
+type JSONReviver = (key: string, value: any) => any;
+/**
+ * This function does no runtime type checking,
+ * make sure that the parsed value is valid
+ */
+declare function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver): T;
+declare function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver;
+declare function createNoopProxy<T>(): T;
+declare function noop(): void;
+declare function exhaustive(_: never): never;
+declare function hash(message: string): Promise<ArrayBuffer>;
+declare function range(start: number, end: number, step?: number): Generator<number, void, unknown>;
+
+export { clamp, composeJSONRevivers, createNoopProxy, exhaustive, hash, noop, range, safeParse };

package/dist/index.js

@@ -0,0 +1,62 @@
+// src/index.ts
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function safeParse(str, defaultValue, reviver) {
+  try {
+    return JSON.parse(str, reviver);
+  } catch (_) {
+    return defaultValue;
+  }
+}
+function composeJSONRevivers(...revivers) {
+  return function(key, value) {
+    for (const reviver of revivers) {
+      value = reviver(key, value);
+    }
+    return value;
+  };
+}
+function createNoopProxy() {
+  const noop2 = () => proxy;
+  const no = () => false;
+  const yes = () => true;
+  const proxy = new Proxy(() => {
+  }, {
+    get: noop2,
+    set: noop2,
+    apply: noop2,
+    construct: noop2,
+    deleteProperty: yes,
+    has: yes,
+    preventExtensions: no,
+    defineProperty: no
+  });
+  return proxy;
+}
+function noop() {
+}
+function exhaustive(_) {
+  throw new Error("This should never be called");
+}
+async function hash(message) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(message);
+  const hash2 = await crypto.subtle.digest("SHA-1", data);
+  return hash2;
+}
+function* range(start, end, step = 1) {
+  for (let i = start; i < end; i += step) {
+    yield i;
+  }
+}
+export {
+  clamp,
+  composeJSONRevivers,
+  createNoopProxy,
+  exhaustive,
+  hash,
+  noop,
+  range,
+  safeParse
+};

package/package.json

@@ -1,49 +1,40 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.0.14",
+	"version": "0.1.1",
 	"type": "module",
-	"module": "./dist/index.js",
-	"author": {
-		"email": "terry@gonguet.com",
-		"name": "Terry Gonguet",
-		"url": "https://terry.gonguet.com/"
-	},
+	"license": "MIT",
 	"scripts": {
 		"dev": "vite",
-		"build": "tsc && vite build",
-		"test": "vitest test --ui --watch --update",
+		"build": "tsup",
+		"test": "vitest test --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"
+		"dist"
 	],
 	"exports": {
 		".": {
-			"types": "./types/index.d.ts",
+			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
 		},
 		"./async": {
-			"types": "./types/async.d.ts",
+			"types": "./dist/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"
+	"devDependencies": {
+		"@vitest/coverage-v8": "^0.32.0",
+		"@vitest/ui": "^0.32.0",
+		"prettier": "^2.8.8",
+		"tsup": "^8.1.0",
+		"typescript": "^5.0.2",
+		"vite": "^4.3.9",
+		"vitest": "^0.32.0"
+	},
+	"author": {
+		"email": "terry@gonguet.com",
+		"name": "Terry Gonguet",
+		"url": "https://terry.gonguet.com/"
 	},
 	"repository": {
 		"type": "git",

package/src/async.ts

@@ -1,112 +0,0 @@
-import { findIndex } from "./functional/index.ts"
-
-export function pause(ms: number): Promise<void> {
-	return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-interface RetryOptions {
-	count?: number
-	delay?: number | ((retryCount: number, error: any) => number)
-}
-
-export function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>
-export function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>
-export function retry<T>(
-	providerOrOptions: RetryOptions | (() => Promise<T>),
-	options?: RetryOptions,
-) {
-	if (typeof providerOrOptions == "function") return _retry(providerOrOptions, options)
-	else return (provider: () => Promise<T>) => _retry(provider, providerOrOptions)
-}
-
-async function _retry<T>(
-	provider: () => Promise<T>,
-	{ count = Infinity, delay }: RetryOptions = {},
-): Promise<T> {
-	let retryCount = 0
-	let lastError: any
-	do {
-		try {
-			return await provider()
-		} catch (error) {
-			lastError = error
-			retryCount++
-			switch (typeof delay) {
-				case "number":
-					await pause(delay)
-					break
-				case "function":
-					await pause(delay(retryCount, error))
-					break
-			}
-		}
-	} while (retryCount <= count)
-	throw lastError
-}
-
-interface AsyncMapOptions {
-	concurrent?: number
-}
-
-export function asyncMap<T, U>(
-	f: AsyncMapFn<T, U>,
-	options?: AsyncMapOptions,
-): (data: T[]) => Promise<U[]>
-export function asyncMap<T, U>(
-	data: T[],
-	f: AsyncMapFn<T, U>,
-	options?: AsyncMapOptions,
-): Promise<U[]>
-export function asyncMap<T, U>(
-	dataOrF: T[] | AsyncMapFn<T, U>,
-	ForOptions: AsyncMapFn<T, U> | AsyncMapOptions | undefined,
-	options?: AsyncMapOptions,
-): Promise<U[]> | ((data: T[]) => Promise<U[]>) {
-	if (typeof dataOrF == "function" && typeof ForOptions != "function") {
-		const f = dataOrF
-		const options = ForOptions
-		return (data: T[]) => asyncMap_(data, f, options)
-	} else if (Array.isArray(dataOrF) && typeof ForOptions == "function") {
-		const data = dataOrF
-		const f = ForOptions
-		return asyncMap_(data, f, options)
-	} else throw new Error("Invalid arguments passed to asyncMap")
-}
-
-type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>
-
-async function asyncMap_<T, U>(
-	data: T[],
-	f: AsyncMapFn<T, U>,
-	{ concurrent = 5 }: AsyncMapOptions = {},
-): Promise<U[]> {
-	return new Promise((resolve, reject) => {
-		const resolved: [i: number, result: U][] = []
-		const inFlight: [i: number, promise: Promise<void>][] = []
-
-		let next = 0
-		function queue(i: number) {
-			if (resolved.length == data.length && inFlight.length == 0) return finish()
-			if (i >= data.length) return
-			const el = data[i]
-			inFlight.push([
-				i,
-				f(el, i, data).then(result => {
-					resolved.push([i, result])
-					findIndex(inFlight, ([j]) => i == j).map(j => inFlight.splice(j, 1))
-					queue(next)
-				}, reject),
-			])
-			next++
-		}
-
-		function finish() {
-			const sorted = resolved.sort(([a], [b]) => a - b)
-			resolve(sorted.map(([, value]) => value))
-		}
-
-		for (let i = 0; i < concurrent; i++) {
-			queue(next)
-		}
-	})
-}

package/src/functional/index.ts

@@ -1,80 +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 function identity<T>(value: T) {
-	return value
-}
-
-export function constant<T>(value: T) {
-	return () => value
-}
-
-export function at(idx: number): <T>(data: T[]) => Maybe<T>
-export function at<T>(data: T[], idx: number): Maybe<T>
-export function at<T>(dataOrIdx: T[] | number, idx?: number) {
-	if (typeof dataOrIdx == "number") return (data: T[]) => Maybe.from(data.at(dataOrIdx))
-	else return Maybe.from(dataOrIdx.at(idx!))
-}
-
-type Predicate<T> = (value: T, idx: number, arr: T[]) => boolean
-
-export function find<T>(predicate: Predicate<T>): (data: T[]) => Maybe<T>
-export function find<T>(data: T[], predicate: Predicate<T>): Maybe<T>
-export function find<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Predicate<T>) {
-	if (typeof dataOrPredicate == "function")
-		return (data: T[]) => Maybe.from(data.find(dataOrPredicate))
-	else return Maybe.from(dataOrPredicate.find(predicate!))
-}
-
-export function findIndex<T>(predicate: Predicate<T>): (data: T[]) => Maybe<number>
-export function findIndex<T>(data: T[], predicate: Predicate<T>): Maybe<number>
-export function findIndex<T>(dataOrPredicate: T[] | Predicate<T>, predicate?: Predicate<T>) {
-	if (typeof dataOrPredicate == "function") {
-		return (data: T[]) => {
-			const idx = data.findIndex(dataOrPredicate)
-			return idx == -1 ? Maybe.None<number>() : Maybe.Some(idx)
-		}
-	} else {
-		const idx = dataOrPredicate.findIndex(predicate!)
-		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/functional/maybe.ts

@@ -1,115 +0,0 @@
-import { compose, constant, identity } from "./index.ts"
-import { Result } from "./result.ts"
-
-const $_kind = "@terrygonguet/utils/functional/maybe"
-const $_variant_Some = "@terrygonguet/utils/functional/maybe/Some"
-const $_variant_None = "@terrygonguet/utils/functional/maybe/None"
-
-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
-}
-
-class Some<T> implements Maybe<T> {
-	value!: T
-
-	constructor(value: T) {
-		Object.defineProperties(this, {
-			$_kind: { value: $_kind, enumerable: false, writable: false },
-			$_variant: { value: $_variant_Some, enumerable: false, writable: false },
-			value: { value, writable: false },
-		})
-	}
-
-	isSome(): true {
-		return true
-	}
-	isNone(): false {
-		return false
-	}
-	orDefault() {
-		return this.value
-	}
-	map<U>(f: (value: T) => U) {
-		return new Some(f(this.value))
-	}
-	flatMap<U>(f: (value: T) => Maybe<U>) {
-		return f(this.value)
-	}
-	toResult<U>(): Result<T, U> {
-		return Result.Success(this.value)
-	}
-	toJSON(): Object {
-		return { $_kind, $_variant: $_variant_Some, value: this.value }
-	}
-}
-
-class None<T> implements Maybe<T> {
-	constructor() {}
-
-	isSome(): false {
-		return false
-	}
-	isNone(): true {
-		return true
-	}
-	orDefault(defaultValue: T) {
-		return defaultValue
-	}
-	map<U>() {
-		return this as unknown as Maybe<U>
-	}
-	flatMap<U>() {
-		return this as unknown as Maybe<U>
-	}
-	toResult(): Result<T, undefined>
-	toResult<U>(mapNone: () => U): Result<T, U>
-	toResult<U>(mapNone?: () => U) {
-		return mapNone ? Result.Failure<T, U>(mapNone?.()) : Result.Failure<T, undefined>(undefined)
-	}
-	toJSON(): Object {
-		return { $_kind, $_variant: $_variant_None }
-	}
-}
-
-const none = new None()
-export const Maybe = {
-	Some<T>(value: T): Maybe<T> {
-		return new Some(value)
-	},
-	None<T>() {
-		return none as Maybe<T>
-	},
-	from<T>(value: T | undefined | null): Maybe<T> {
-		switch (value) {
-			case null:
-			case undefined:
-				return this.None()
-			default:
-				return new 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(this.None()))
-	},
-	JSONReviver(_key: string, value: any) {
-		if (value?.$_kind == $_kind) {
-			const $_variant = value?.$_variant
-			if ($_variant == $_variant_Some) return new Some<unknown>(value?.value)
-			else if ($_variant == $_variant_None) return Maybe.None()
-			else return value
-		} else return value
-	},
-}
-
-export type { Some, None }

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 {};