ctx-core 2.2.0 → 2.2.1

package/all/every_arg/index.test.ts

@@ -0,0 +1,37 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { every_arg_ } from '../every_arg/index.js'
+test('every_arg_|default every fn & or', ()=>{
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar')(null, null, null), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar')(null, null, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar')(null, true, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar')(false, true, true), 'foobar')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar')(false, null, true), null)
+	equal(null, every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar')(false, false, null))
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar')(false, false, false), 'foobar')
+})
+test('every_arg_|default or', ()=>{
+	const I = ($:any)=>$
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, false, false), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, false, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, true, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, true, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, false, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, false, false), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, false, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(false, true, true), null)
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I)(true, true, true), 'foobar')
+})
+test('every_arg_|no defaults', ()=>{
+	const I = ($:any)=>$
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, false, false), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, false, true), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, true, true), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, true, true), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, false, true), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, false, false), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, false, true), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(false, true, true), '')
+	equal(every_arg_((_$0:any, _$1:any, _$2:any)=>'foobar', I, ()=>'')(true, true, true), 'foobar')
+})
+test.run()

package/all/exclude/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Exclude keys from obj
+ */
+export declare function exclude<
+	I extends unknown = unknown,
+	O = I
+>(obj:I, ...key_a:string[]):O|undefined

package/all/exclude/index.js

@@ -0,0 +1,17 @@
+/**
+ * Exclude keys from obj
+ * @param {unknown}obj
+ * @param {string}key_
+ * @returns {unknown}
+ */
+export function exclude(obj, ...key_) {
+	if (!obj) return
+	const out = {}
+	const exclude1 = new Set(key_)
+	for (let key in obj) {
+		if (!exclude1.has(key)) {
+			out[key] = obj[key]
+		}
+	}
+	return out
+}

package/all/extract/index.d.ts

@@ -0,0 +1,14 @@
+export declare function extract<
+	Type,
+	TActual extends Type = Type
+>(
+	value:TActual,
+	properties:Record<keyof Type, true>
+):Type
+/**
+ * @see {@link https://stackoverflow.com/a/50895613/142571}
+ */
+export declare function extract_<Type>(
+	properties:Record<keyof Type, true>
+):<TActual extends Type>(val:TActual)=>Type;
+export { extract_ as _extract, }

package/all/extract/index.js

@@ -0,0 +1,24 @@
+/**
+ * @param {unknown}value
+ * @param {Record<string, true>}properties
+ * @returns {unknown}
+ */
+export function extract(value, properties) {
+	let result = {}
+	for (const property of Object.keys(properties)) {
+		result[property] = value[property]
+	}
+	return result
+}
+/**
+ * @param {Record<string, true>}properties
+ * @returns {(val:unknown)=>unknown}
+ * @see {@link https://stackoverflow.com/a/50895613/142571}
+ * @private
+ */
+export function extract_(properties) {
+	return function curry_extract(value) {
+		return extract(value, properties)
+	}
+}
+export { extract_ as _extract, }

package/all/extract/index.test.ts

@@ -0,0 +1,18 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { extract } from '../extract/index.js'
+test('extract', ()=>{
+	const obj = {
+		id: 1,
+		name: 'My name',
+		date: new Date()
+	}
+	equal({
+		id: 1,
+		name: 'My name'
+	}, extract(obj, {
+		id: true,
+		name: true
+	}))
+})
+test.run()

package/all/falsy/index.d.ts

@@ -0,0 +1,7 @@
+import type { nullish } from '../nullish/index.js'
+export declare type falsy =
+	false
+	|0
+	|typeof NaN
+	|''
+	|nullish

package/all/falsy/index.js

@@ -0,0 +1 @@
+export {}

package/all/falsy__none/index.d.ts

@@ -0,0 +1,9 @@
+import type { falsy } from '../falsy/index.js'
+export function falsy__none_<
+	T extends any[], U
+>(
+	$:T,
+	_:(...$:T)=>U,
+	onfalsy?:(falsy:falsy)=>any
+):U
+export { falsy__none_ as falsy__check_ }

package/all/falsy__none/index.js

@@ -0,0 +1,23 @@
+/** @typedef {import('../falsy/index.d.ts').falsy} */
+/**
+ * @param {unknown[]}a
+ * @param {(...$:unknown[])=>unknown}_
+ * @param {(falsy:falsy)=>any}[onfalsy]
+ * @returns {unknown}
+ */
+export function falsy__none_(a, _, onfalsy) {
+	for (const v of a) {
+		if (v === undefined) {
+			if (onfalsy) onfalsy(undefined)
+			return undefined
+		}
+	}
+	for (const v of a) {
+		if (v === null) {
+			if (onfalsy) onfalsy(null)
+			return null
+		}
+	}
+	return _(...a)
+}
+export { falsy__none_ as falsy__check_ }

package/all/falsy__none/index.test.ts

@@ -0,0 +1,58 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { falsy__none_ } from '../falsy__none/index.js'
+test('falsy__none_|-onfalsy', ()=>{
+	const arg_aa:any[][] = []
+	const _ = (...arg_a:any[])=>{
+		arg_aa.push(arg_a)
+		return arg_a
+	}
+	const undefined_val = undefined
+	const null_val = null
+	const zero = 0
+	const str = ''
+	const o = {}
+	equal(falsy__none_([undefined_val], _), undefined)
+	equal(arg_aa, [])
+	equal(falsy__none_([null_val], _), null)
+	equal(arg_aa, [])
+	equal(falsy__none_([zero], _), [zero])
+	equal(arg_aa, [[zero]])
+	equal(falsy__none_([str], _), [str])
+	equal(arg_aa, [[zero], [str]])
+	equal(falsy__none_([o], _), [o])
+	equal(arg_aa, [[zero], [str], [o]])
+})
+test('falsy__none_|+onfalsy', ()=>{
+	const arg_aa:any[][] = []
+	const _ = (...arg_a:any[])=>{
+		arg_aa.push(arg_a)
+		return arg_a
+	}
+	const onfalsy__arg_aa:any[][] = []
+	const onfalsy = (...arg_a:any[])=>{
+		onfalsy__arg_aa.push(arg_a)
+		return 'foobar'
+	}
+	const undefined_val = undefined
+	const null_val = null
+	const zero = 0
+	const str = ''
+	const o = {}
+	equal(falsy__none_([undefined_val], _, onfalsy), undefined)
+	equal(arg_aa, [])
+	equal(onfalsy__arg_aa, [[undefined]])
+	equal(falsy__none_([null_val], _, onfalsy), null)
+	equal(arg_aa, [])
+	equal(onfalsy__arg_aa, [[undefined], [null]])
+	equal(falsy__none_([zero], _, onfalsy), [zero])
+	equal(arg_aa, [[zero]])
+	equal(onfalsy__arg_aa, [[undefined], [null]])
+	equal(falsy__none_([str], _, onfalsy), [str])
+	equal(arg_aa, [[zero], [str]])
+	equal(onfalsy__arg_aa, [[undefined], [null]])
+	equal(falsy__none_([o], _, onfalsy), [o])
+	equal(arg_aa, [[zero], [str], [o]])
+	equal(onfalsy__arg_aa, [[undefined], [null]])
+})
+test.run()

package/all/falsy_async_guard/index.d.ts

@@ -0,0 +1,7 @@
+import type { falsy } from '../falsy/index.js'
+export declare function falsy_async_guard<
+	Val extends unknown = unknown
+>(
+	label:string, ...fns:(()=>Promise<Val|falsy>)[]
+):Promise<Val|falsy>
+export { falsy_async_guard as falsish_async_guard }

package/all/falsy_async_guard/index.js

@@ -0,0 +1,13 @@
+/**
+ * @param {string}label
+ * @param {(()=>Promise<unknown>)}fns
+ * @returns {Promise<unknown>}
+ */
+export async function falsy_async_guard(label, ...fns) {
+	for (const fn of fns) {
+		const rv = await fn()
+		if (rv) return rv
+	}
+	throw `${label} cannot be falsy`
+}
+export { falsy_async_guard as falsish_async_guard }

package/all/falsy_guard/index.d.ts

@@ -0,0 +1,5 @@
+import type { falsy } from '../falsy/index.js'
+export declare function falsy_guard<
+	Val extends unknown = unknown
+>(label:string, ...fns:(()=>(Val|falsy))[]):Val|falsy
+export { falsy_guard as falsish_guard }

package/all/falsy_guard/index.js

@@ -0,0 +1,13 @@
+/**
+ * @param {string}label
+ * @param {()=>unknown}fns
+ * @returns {unknown}
+ */
+export function falsy_guard(label, ...fns) {
+	for (const fn of fns) {
+		const rv = fn()
+		if (rv) return rv
+	}
+	throw `${label} cannot be falsy`
+}
+export { falsy_guard as falsish_guard }

package/all/fetch/index.d.ts

@@ -0,0 +1,5 @@
+export declare const fetch:fetch_T
+export type fetch_T = (
+	input: RequestInfo,
+	init?: RequestInit,
+)=>Promise<Response>

package/all/fetch/index.js

@@ -0,0 +1,2 @@
+/** @type {import('../fetch/index.d.ts').fetch} */
+export const { fetch } = globalThis

package/all/fetch__template_pair/index.d.ts

@@ -0,0 +1,40 @@
+import type { response_pair_T } from '../response_pair/index.js'
+export declare function fetch__template_pair__new<
+	F extends ((...arg_a:any[])=>Promise<Response>)|any[],
+	U = unknown,
+	H = U,
+>(
+	fetch_fn:
+		F extends (...arg_a:any[])=>Promise<Response>
+			? F
+			: F extends any[]
+				? (...arg_a:F)=>Promise<Response>
+				: never,
+	hydrate?:(dehydrated_val:U)=>H
+):fetch__template_pair_T<F, H>
+export type fetch__template_pair_T<
+	F extends ((...arg_a:any[])=>Promise<Response>)|any[],
+	T = unknown,
+> = [
+	fetch__template_pair_0_T<F>,
+	fetch__template_pair_1_T<F, T>
+]
+export type fetch__template_pair_0_T<
+	F extends ((...arg_a:any[])=>Promise<Response>)|any[]
+> =
+	F extends (...arg_a:any[])=>Promise<Response>
+		? F
+		: F extends any[]
+			? (...arg_a:F)=>Promise<Response>
+			: never
+export type fetch__template_pair_1_T<
+	F extends ((...arg_a:any[])=>Promise<Response>)|any[],
+	T = unknown,
+> = (
+	...arg_a:
+		F extends (...arg_a:any[])=>Promise<Response>
+			? Parameters<F>
+			: F extends any[]
+				? F
+				: never
+)=>Promise<response_pair_T<T>>

package/all/fetch__template_pair/index.js

@@ -0,0 +1,20 @@
+import { response_pair__new } from '../response_pair/index.js'
+/** @typedef {import('../fetch__template_pair/index.d.ts').fetch__template_pair_T}fetch__template_pair_T */
+/**
+ * @param {(...arg_a:any[])=>Promise<Response>}fetch_fn
+ * @param {(val:unknown)=>unknown}[hydrate]
+ * @returns {fetch__template_pair_T}
+ * @private
+ */
+export function fetch__template_pair__new(
+	fetch_fn,
+	hydrate = val=>val
+) {
+	return [
+		fetch_fn,
+		(...arg_a)=>
+			fetch_fn(...arg_a)
+				.then(response=>
+					response_pair__new(response, hydrate))
+	]
+}

package/all/fetch__template_pair/index.test.ts

@@ -0,0 +1,46 @@
+import { restore, stub } from 'sinon'
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { fetch__template_pair__new } from '../fetch__template_pair/index.js'
+test.after.each(()=>{
+	restore()
+})
+test('fetch__template_pair__new', async ()=>{
+	const _stub = stub(globalThis, 'fetch')
+	.withArgs('https://test.site/api?id=123')
+	const [
+		test__fetch,
+		test__fetch2,
+	] = fetch__template_pair__new<
+		[id:number],
+		{ foo:string },
+		{ foo:string[] }
+	>(id=>
+			fetch(`https://test.site/api?id=${id}`),
+		dehydrated=>({
+			foo: [dehydrated.foo]
+		}))
+	_stub.resolves(new Response(JSON.stringify({
+		foo: 'bar'
+	}), {
+		headers: {
+			'Content-Type': 'application/json'
+		}
+	}))
+	equal(
+		await test__fetch(123).then(res=>res.json()),
+		{ foo: 'bar' }
+	)
+	_stub.resolves(new Response(JSON.stringify({
+		foo: 'bar'
+	}), {
+		headers: {
+			'Content-Type': 'application/json'
+		}
+	}))
+	const response_pair = await test__fetch2(123)
+	equal(
+		response_pair[0],
+		{ foo: ['bar'] })
+})
+test.run()

package/all/fetch_method/index.d.ts

@@ -0,0 +1,5 @@
+export declare function fetch_method__new(params:fetch_method___params_T):string
+export declare interface fetch_method___params_T {
+	method:string
+}
+export declare type fetch_method_params__T = fetch_method___params_T

package/all/fetch_method/index.js

@@ -0,0 +1,8 @@
+/**
+ * @param {import('../fetch_method/index.js').fetch_method___params_T}fetch_method___params
+ * @returns {string}
+ * @private
+ */
+export function fetch_method__new(fetch_method___params) {
+	return (fetch_method___params.method || 'GET').toUpperCase()
+}

package/all/fetch_response__throw/index.d.ts

@@ -0,0 +1,7 @@
+export declare function fetch_response__throw(
+	response:Response
+):Promise<void>
+export {
+	fetch_response__throw as throw_fetch_response,
+	fetch_response__throw as throw__response__fetch,
+}

package/all/fetch_response__throw/index.js

@@ -0,0 +1,15 @@
+import { error_o__throw } from '../error_o/index.js'
+/**
+ * @param {Response}response
+ * @returns {Promise<void>}
+ */
+export async function fetch_response__throw(response) {
+	const message = await response.text()
+	error_o__throw(message, {
+		http__status: response.status,
+	})
+}
+export {
+	fetch_response__throw as throw_fetch_response,
+	fetch_response__throw as throw__response__fetch,
+}

package/all/fetch_response__throw/index.test.ts

@@ -0,0 +1,19 @@
+import { Buffer } from 'buffer'
+import { test } from 'uvu'
+import { equal, unreachable } from 'uvu/assert'
+import { fetch_response__throw } from '../fetch_response__throw/index.js'
+import type { HttpError } from '../http_error/index.js'
+test('fetch_response__throw', async ()=>{
+	const error_msg = 'the error message'
+	const buffer = Buffer.from(error_msg)
+	const response = new Response(buffer, { status: 501 })
+	try {
+		await fetch_response__throw(response)
+		unreachable('should have thrown')
+	} catch (_err) {
+		const err = _err as HttpError
+		equal(err.http__status, 501)
+		equal(err.message, error_msg)
+	}
+})
+test.run()

package/all/fetch_response_pair/index.d.ts

@@ -0,0 +1,5 @@
+import { fetch_T } from '../fetch/index.js'
+export declare function fetch_response_pair__new2(fetch:fetch_T):typeof fetch_response_pair__new
+export declare function fetch_response_pair__new<Body>(
+	input:RequestInfo, init?:RequestInit
+):Promise<[Body, globalThis.Response]>

package/all/fetch_response_pair/index.js

@@ -0,0 +1,13 @@
+import { response_pair__new } from '../response_pair/index.js'
+/** @typedef {import('../fetch/index.d.ts').fetch_T} */
+/**
+ * @param {fetch_T}fetch
+ * @returns {typeof import('../fetch__template_pair/index.js').fetch_response_pair__new}
+ */
+export function fetch_response_pair__new2(fetch) {
+	return async (input, init)=>{
+		const response = await fetch(input, init)
+		return await response_pair__new(response)
+	}
+}
+export const fetch_response_pair__new = fetch_response_pair__new2(globalThis.fetch)

package/all/fibonacci_number/index.d.ts

@@ -0,0 +1,5 @@
+export declare function fibonacci_number_(n:number):number
+export {
+	fibonacci_number_ as _fibonacci_number,
+	fibonacci_number_ as _number__fibonacci,
+}

package/all/fibonacci_number/index.js

@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @returns {number}
+ */
+export function fibonacci_number_(n) {
+	return n < 1 ? 0 : n <= 2 ? 1 : fibonacci_number_(n - 1) + fibonacci_number_(n - 2)
+}
+export {
+	fibonacci_number_ as _fibonacci_number,
+	fibonacci_number_ as _number__fibonacci,
+}

package/all/filter/index.d.ts

@@ -0,0 +1,35 @@
+import type { is_match__T } from '../array_types/index.js'
+/**
+ * Returns Array where items in `a` are filtered by `fn`.
+ */
+export declare function filter<
+	Val extends unknown = unknown
+>(
+	a:readonly Val[],
+	is_match_fn:is_match__T<Val>
+):Val[]
+export declare function maybe_filter<
+	Val extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly Val[]|undefined,
+	is_match_fn:is_match__T<Val>,
+	or?:Or
+):Val[]|Or
+/**
+ * Returns function that returns value from [filter](#filter) with `fn` argument.
+ */
+export declare function filter_<
+	I extends unknown = unknown
+>(
+	is_match_fn:is_match__T<I>
+):(a:readonly I[])=>I[]
+export declare function maybe_filter_<
+	I extends unknown = unknown
+>(
+	is_match_fn:is_match__T<I>
+):(maybe_a:readonly I[]|undefined)=>I[]
+export {
+	filter_ as _filter,
+	filter_ as _fn__filter,
+	maybe_filter_ as _maybe_filter,
+}

package/all/filter/index.js

@@ -0,0 +1,55 @@
+/** @typedef {import('../array_types/index.d.ts').is_match__T}is_match__T */
+/**
+ * Returns Array where items in `a` are filtered by `fn`.
+ * @param {unknown[]}a
+ * @param {is_match__T}is_match_fn
+ * @returns {unknown[]}
+ */
+export function filter(a, is_match_fn) {
+	const out_a = []
+	for (let i = 0; i < a.length; i++) {
+		const value = a[i]
+		if (is_match_fn(value, i)) {
+			out_a.push(value)
+		}
+	}
+	return out_a
+}
+export {
+	filter_ as _filter,
+	filter_ as _fn__filter,
+}
+/**
+ * @param maybe_a{unknown[]|undefined}
+ * @param is_match_fn{is_match__T}
+ * @param or{unknown[]|null|undefined}
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_filter(
+	maybe_a,
+	is_match_fn,
+	or = null
+) {
+	if (!maybe_a) return or
+	return filter(maybe_a, is_match_fn)
+}
+/**
+ * Returns function that returns value from [filter](#filter) with `fn` argument.
+ */
+/**
+ * @param is_match_fn{is_match__T}
+ * @returns {(a:unknown[])=>unknown[]}
+ */
+export function filter_(is_match_fn) {
+	return (a)=>filter(a, is_match_fn)
+}
+/**
+ * @param is_match_fn{is_match__T}
+ * @returns {(maybe_a:unknown[]|undefined)=>unknown[]}
+ */
+export function maybe_filter_(is_match_fn) {
+	return (maybe_a)=>filter(maybe_a, is_match_fn)
+}
+export {
+	maybe_filter_ as _maybe_filter,
+}

package/all/filter_o/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Returns a filter_h1 with the values filtered by `fn`.
+ */
+export declare function filter_o_<
+	Obj extends object = object
+>(
+	in_r:Obj|undefined,
+	fn?:(val:Obj[keyof Obj], key:string, h1:Obj)=>Obj[keyof Obj],
+):filter_o_T|undefined
+export {
+	filter_o_ as filter_r_,
+	filter_o_ as filter_h_,
+	filter_o_ as _filter_h1,
+	filter_o_ as _h1__filter,
+}
+export interface filter_o_T extends Record<string, boolean> {
+}
+export type filter_r_T = filter_o_T
+/**
+ * Returns a function that calls filter_r_ with fn
+ */
+export declare function filter_o__<
+	Obj extends object = object
+>(
+	fn?:(val:Obj[keyof Obj], key:string, l0_r:Obj)=>any
+):((l1_r:Obj|undefined)=>filter_o_T|undefined)
+export {
+	filter_o__ as filter_r__,
+	filter_o__ as filter_h_2,
+	filter_o__ as _fn__h1__filter,
+}

package/all/filter_o/index.js

@@ -0,0 +1,39 @@
+import { I__ } from '../combinators/index.js'
+/**
+ * Returns a filter_h1 with the values filtered by `fn`.
+ * @param {object}o
+ * @param {(val:any, key:string, h1:object)=>any}fn
+ * @returns {import('../filter_o').filter_o_T|undefined}
+ */
+export function filter_o_(
+	o,
+	fn = I__
+) {
+	if (!o) return
+	const r = o
+	const filter_r = {}
+	for (let key in r) {
+		filter_r[key] = !!fn(r[key], key, r)
+	}
+	return filter_r
+}
+export {
+	filter_o_ as filter_r_,
+	filter_o_ as filter_h_,
+	filter_o_ as _filter_h1,
+	filter_o_ as _h1__filter,
+}
+/**
+ * Returns a filter_h where the value is a
+ * boolean of whether the array has items present
+ * @param {(val:any, key:string, l0_r:object)=>any}fn
+ * @returns {(l1_r:object|undefined)=>(import('../filter_o').filter_o_T|undefined)}
+ */
+export function filter_o__(fn = I__) {
+	return (l1_r)=>filter_o_(l1_r, fn)
+}
+export {
+	filter_o__ as filter_r__,
+	filter_o__ as filter_h_2,
+	filter_o__ as _fn__h1__filter,
+}