add: isNotError, whenNotError, whenNotErrorAll, and related types

Author: aggre

src/types/types.ts

@@ -1,3 +1,5 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 
 export type UndefinedOr<R> = undefined | R
+export type ErrorOr<T> = Error | T
+export type NotError<T> = Exclude<T, Error>

src/utils/isNotError.test.ts

@@ -0,0 +1,10 @@
+import test from 'ava'
+import { isNotError } from './isNotError'
+
+test('Returns false when the passed value is Error', (t) => {
+	t.false(isNotError(new Error()))
+})
+
+test('Returns true when the passed value is not Error', (t) => {
+	t.true(isNotError(undefined))
+})

src/utils/isNotError.ts

@@ -0,0 +1,4 @@
+import { NotError } from '../types/types'
+
+export const isNotError = <T>(t: T): t is NotError<T> =>
+	t instanceof Error ? false : true

src/utils/whenNotError.test.ts

@@ -0,0 +1,17 @@
+import test from 'ava'
+import { whenNotError } from './whenNotError'
+
+test(`Executes the passed function when the passed value is not Error.`, (t) => {
+	const result = whenNotError(null, (v) => {
+		t.is(v, null)
+		return 'done'
+	})
+	t.is(result, 'done')
+})
+
+test(`Returns Error when the passed value is Error.`, (t) => {
+	const err = new Error('ERROR')
+	const result = whenNotError(err, () => true)
+	t.is(result, err)
+	t.is((result as Error).message, 'ERROR')
+})

src/utils/whenNotError.ts

@@ -0,0 +1,14 @@
+import { cond, always, T } from 'ramda'
+import { ErrorOr, NotError } from '../types/types'
+import { isNotError } from './isNotError'
+
+export const whenNotError = <D, F>(
+	depends: D,
+	fn: (d: NotError<D>) => F
+): ErrorOr<F> =>
+	cond([
+		[isNotError, fn],
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		[T, always(depends as any)],
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	])(depends as any)

src/utils/whenNotErrorAll.test.ts

@@ -0,0 +1,37 @@
+import test from 'ava'
+import { whenNotErrorAll } from './whenNotErrorAll'
+
+test(`Executes the passed function when the passed array's values are not Error all.`, (t) => {
+	const result = whenNotErrorAll(
+		['', 0, [], false, 'false', '0'],
+		([empty, zero, arr, f, strF, str0]) => {
+			t.is(empty, '')
+			t.is(zero, 0)
+			t.deepEqual(arr, [])
+			t.is(f, false)
+			t.is(strF, 'false')
+			t.is(str0, '0')
+			return 'done'
+		}
+	)
+	t.is(result, 'done')
+})
+
+test(`Returns Error when the passed array's includes Error.`, (t) => {
+	const err = new Error('ERROR')
+	const result = whenNotErrorAll(['', 0, [], false, err], () => true)
+	t.is(result, err)
+	t.is((result as Error).message, 'ERROR')
+})
+
+test(`Returns the first Error if the passed array includes multiple errors.`, (t) => {
+	const err1 = new Error('ERROR1')
+	const err2 = new Error('ERROR2')
+	const err3 = new Error('ERROR3')
+	const result = whenNotErrorAll(
+		['', err1, [], err2, undefined, err3],
+		() => true
+	)
+	t.is(result, err1)
+	t.is((result as Error).message, 'ERROR1')
+})

src/utils/whenNotErrorAll.ts

@@ -0,0 +1,69 @@
+import { T, always, cond } from 'ramda'
+import { whenDefined } from './whenDefined'
+import { isNotError } from './isNotError'
+import { ErrorOr, NotError } from '../types/types'
+
+const passAll = <D>(depends: D): boolean =>
+	depends instanceof Array ? depends.every(isNotError) : isNotError(depends)
+
+export function whenNotErrorAll<D1, F>(
+	depends: readonly [D1],
+	fn: (d: readonly [NotError<D1>]) => F
+): ErrorOr<F>
+export function whenNotErrorAll<D1, D2, F>(
+	depends: readonly [D1, D2],
+	fn: (d: readonly [NotError<D1>, NotError<D2>]) => F
+): ErrorOr<F>
+export function whenNotErrorAll<D1, D2, D3, F>(
+	depends: readonly [D1, D2, D3],
+	fn: (d: readonly [NotError<D1>, NotError<D2>, NotError<D3>]) => F
+): ErrorOr<F>
+export function whenNotErrorAll<D1, D2, D3, D4, F>(
+	depends: readonly [D1, D2, D3, D4],
+	fn: (
+		d: readonly [NotError<D1>, NotError<D2>, NotError<D3>, NotError<D4>]
+	) => F
+): ErrorOr<F>
+export function whenNotErrorAll<D1, D2, D3, D4, D5, F>(
+	depends: readonly [D1, D2, D3, D4, D5],
+	fn: (
+		d: readonly [
+			NotError<D1>,
+			NotError<D2>,
+			NotError<D3>,
+			NotError<D4>,
+			NotError<D5>
+		]
+	) => F
+): ErrorOr<F>
+export function whenNotErrorAll<D1, D2, D3, D4, D5, D6, F>(
+	depends: readonly [D1, D2, D3, D4, D5, D6],
+	fn: (
+		d: readonly [
+			NotError<D1>,
+			NotError<D2>,
+			NotError<D3>,
+			NotError<D4>,
+			NotError<D5>,
+			NotError<D6>
+		]
+	) => F
+): ErrorOr<F>
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function whenNotErrorAll(depends: unknown, fn: any): unknown {
+	return whenDefined(
+		depends,
+		cond([
+			[passAll, (deps) => fn(deps)],
+			[
+				T,
+				always(
+					depends instanceof Array
+						? depends.find((d) => !isNotError(d))
+						: depends
+				),
+			],
+		])
+	)
+}