ctx-core 2.2.0 → 2.2.2

package/all/notnot/index.js

@@ -0,0 +1,23 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+/**
+ * Returns the truthiness of all values in `in_value_a`
+ * @param {unknown|unknown[]}in_value_a
+ * @returns {boolean}
+ */
+export function notnot(in_value_a) {
+	const value_a = wrap_a_(in_value_a)
+	for (let i = 0; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (!value) return false
+	}
+	return true
+}
+/**
+ * Returns function that calls [notnot](#notnot) with [wrap_concat](#wrap_concat) of the arguments.
+ * @param {unknown|unknown[]}in_value_a
+ * @returns {(val:unknown)=>boolean}
+ */
+export function notnot_(in_value_a) {
+	return (val)=>notnot(wrap_concat(in_value_a, val))
+}
+export { notnot_ as _notnot, }

package/all/null/index.d.ts

@@ -0,0 +1,5 @@
+export declare const null_:()=>null
+export {
+	null_ as null_fn,
+	null_ as _null,
+}

package/all/null/index.js

@@ -0,0 +1,10 @@
+/**
+ * @returns {null}
+ */
+export function null_() {
+	return null
+}
+export {
+	null_ as null_fn,
+	null_ as _null,
+}

package/all/nullish/index.d.ts

@@ -0,0 +1,2 @@
+export declare type nullish = null|undefined
+export declare type nullsy = nullish

package/all/nullish/index.js

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

package/all/nullish__guard/index.d.ts

@@ -0,0 +1,10 @@
+import type { nullish } from '../nullish/index.js'
+export declare function nullish__guard<
+	Val extends unknown = unknown
+>(
+	label:string, ...fn_a:(()=>(nullish|Val))[]
+):Val|nullish
+export {
+	nullish__guard as nullish_guard,
+	nullish__guard as nullsy_guard,
+}

package/all/nullish__guard/index.js

@@ -0,0 +1,16 @@
+/**
+ * @param {string}label
+ * @param {()=>unknown}fn_a
+ * @returns {unknown}
+ */
+export function nullish__guard(label, ...fn_a) {
+	for (const fn of fn_a) {
+		const rv = fn()
+		if (rv != null) return rv
+	}
+	throw new Error(`${label} cannot be nullish`)
+}
+export {
+	nullish__guard as nullish_guard,
+	nullish__guard as nullsy_guard,
+}

package/all/nullish__guard__async/index.d.ts

@@ -0,0 +1,10 @@
+import type { nullish } from '../nullish/index.js'
+export declare function nullish__guard__async<
+	Val extends unknown = unknown
+>(
+	label:string, ...fn_a:(()=>Promise<nullish|Val>)[]
+):Promise<Val>
+export {
+	nullish__guard__async as nullish_async_guard,
+	nullish__guard__async as nullsy_async_guard,
+}

package/all/nullish__guard__async/index.js

@@ -0,0 +1,18 @@
+/**
+ * @param {string}label
+ * @param {()=>Promise<unknown>}fn_a
+ * @returns {Promise<unknown>}
+ */
+export async function nullish__guard__async(
+	label, ...fn_a
+) {
+	for (const fn of fn_a) {
+		const rv = await fn()
+		if (rv != null) return rv
+	}
+	throw new Error(`${label} cannot be nullish`)
+}
+export {
+	nullish__guard__async as nullish_async_guard,
+	nullish__guard__async as nullsy_async_guard,
+}

package/all/nullish__none/index.d.ts

@@ -0,0 +1,12 @@
+import type { nullish } from '../nullish/index.js'
+export function nullish__none_<
+	T extends any[], U
+>(
+	$:T,
+	_:(...$:T)=>U,
+	onnullish?:(nullish:nullish)=>any
+):U
+export {
+	nullish__none_ as nullish__check_,
+}
+

package/all/nullish__none/index.js

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

package/all/nullish__none/index.test.ts

@@ -0,0 +1,58 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { nullish__none_ } from '../nullish__none/index.js'
+test('nullish__none_|-onnullish', ()=>{
+	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(nullish__none_([undefined_val], _), undefined)
+	equal(arg_aa, [])
+	equal(nullish__none_([null_val], _), null)
+	equal(arg_aa, [])
+	equal(nullish__none_([zero], _), [zero])
+	equal(arg_aa, [[zero]])
+	equal(nullish__none_([str], _), [str])
+	equal(arg_aa, [[zero], [str]])
+	equal(nullish__none_([o], _), [o])
+	equal(arg_aa, [[zero], [str], [o]])
+})
+test('nullish__none_|+onnullish', ()=>{
+	const arg_aa:any[][] = []
+	const _ = (...arg_a:any[])=>{
+		arg_aa.push(arg_a)
+		return arg_a
+	}
+	const onnullish__arg_aa:any[][] = []
+	const onnullish = (...arg_a:any[])=>{
+		onnullish__arg_aa.push(arg_a)
+		return 'foobar'
+	}
+	const undefined_val = undefined
+	const null_val = null
+	const zero = 0
+	const str = ''
+	const o = {}
+	equal(nullish__none_([undefined_val], _, onnullish), undefined)
+	equal(arg_aa, [])
+	equal(onnullish__arg_aa, [[undefined]])
+	equal(nullish__none_([null_val], _, onnullish), null)
+	equal(arg_aa, [])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+	equal(nullish__none_([zero], _, onnullish), [zero])
+	equal(arg_aa, [[zero]])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+	equal(nullish__none_([str], _, onnullish), [str])
+	equal(arg_aa, [[zero], [str]])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+	equal(nullish__none_([o], _, onnullish), [o])
+	equal(arg_aa, [[zero], [str], [o]])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+})
+test.run()

package/all/nullish__not_all/index.d.ts

@@ -0,0 +1,8 @@
+import type { nullish } from '../nullish/index.js'
+export function nullish__not_all_<
+	T extends any[], U
+>(
+	$:T,
+	_:(...$:T)=>U,
+	onnullish?:(nullish:nullish)=>any
+):U

package/all/nullish__not_all/index.js

@@ -0,0 +1,16 @@
+/** @typedef {import('../nullish/index.d.ts').nullish} */
+/**
+ * @param {unknown[]}a
+ * @param {(...$:unknown[])=>unknown}_
+ * @param {(nullish:nullish)=>any}[onnullish]
+ * @returns {unknown}
+ */
+export function nullish__not_all_(a, _, onnullish) {
+	let nullish
+	for (const v of a) {
+		if (v != null) return _(...a)
+		if (v === null) nullish = null
+	}
+	if (onnullish) onnullish(nullish)
+	return nullish
+}

package/all/nullish__not_all/index.test.ts

@@ -0,0 +1,70 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { nullish__not_all_ } from '../nullish__not_all/index.js'
+test('nullish__not_all_|-onnullish', ()=>{
+	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(nullish__not_all_([undefined_val], _),
+		undefined)
+	equal(arg_aa, [])
+	equal(nullish__not_all_([undefined_val, null_val], _),
+		null)
+	equal(arg_aa, [])
+	equal(nullish__not_all_([null_val, zero], _),
+		[null, zero])
+	equal(arg_aa, [[null, zero]])
+	equal(nullish__not_all_([undefined_val, str], _),
+		[undefined, str])
+	equal(arg_aa, [[null, zero], [undefined, str]])
+	equal(nullish__not_all_([null, undefined, o], _),
+		[null, undefined, o])
+	equal(arg_aa, [[null, zero], [undefined, str],
+		[null, undefined, o]
+	])
+})
+test('nullish__not_all_|+onnullish', ()=>{
+	const arg_aa:any[][] = []
+	const _ = (...arg_a:any[])=>{
+		arg_aa.push(arg_a)
+		return arg_a
+	}
+	const onnullish__arg_aa:any[][] = []
+	const onnullish = (...arg_a:any[])=>{
+		onnullish__arg_aa.push(arg_a)
+		return 'foobar'
+	}
+	const undefined_val = undefined
+	const null_val = null
+	const zero = 0
+	const str = ''
+	const o = {}
+	equal(nullish__not_all_([undefined_val], _, onnullish),
+		undefined)
+	equal(arg_aa, [])
+	equal(onnullish__arg_aa, [[undefined]])
+	equal(nullish__not_all_([undefined_val, null_val], _, onnullish),
+		null)
+	equal(arg_aa, [])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+	equal(nullish__not_all_([null_val, zero], _, onnullish),
+		[null, zero])
+	equal(arg_aa, [[null, zero]])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+	equal(nullish__not_all_([undefined_val, str], _, onnullish),
+		[undefined, str])
+	equal(arg_aa, [[null, zero], [undefined, str]])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+	equal(nullish__not_all_([null, undefined, o], _, onnullish),
+		[null, undefined, o])
+	equal(arg_aa, [[null, zero], [undefined, str], [null, undefined, o]])
+	equal(onnullish__arg_aa, [[undefined], [null]])
+})
+test.run()

package/all/nullish_or/index.d.ts

@@ -0,0 +1,5 @@
+import type { nullish } from '../nullish/index.js'
+export declare function nullish_or_<
+	Out = unknown,
+	Val = unknown
+>(val:Val, or_:()=>Out):Out|nullish

package/all/nullish_or/index.js

@@ -0,0 +1,11 @@
+/**
+ * @param {unknown}val
+ * @param {()=>unknown}or_
+ * @returns {unknown}
+ * @private
+ */
+export function nullish_or_(val, or_) {
+	if (val === undefined) return undefined
+	if (val === null) return null
+	return or_()
+}

package/all/number__count/index.d.ts

@@ -0,0 +1,4 @@
+import type { nullish } from '../nullish/index.js'
+export declare function number__count_(
+	number_a:(number|nullish)[]
+):number

package/all/number__count/index.js

@@ -0,0 +1,13 @@
+/** @typedef {import('../nullish/index.d.ts').nullish} */
+/**
+ * @param {(number|nullish)[]}number_a
+ * @returns {number}
+ * @private
+ */
+export function number__count_(number_a) {
+	let number__count = 0
+	for (let i = 0; i < number_a.length; i++) {
+		if (number_a[i] != null) number__count++
+	}
+	return number__count
+}

package/all/number__count/index.test.ts

@@ -0,0 +1,7 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { number__count_ } from '../number__count/index.js'
+test('number__count_', ()=>{
+	equal(number__count_([null, 0, 1, null, 3]), 3)
+})
+test.run()

package/all/number_or_mdash_str/index.d.ts

@@ -0,0 +1,2 @@
+export declare function number_or_mdash_str_(number:number|any):string
+export { number_or_mdash_str_ as _number_or_mdash_str, number_or_mdash_str_ as _text__number__or__mdash, }

package/all/number_or_mdash_str/index.js

@@ -0,0 +1,5 @@
+import { isNumber_ } from '../isNumber/index.js'
+export function number_or_mdash_str_(number) {
+	return isNumber_(number) ? `${number}` : '—'
+}
+export { number_or_mdash_str_ as _number_or_mdash_str, number_or_mdash_str_ as _text__number__or__mdash, }

package/all/numerator_or_0_avg/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Averages the items in argument a1, adding 0 if the item is falsy
+ */
+export declare function numerator_or_0_avg_(numerator_a:readonly number[]):number
+export { numerator_or_0_avg_ as _numerator_or_0_avg, numerator_or_0_avg_ as _avg__numerator__or__0, }

package/all/numerator_or_0_avg/index.js

@@ -0,0 +1,10 @@
+import { fn_mean_ } from '../fn_mean/index.js'
+/**
+ * Averages the items in argument a1, adding 0 if the item is falsy
+ * @param {number[]}numerator_a
+ * @returns number
+ */
+export function numerator_or_0_avg_(numerator_a) {
+	return fn_mean_(numerator_a, $=>$ || 0)
+}
+export { numerator_or_0_avg_ as _numerator_or_0_avg, numerator_or_0_avg_ as _avg__numerator__or__0, }

package/all/numerator_or_0_sum/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the sum of the items in numerator_a, adding 0 if an item is falsy.
+ */
+export declare function numerator_or_0_sum_(numerator_a:readonly number[]):number
+export { numerator_or_0_sum_ as _numerator_or_0_sum, numerator_or_0_sum_ as _sum__numerator__or__0, }

package/all/numerator_or_0_sum/index.js

@@ -0,0 +1,10 @@
+import { fn_sum_ } from '../fn_sum/index.js'
+/**
+ * Returns the sum of the items in numerator_a, adding 0 if an item is falsy.
+ * @param {number[]}numerator_a
+ * @return number
+ */
+export function numerator_or_0_sum_(numerator_a) {
+	return fn_sum_(numerator_a, $=>$ || 0)
+}
+export { numerator_or_0_sum_ as _numerator_or_0_sum, numerator_or_0_sum_ as _sum__numerator__or__0, }

package/all/numeric_range/index.d.ts

@@ -0,0 +1,7 @@
+export declare function numeric_range_<
+	F extends number,
+	T extends number
+>(
+	start_idx_or_length:number,
+	length?:number
+):number[]

package/all/numeric_range/index.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number}start_idx_or_length
+ * @param {number}[length]
+ * @returns {number[]}
+ * @private
+ */
+export function numeric_range_(start_idx_or_length, length) {
+	const start_idx =
+		isFinite(length)
+			? start_idx_or_length
+			: 0
+	if (!isFinite(length)) length = start_idx_or_length
+	if (length < 0) throw new Error('length must be >= 0')
+	const numeric_range = /** @type {number[]} */[]
+	for (let idx = start_idx; idx < start_idx + length; idx++) {
+		numeric_range.push(idx)
+	}
+	return numeric_range
+}

package/all/numeric_range/index.test.ts

@@ -0,0 +1,9 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { numeric_range_ } from '../numeric_range/index.js'
+test('numeric_range_', ()=>{
+	equal(numeric_range_(5), [0, 1, 2, 3, 4])
+	equal(numeric_range_(0, 5), [0, 1, 2, 3, 4])
+	equal(numeric_range_(3, 5), [3, 4, 5, 6, 7])
+})
+test.run()

package/all/o_a_present/index.d.ts

@@ -0,0 +1,18 @@
+import type { filter_o_T } from '../filter_o/index.js'
+/**
+ * Returns an Object where the value is a
+ * boolean of whether the array has items present
+ */
+export declare function o_a_present<
+	Val extends unknown = unknown,
+	Obj extends {
+		[key:string]:Val[];
+	} = {
+		[key:string]:Val[];
+	}
+>(o:Obj):filter_o_T|undefined
+export {
+	o_a_present as r_a_present,
+	o_a_present as h_a_present,
+	o_a_present as _h1__present__a1,
+}

package/all/o_a_present/index.js

@@ -0,0 +1,18 @@
+import { a_present_ } from '../a_present/index.js'
+import { filter_o__ } from '../filter_o/index.js'
+/** @typedef {import('../filter_o/index.d.ts').filter_o_T}filter_r_T */
+/**
+ * Returns a filter_h where the values are a boolean of whether the array has items present
+ * @param {object}o
+ * @returns {filter_r_T|undefined}
+ */
+export function o_a_present(o) {
+	return filter_o__(val=>
+		a_present_(val)
+	)(o)
+}
+export {
+	o_a_present as r_a_present,
+	o_a_present as h_a_present,
+	o_a_present as _h1__present__a1,
+}

package/all/o_some/index.d.ts

@@ -0,0 +1,13 @@
+import type { maybe } from '../maybe/index.js'
+/**
+ * Returns true when some of the key/value pairs cause the fn to be truthy.
+ * @example
+ * some({foo: 9, bar: 10}, (value, key) => value === 10) // returns true
+ * some({baz: 11, quux: 12}, (value, key) => value === 10) // returns false
+ */
+export declare function o_some<
+	I extends unknown = unknown
+>(
+	obj:Record<string, I>,
+	compare_some:(obj:I, key:string)=>unknown
+):maybe<boolean>

package/all/o_some/index.js

@@ -0,0 +1,16 @@
+/**
+ * Returns true when some of the key/value pairs cause the fn to be truthy.
+ * @param {object}obj
+ * @param {(obj:unknown, key:string)=>unknown}compare_some
+ * @returns {boolean|undefined}
+ * @example
+ * some({foo: 9, bar: 10}, (value, key) => value === 10) // returns true
+ * some({baz: 11, quux: 12}, (value, key) => value === 10) // returns false
+ */
+export function o_some(obj, compare_some) {
+	if (!obj) return
+	for (let key in obj) {
+		if (compare_some(obj[key], key)) return true
+	}
+	return false
+}

package/all/obj_key_r/index.d.ts

@@ -0,0 +1,10 @@
+import type { valueof } from '../valueof/index.js'
+/**
+ * Returns Hash of each `value[key]` in `obj`.
+ */
+export declare function obj_key_r_<T>(obj:T, key:keyof T):Record<string, valueof<T>>
+export {
+	obj_key_r_ as obj_key_h_,
+	obj_key_r_ as _obj_key_hash,
+	obj_key_r_ as _hash__key__obj,
+}

package/all/obj_key_r/index.js

@@ -0,0 +1,19 @@
+/**
+ * Returns Hash of each `value[key]` in `obj`.
+ * @param {unknown}obj
+ * @param {string}key
+ * @returns {object}
+ * @private
+ */
+export function obj_key_r_(obj, key) {
+	const obj_key_r = {}
+	for (let attr_key in obj) {
+		obj_key_r[attr_key] = obj[attr_key][key]
+	}
+	return obj_key_r
+}
+export {
+	obj_key_r_ as obj_key_h_,
+	obj_key_r_ as _obj_key_hash,
+	obj_key_r_ as _hash__key__obj,
+}

package/all/offset_destructure_aa/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns 2d Array where `source_a` is destructured into subarray of length `offset`.
+ */
+export declare function offset_destructure_aa_<
+	I extends unknown = unknown
+>(
+	source_a:readonly I[], offset?:number
+):I[][]
+export {
+	offset_destructure_aa_ as offset_destructure_a2_,
+	offset_destructure_aa_ as _offset_destructure_a2,
+	offset_destructure_aa_ as _a2__destructure__offset,
+}

package/all/offset_destructure_aa/index.js

@@ -0,0 +1,22 @@
+/**
+ * Returns 2d Array where `source_a` is destructured into subarray of length `offset`.
+ * @param {unknown[]}source_a
+ * @param {number}offset
+ * @returns {unknown[][]}
+ */
+export function offset_destructure_aa_(source_a, offset = 1) {
+	const offset_destructure_aa = []
+	for (let i = 0; i < offset; i++) {
+		offset_destructure_aa.push([])
+	}
+	for (let i1 = 0; i1 < source_a.length; i1++) {
+		const val = source_a[i1]
+		offset_destructure_aa[i1 % offset].push(val)
+	}
+	return offset_destructure_aa
+}
+export {
+	offset_destructure_aa_ as offset_destructure_a2_,
+	offset_destructure_aa_ as _offset_destructure_a2,
+	offset_destructure_aa_ as _a2__destructure__offset,
+}

package/all/offset_i/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns offset index, i * offset
+ */
+export declare function offset_i_(i:number, offset?:number):number
+export {
+	offset_i_ as _offset_i,
+	offset_i_ as _i__offset,
+}

package/all/offset_i/index.js

@@ -0,0 +1,13 @@
+/**
+ * Returns offset index, i * offset
+ * @param {number}i
+ * @param {number}[offset]
+ * @returns {number}
+ */
+export function offset_i_(i, offset = 1) {
+	return i * offset
+}
+export {
+	offset_i_ as _offset_i,
+	offset_i_ as _i__offset,
+}

package/all/offset_i_slice/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns an Array from slicing an array from an array's offset from position i
+ */
+export declare function offset_i_slice<
+	I extends unknown = unknown
+>(
+	a:readonly I[],
+	i:number,
+	offset?:number
+):I[]
+export declare function maybe_offset_i_slice<
+	I extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly I[]|undefined,
+	i:number,
+	offset?:number,
+	or?:Or
+):I[]|Or
+export { offset_i_slice as slice__i__offset, }

package/all/offset_i_slice/index.js

@@ -0,0 +1,26 @@
+/**
+ * Returns an Array from slicing an array from an array's offset from position i
+ * @param {unknown[]}a
+ * @param {number}i
+ * @param {number}offset
+ * @returns {unknown[]}
+ */
+export function offset_i_slice(a, i, offset = 1) {
+	return a.slice(i * offset, (i + 1) * offset)
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {number}i
+ * @param {number}offset
+ * @param {unknown[]|null|undefined}or
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_offset_i_slice(
+	maybe_a,
+	i,
+	offset = 1,
+	or = null
+) {
+	return maybe_a ? maybe_a.slice(i * offset, (i + 1) * offset) : or
+}
+export { offset_i_slice as slice__i__offset, }