ctx-core 2.2.0 → 2.2.2

package/all/find/index.d.ts

@@ -0,0 +1,30 @@
+import type { wrap_a_T2 } from '../wrap_a/index.js'
+/**
+ * Returns first item in `a` where `fn(a[idx], idx)` is truthy.
+ */
+export declare function find<
+	In extends unknown = unknown
+>(
+	a:wrap_a_T2<In>,
+	fn:(val:In, idx:number)=>any
+):In|undefined
+export declare function maybe_find<
+	In extends unknown = unknown, Or = null
+>(
+	maybe_a:wrap_a_T2<In>,
+	fn:(val:In, idx:number)=>any,
+	or?:Or
+):In|Or
+/**
+ * Returns function that returns value from [find](#find) with `fn` argument.
+ */
+export declare function find_<I extends unknown = unknown>(
+	fn:(val:I, idx:number)=>I
+):(a:readonly I[])=>I|undefined
+export declare function maybe_find_<I extends unknown = unknown>(
+	fn:(val:I, idx:number)=>I
+):(maybe_a:wrap_a_T2<I>)=>I|undefined
+export {
+	find_ as _find,
+	maybe_find_ as _maybe_find,
+}

package/all/find/index.js

@@ -0,0 +1,51 @@
+/** @typedef {import('../wrap_a/index.d.ts').wrap_a_T2} */
+/**
+ * Returns first item in `a` where `fn(a[idx], idx)` is truthy.
+ * @param {wrap_a_T2}a
+ * @param {(val:unknown, idx:number)=>unknown}fn
+ * @returns {unknown}
+ */
+export function find(a, fn) {
+	for (let idx = 0; idx < a.length; idx++) {
+		const val = a[idx]
+		const map_val = fn(val, idx)
+		if (map_val) return val
+	}
+	return undefined
+}
+/**
+ * @param maybe_a{wrap_a_T2}
+ * @param fn{(val:unknown, idx:number)=>unknown}
+ * @param or{unknown}
+ * @returns {unknown}
+ */
+export function maybe_find(
+	maybe_a,
+	fn,
+	or = null
+) {
+	if (!maybe_a) return or
+	return find(maybe_a, fn)
+}
+/**
+ * Returns function that returns value from [find](#find) with `fn` argument.
+ * @param fn{(val:unknown, idx:number)=>unknown}
+ * @returns {(a:unknown[])=>unknown}
+ */
+export function find_(fn) {
+	return (a)=>find(a, fn)
+}
+export {
+	find_ as find_fn,
+	find_ as _find,
+}
+/**
+ * @param fn{(val:unknown, idx:number)=>unknown}
+ * @returns {(maybe_a:wrap_a_T2)=>unknown}
+ */
+export function maybe_find_(fn) {
+	return (maybe_a)=>maybe_find(maybe_a, fn)
+}
+export {
+	maybe_find_ as _maybe_find,
+}

package/all/first/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the first item in `a`.
+ */
+export declare function first_<
+	I extends unknown = unknown
+>(a:readonly I[]):I|undefined
+export declare function maybe_first_<
+	I extends unknown = unknown,
+	Or = null
+>(
+	maybe_a:readonly I[]|undefined,
+	or?:Or
+):I|Or
+export {
+	first_ as _first,
+	maybe_first_ as _maybe_first,
+}

package/all/first/index.js

@@ -0,0 +1,23 @@
+/**
+ * Returns the first item in `a`.
+ * @param {unknown[]}a
+ * @returns {unknown}
+ */
+export function first_(a) {
+	return a[0]
+}
+/**
+ * @param maybe_a{unknown[]|undefined}
+ * @param or{unknown[]|null|undefined}
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_first_(
+	maybe_a,
+	or = null
+) {
+	return maybe_a ? first_(maybe_a) : or
+}
+export {
+	first_ as _first,
+	maybe_first_ as _maybe_first,
+}

package/all/flatten/index.d.ts

@@ -0,0 +1,14 @@
+import type { wrap_a_T2 } from '../wrap_a/index.js'
+/**
+ * Flattens the a & it's children into an array without chunks
+ */
+export declare function flatten<
+	I extends unknown = unknown
+>(a:wrap_a_T2<I>):I[]
+export declare function maybe_flatten<
+	I extends unknown = unknown, Or = null
+>(
+	in_a:wrap_a_T2<I>,
+	or?:Or
+):I[]|Or
+export { flatten as flatten__a1, }

package/all/flatten/index.js

@@ -0,0 +1,28 @@
+import { isArray } from '../isArray/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/** @typedef {import('../wrap_a/index.d.ts').wrap_a_T2} */
+/**
+ * Flattens the a & it's children into an array without chunks
+ * @param {wrap_a_T2}a
+ * @returns {unknown[]}
+ */
+export function flatten(a) {
+	return (
+		a.reduce((previous_val, current_val)=>
+				wrap_concat(
+					previous_val,
+					...isArray(current_val)
+						? flatten(current_val)
+						: [current_val]),
+			[]))
+}
+/**
+ * @param in_a{wrap_a_T2}
+ * @param or{unknown[]|null|undefined}
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_flatten(in_a, or = null) {
+	if (!in_a) return or
+	return flatten(in_a)
+}
+export { flatten as flatten__a1, }

package/all/flip/index.d.ts

@@ -0,0 +1,5 @@
+import type { append_current_T, resolver_curry_T } from '../resolver_curry/index.js'
+export declare function flip<
+	ResolverArg extends unknown = unknown
+>(append:append_current_T<ResolverArg>):resolver_curry_T<ResolverArg>
+export { flip as curry__flip }

package/all/flip/index.js

@@ -0,0 +1,10 @@
+import { curry_ } from '../curry/index.js'
+/**
+ * @param append{import('../resolver_curry').append_current_T}
+ * @returns {import('../resolver_curry').resolver_curry_T<unknown>}
+ */
+export function flip(append) {
+	return curry_((local, arg_a)=>
+		Array.prototype.unshift.apply(local, arg_a))(append)
+}
+export { flip as curry__flip }

package/all/float_isNaN/index.d.ts

@@ -0,0 +1,2 @@
+export declare function float_isNaN_(number:number|string):boolean
+export { float_isNaN_ as _float_isNaN, float_isNaN_ as isNaN__float, }

package/all/float_isNaN/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {number}number
+ * @returns {boolean}
+ * @private
+ */
+export function float_isNaN_(number) {
+	return isNaN(parseFloat(number))
+}
+export { float_isNaN_ as _float_isNaN, float_isNaN_ as isNaN__float, }

package/all/fn_mean/index.d.ts

@@ -0,0 +1,13 @@
+import type { nullish } from '../nullish/index.js'
+/**
+ * Averages the items in passed in array
+ */
+export declare function fn_mean_<I = number>(
+	a:readonly I[],
+	numerator_:(val:I)=>number|nullish
+):number
+export {
+	fn_mean_ as fn_avg,
+	fn_mean_ as _fn_avg,
+	fn_mean_ as _avg__fn,
+}

package/all/fn_mean/index.js

@@ -0,0 +1,21 @@
+/**
+ * Averages the items in passed in array
+ */
+export function fn_mean_(a, numerator_) {
+	if (!a) return null
+	let sum = 0
+	let count = 0
+	for (let i = 0; i < a.length; i++) {
+		const val = numerator_(a[i])
+		if (val != null) {
+			sum += val
+			count++
+		}
+	}
+	return sum / count
+}
+export {
+	fn_mean_ as fn_avg,
+	fn_mean_ as _fn_avg,
+	fn_mean_ as _avg__fn,
+}

package/all/fn_mean/index.test.ts

@@ -0,0 +1,13 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { fn_mean_ } from '../fn_mean/index.js'
+test('fn_mean_', ()=>{
+	equal(
+		fn_mean_([null, 1, 2, null, null, 3],
+			val=>
+				val == null
+					? null
+					: val * 2),
+		4)
+})
+test.run()

package/all/fn_pipe/index.d.ts

@@ -0,0 +1,70 @@
+export function fn_pipe<A>(o:A):A
+export function fn_pipe<A, B>(o:A, _0:($:A)=>B):B
+export function fn_pipe<A, B, C>(o:A, _0:($:A)=>B, _1:($:B)=>C):C
+export function fn_pipe<A, B, C, D>(o:A, _0:($:A)=>B, _1:($:B)=>C, _2:($:C)=>D):D
+export function fn_pipe<A, B, C, D, E>(o:A, _0:($:A)=>B, _1:($:B)=>C, _2:($:C)=>D, _3:($:D)=>E):E
+export function fn_pipe<A, B, C, D, E, F>(
+	o:A,
+	_0:($:A)=>B,
+	_1:($:B)=>C,
+	_2:($:C)=>D,
+	_3:($:D)=>E,
+	_4:($:E)=>F
+):F
+export function fn_pipe<A, B, C, D, E, F, G>(
+	o:A,
+	_0:($:A)=>B,
+	_1:($:B)=>C,
+	_2:($:C)=>D,
+	_3:($:D)=>E,
+	_4:($:E)=>F,
+	_5:($:F)=>G
+):G
+export function fn_pipe<A, B, C, D, E, F, G, H>(
+	o:A,
+	_0:($:A)=>B,
+	_1:($:B)=>C,
+	_2:($:C)=>D,
+	_3:($:D)=>E,
+	_4:($:E)=>F,
+	_5:($:F)=>G,
+	_6:($:G)=>H
+):H
+export function fn_pipe<A, B, C, D, E, F, G, H, I>(
+	o:A,
+	_0:($:A)=>B,
+	_1:($:B)=>C,
+	_2:($:C)=>D,
+	_3:($:D)=>E,
+	_4:($:E)=>F,
+	_5:($:F)=>G,
+	_6:($:G)=>H,
+	_7:($:H)=>I
+):I
+export function fn_pipe<A, B, C, D, E, F, G, H, I, J>(
+	o:A,
+	_0:($:A)=>B,
+	_1:($:B)=>C,
+	_2:($:C)=>D,
+	_3:($:D)=>E,
+	_4:($:E)=>F,
+	_5:($:F)=>G,
+	_6:($:G)=>H,
+	_7:($:H)=>I,
+	_8:($:I)=>J
+):J
+export function fn_pipe<A, B, C, D, E, F, G, H, I, J, K>(
+	o:A,
+	_0:($:A)=>B,
+	_1:($:B)=>C,
+	_2:($:C)=>D,
+	_3:($:D)=>E,
+	_4:($:E)=>F,
+	_5:($:F)=>G,
+	_6:($:G)=>H,
+	_7:($:H)=>I,
+	_8:($:I
+	)=>J, ...args:(($:any)=>any)[]):K
+export {
+	fn_pipe as _p_,
+}

package/all/fn_pipe/index.js

@@ -0,0 +1,11 @@
+/**
+ * @param {...args(($:unknown)=>unknown)[]}args
+ * @returns {unknown}
+ */
+export function fn_pipe(...args) {
+	return args.reduce((acc, el)=>el(acc))
+}
+export {
+	fn_pipe as _p_,
+	fn_pipe as P,
+}

package/all/fn_pipe/index.test.ts

@@ -0,0 +1,18 @@
+import { test } from 'uvu'
+import { equal, is } from 'uvu/assert'
+import { _p_, fn_pipe } from '../fn_pipe/index.js'
+test('fn_pipe|synchronous', ()=>{
+	const o = {}
+	is(o, fn_pipe(o, $=>$))
+	equal({ foo: 'bar', o }, fn_pipe(o, $=>$, o=>({ foo: 'bar', o })))
+	is(o, _p_(o, $=>$))
+	equal({ foo: 'bar', o }, _p_(o, $=>$, o=>({ foo: 'bar', o })))
+})
+test('fn_pipe|async', async ()=>{
+	const o = { one: 1 }
+	equal({ one: 1, foo: 'bar', baz: 'quux' },
+		await fn_pipe(o, async ()=>({ ...o, foo: 'bar' }), $=>$.then($=>({ ...$, baz: 'quux' }))))
+	equal({ one: 1, foo: 'bar', baz: 'quux' },
+		await _p_(o, async ()=>({ ...o, foo: 'bar' }), $=>$.then($=>({ ...$, baz: 'quux' }))))
+})
+test.run()

package/all/fn_sum/index.d.ts

@@ -0,0 +1,12 @@
+import type { nullish } from '../nullish/index.js'
+/**
+ * Returns the sum of the values mapped by numerator_
+ */
+export declare function fn_sum_<I = number>(
+	a:readonly I[],
+	numerator_:(val:I)=>(number|nullish)
+):number
+export {
+	fn_sum_ as _fn_sum,
+	fn_sum_ as _sum__fn,
+}

package/all/fn_sum/index.js

@@ -0,0 +1,17 @@
+/**
+ * Returns the sum of the values mapped by numerator_
+ * @param {unknown[]}a
+ * @param {(val:I)=>(number|nullish)}numerator_
+ */
+export function fn_sum_(a, numerator_) {
+	let sum = 0
+	if (!a) return sum
+	for (let i = 0; i < a.length; i++) {
+		sum += numerator_(a[i])
+	}
+	return sum
+}
+export {
+	fn_sum_ as _fn_sum,
+	fn_sum_ as _sum__fn,
+}

package/all/fn_sum/index.test.ts

@@ -0,0 +1,13 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { fn_sum_ } from '../fn_sum/index.js'
+test('fn_sum_', ()=>{
+	equal(
+		fn_sum_([null, 1, 2, null, null, 3],
+			val=>
+				val == null
+					? null
+					: val * 2),
+		12)
+})
+test.run()

package/all/format_date_prose/index.d.ts

@@ -0,0 +1 @@
+export declare function format_date_prose(date?:Date):string

package/all/format_date_prose/index.js

@@ -0,0 +1,10 @@
+import { month_a } from '../month_a/index.js'
+import { pad2 } from '../pad2/index.js'
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function format_date_prose(date) {
+	date = date || new Date()
+	return `${month_a[date.getMonth()]} ${pad2(date.getDate())}, ${date.getFullYear()}`
+}

package/all/format_utc_date_prose/index.d.ts

@@ -0,0 +1 @@
+export declare function format_utc_date_prose(date?:Date):string

package/all/format_utc_date_prose/index.js

@@ -0,0 +1,10 @@
+import { month_a } from '../month_a/index.js'
+import { pad2 } from '../pad2/index.js'
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function format_utc_date_prose(date) {
+	date = date || new Date()
+	return `${month_a[date.getUTCMonth()]} ${pad2(date.getUTCDate())}, ${date.getUTCFullYear()}`
+}

package/all/globalThis__prop__ensure/index.d.ts

@@ -0,0 +1,4 @@
+export declare function globalThis__prop__ensure<T>(
+	prop_sym:string|symbol,
+	_:()=>T
+):T

package/all/globalThis__prop__ensure/index.js

@@ -0,0 +1,10 @@
+/**
+ * @param {string|Symbol}prop
+ * @param {()=>unknown}_
+ */
+export function globalThis__prop__ensure(prop, _) {
+	if (!globalThis[prop]) {
+		globalThis[prop] = _()
+	}
+	return globalThis[prop]
+}

package/all/globalThis__prop__ensure/index.test.ts

@@ -0,0 +1,22 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { globalThis__prop__ensure } from '../globalThis__prop__ensure/index.js'
+const test_fn_sym = Symbol.for('test_fn_sym')
+test('globalThis__prop__ensure|string', ()=>{
+	const test__globalThis = globalThis as test__globalThis_T
+	equal(test__globalThis.test_fn_str, undefined)
+	equal(
+		globalThis__prop__ensure('test_fn_str', ()=>'test'),
+		'test')
+	equal(test__globalThis.test_fn_str, 'test')
+})
+test('globalThis__prop__ensure|symbol', ()=>{
+	const test__globalThis = globalThis as test__globalThis_T
+	equal(test__globalThis[test_fn_sym], undefined)
+	equal(globalThis__prop__ensure(test_fn_sym, ()=>'test'), 'test')
+	equal(test__globalThis[test_fn_sym], 'test')
+})
+type test__globalThis_T = typeof globalThis&{
+	test_fn_str:string
+	[test_fn_sym]:string
+}

package/all/gte_0_a/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns Array of values `>= 0` in `val_a`.
+ */
+export declare function gte_0_a_<
+	T extends number = number
+>(val_a:readonly T[]):T[]
+export {
+	gte_0_a_ as gte_0_a1_fn,
+	gte_0_a_ as _gte_0_a1,
+	gte_0_a_ as _a1__gte__0,
+}

package/all/gte_0_a/index.js

@@ -0,0 +1,21 @@
+/**
+ * Returns Array of values `>= 0` in `val_a`.
+ * @param val_a{number[]}
+ * @returns {number[]}
+ */
+export function gte_0_a_(val_a) {
+	/** @type {number[]} */
+	const gte_0_a = []
+	for (let i = 0; i < val_a.length; i++) {
+		const val = val_a[i]
+		if (val >= 0) {
+			gte_0_a.push(val)
+		}
+	}
+	return gte_0_a
+}
+export {
+	gte_0_a_ as gte_0_a1_fn,
+	gte_0_a_ as _gte_0_a1,
+	gte_0_a_ as _a1__gte__0,
+}

package/all/hasOwnProperty_pick/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns object with picked values,
+ * not including inherited property values (i.e. if hasOwnProperty is false).
+ */
+export declare function hasOwnProperty_pick<
+	I extends unknown = unknown,
+	O = I
+>(val:I, ...key_a:string[]):O|undefined
+export { hasOwnProperty_pick as pick__hasOwnProperty }

package/all/hasOwnProperty_pick/index.js

@@ -0,0 +1,17 @@
+/**
+ * Returns object with picked values,
+ * not including inherited property values (i.e. if hasOwnProperty is false).
+ * @param {unknown}val
+ * @param {string}key_a
+ * @returns {unknown}}
+ */
+export function hasOwnProperty_pick(val, ...key_a) {
+	if (!val) return
+	let memo = {}
+	for (let i = 0; i < key_a.length; i++) {
+		const key = key_a[i]
+		if (val.hasOwnProperty(key)) memo[key] = val[key]
+	}
+	return memo
+}
+export { hasOwnProperty_pick as pick__hasOwnProperty }

package/all/has_key/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns true if obj has given in_key, false otherwise.
+ * If no in_key given, returns true if obj has any in_key, false otherwise.
+ */
+export declare function has_key(obj:object, in_key?:symbol):boolean
+export { has_key as has__key }
+/**
+ * If a key is given, returns boolean indicitating if the given key is a member of the obj.
+ * If no key is given, returns boolean indicitating if the obj has any key.
+ */
+export declare function has_key_(obj:object, in_key?:string):boolean
+export {
+	has_key_ as _has_key,
+	has_key_ as _has__key,
+}

package/all/has_key/index.js

@@ -0,0 +1,38 @@
+import { keys } from '../keys/index.js'
+const no_key_arg_symbol = Symbol('no_key_arg')
+/**
+ * Returns true if obj has given in_key; false otherwise.
+ * If no in_key given, returns true if obj has any in_key; false otherwise.
+ * @param {object}obj
+ * @param {symbol}[in_key]
+ * @returns {boolean}
+ */
+export function has_key(obj, in_key = no_key_arg_symbol) {
+	if (in_key === no_key_arg_symbol) {
+		for (let _ in obj) {
+			return true
+		}
+	} else {
+		for (let key in obj) {
+			if (in_key.toString() === key.toString()) return true
+		}
+	}
+	return false
+}
+export { has_key as has__key }
+/**
+ * If a key is given, returns boolean of indicitating if the given key is a member of the obj.
+ * If no key is given, returns boolean of indicitating if the obj has any key.
+ * @param {object}obj
+ * @param {boolean}[in_key]
+ * @returns {boolean}
+ * @private
+ */
+export function has_key_(obj, in_key) {
+	const $keys = keys(obj)
+	return in_key ? !!~$keys.indexOf(in_key) : !!$keys.length
+}
+export {
+	has_key_ as _has_key,
+	has_key_ as _has__key,
+}

package/all/has_multiple/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns true if argument is an array with more than one item
+ */
+export declare function has_multiple_(a:readonly unknown[]):boolean
+export {
+	has_multiple_ as _has_multiple,
+	has_multiple_ as _has__multiple,
+	has_multiple_ as _has__multiple__a1,
+}

package/all/has_multiple/index.js

@@ -0,0 +1,14 @@
+import { a_length_ } from '../a_length/index.js'
+/**
+ * Returns true if argument is an array with more than one item
+ * @param {unknown[]}a
+ * @returns {boolean}
+ */
+export function has_multiple_(a) {
+	return a_length_(a) > 1
+}
+export {
+	has_multiple_ as _has_multiple,
+	has_multiple_ as _has__multiple,
+	has_multiple_ as _has__multiple__a1,
+}

package/all/has_some_key/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if obj has at least 1 key
+ */
+export declare function has_some_key(obj:object):boolean
+export { has_some_key as has__some__key }

package/all/has_some_key/index.js

@@ -0,0 +1,12 @@
+/**
+ * Returns true if obj has at least 1 key
+ * @param {object}obj
+ * @returns {boolean}
+ */
+export function has_some_key(obj) {
+	for (let _ in obj) {
+		return true
+	}
+	return false
+}
+export { has_some_key as has__some__key }

package/all/head_arg_a/index.d.ts

@@ -0,0 +1,12 @@
+import type { slice_arg_a_fn_T, slice_arg_a_T } from '../slice_arg_a/index.js'
+/**
+ * Returns a function where the first `count` arguments are sent to the wrapped function.
+ */
+export declare function head_arg_a_<
+	I extends unknown = unknown
+>(fn:slice_arg_a_fn_T<I>, count?:number):slice_arg_a_T<I>
+export {
+	head_arg_a_ as head_arg_a1_fn,
+	head_arg_a_ as _head_arg_a1,
+	head_arg_a_ as _arg_a1__head,
+}

package/all/head_arg_a/index.js

@@ -0,0 +1,15 @@
+import { slice_arg_a_ } from '../slice_arg_a/index.js'
+/**
+ * Returns a function where the first `count` arguments are sent to the wrapped function.
+ * @param {import('../slice_arg_a/index.js').slice_arg_a_fn_T}fn
+ * @param {number}[count]
+ * @returns {import('../slice_arg_a_/index.js').slice_arg_a_T}
+ */
+export function head_arg_a_(fn, count = 1) {
+	return slice_arg_a_(fn, 0, count)
+}
+export {
+	head_arg_a_ as head_arg_a1_fn,
+	head_arg_a_ as _head_arg_a1,
+	head_arg_a_ as _arg_a1__head,
+}