ctx-core 2.2.0 → 2.2.1

package/all/map_andand_or/index.d.ts

@@ -0,0 +1,13 @@
+import type { andand_key_T } from '../andand/index.js'
+import type { andand_or_T } from '../andand_or/index.js'
+/**
+ * Returns Array of mapped `a` with `_andand(...attr_a)` or the return value of `or_fn`.
+ */
+export declare function map_andand_or<
+	In extends unknown = unknown, Out extends unknown = unknown
+>(
+	a:readonly In[],
+	attr_a:readonly andand_key_T<In>[],
+	or_fn:andand_or_T<In, Out>
+):Out[]
+export { map_andand_or as map__andand__or, }

package/all/map_andand_or/index.js

@@ -0,0 +1,13 @@
+import { map } from '../map/index.js'
+import { one_andand_or_ } from '../one_andand_or/index.js'
+/**
+ * Returns Array of mapped `a` with `_andand(...attr_a)` or the return value of `or_fn`.
+ * @param {unknown[]}a
+ * @param {import('../andand/index.js').andand_key_T[]}attr_a
+ * @param {import('../andand/index.js').andand_or_T}or_fn
+ * @returns {unknown[]}
+ */
+export function map_andand_or(a, attr_a, or_fn) {
+	return map(a, one_andand_or_(attr_a, or_fn))
+}
+export { map_andand_or as map__andand__or, }

package/all/map_andandfn/index.d.ts

@@ -0,0 +1,28 @@
+import type { andand_key_T } from '../andand/index.js'
+/**
+ * Returns Array of mapped `a` with `andandfn_(...attr_a)`
+ */
+export declare function map_andandfn<
+	In extends unknown = unknown, Out extends unknown = unknown
+>(
+	a:readonly In[],
+	...attr_a:readonly andand_key_T<In>[]
+):Out[]
+export {
+	map_andandfn as map__andand_,
+	map_andandfn as map__andand__fn,
+}
+/**
+ * Returns function that returns value from [map_andand_](#map_andand_) with `...attr_a`.
+ */
+export declare function map_andandfn_<
+	Val extends unknown, Out extends unknown
+>(
+	...attr_a:readonly andand_key_T<Val>[]
+):(a:readonly Val[])=>Out[]
+export {
+	map_andandfn_ as map_andand_2,
+	map_andandfn_ as _map_andand_,
+	map_andandfn_ as _map__andand_,
+	map_andandfn_ as _fn__map__andand__fn,
+}

package/all/map_andandfn/index.js

@@ -0,0 +1,29 @@
+import { andandfn_ } from '../andandfn/index.js'
+/** @typedef {import('../andand/index.d.ts').andand_key_T} */
+/**
+ * Returns Array of mapped `a` with `andandfn_(...attr_a)`
+ * @param {unknown[]}a
+ * @param {andand_key_T}attr_a
+ * @returns {unknown[]}
+ */
+export function map_andandfn(a, ...attr_a) {
+	return a.map(andandfn_(...attr_a))
+}
+export {
+	map_andandfn as map__andand_,
+	map_andandfn as map__andand__fn,
+}
+/**
+ * Returns function that returns value from [map_andand_](#map_andand_) with `...attr_a`.
+ * @param {andand_key_T}attr_a
+ * @returns {(a:unknown[])=>unknown[]}
+ */
+export function map_andandfn_(...attr_a) {
+	return a=>map_andandfn(a, ...attr_a)
+}
+export {
+	map_andandfn_ as map_andand_2,
+	map_andandfn_ as _map_andand_,
+	map_andandfn_ as _map__andand_,
+	map_andandfn_ as _fn__map__andand__fn,
+}

package/all/map_apply/index.d.ts

@@ -0,0 +1,17 @@
+import type { map_fn_T } from '../map_fn/index.js'
+/**
+ * Returns function that returns map of calls to fn_a applying in_arg_a with ...arg_a_
+ */
+export declare function map_apply_<
+	Arg extends unknown = unknown,
+	O extends unknown = unknown,
+>(fn_a:map_fn_T[], in_arg_a?:Arg[]):(...fn_arg_a:Arg[])=>O[]
+export declare type map_apply_T<
+	Arg extends unknown = unknown,
+	O extends unknown = unknown,
+> = (...fn_arg_a:Arg[])=>O[]
+export {
+	map_apply_ as map_fn_apply_fn,
+	map_apply_ as _map_apply,
+	map_apply_ as _apply__map,
+}

package/all/map_apply/index.js

@@ -0,0 +1,15 @@
+import { concat } from '../concat/index.js'
+/**
+ * Returns function that returns map of calls to fn_a applying in_arg_a with ...arg_a_
+ * @param {import('../_function_types/index.js').map_fn_T[]}fn_a
+ * @param {unknown}[in_arg_a]
+ * @returns {(...fn_arg_a:unknown[])=>unknown[]}
+ */
+export function map_apply_(fn_a, in_arg_a = []) {
+	return (...fn_arg_a)=>fn_a.map((fn)=>fn(...concat(in_arg_a, fn_arg_a)))
+}
+export {
+	map_apply_ as map_fn_apply_fn,
+	map_apply_ as _map_apply,
+	map_apply_ as _apply__map,
+}

package/all/map_call/index.d.ts

@@ -0,0 +1,22 @@
+import type { map_fn_T } from '../map_fn/index.js'
+/**
+ * Returns the map of calls to fn_a with ...arg_a.
+ */
+export declare function map_call<
+	I extends unknown = unknown,
+	O extends unknown = unknown
+>(fn_a:map_fn_T<I, O>[], ...arg_a:I[]):O[]
+export { map_call as call__map }
+/**
+ * Returns function that maps calls to fn_al ...fac_arg_a concat with ...fn_arg_a passed to function
+ */
+export declare function map_call_<
+	I extends unknown = unknown,
+	O extends unknown = unknown
+>(fn_a:map_fn_T<I, O>[], ...fac_arg_a:I[]):(...fn_arg_a:I[])=>O[]
+export {
+	map_call_ as map_a_call_fn,
+	map_call_ as map_a1_call_fn,
+	map_call_ as _map_call,
+	map_call_ as _call__map,
+}

package/all/map_call/index.js

@@ -0,0 +1,26 @@
+import { concat } from '../concat/index.js'
+/**
+ * Returns the map of calls to fn_a with ...arg_a.
+ * @param {import('../map_fn/index.js').map_fn_T[]}fn_a
+ * @param {unknown}arg_a
+ * @returns {unknown[]}
+ */
+export function map_call(fn_a, ...arg_a) {
+	return fn_a.map((fn)=>fn(...arg_a))
+}
+export { map_call as call__map }
+/**
+ * Returns function that maps calls to fn_al ...fac_arg_a concat with ...fn_arg_a passed to function
+ * @param {import('../map_fn/index.js').map_fn_T[]}fn_a
+ * @param {unknown}fac_arg_a
+ * @returns {(...fn_arg_a:unknown[])=>unknown[]}
+ */
+export function map_call_(fn_a, ...fac_arg_a) {
+	return (...fn_arg_a)=>map_call(fn_a, ...concat(fac_arg_a, fn_arg_a))
+}
+export {
+	map_call_ as map_a_call_fn,
+	map_call_ as map_a1_call_fn,
+	map_call_ as _map_call,
+	map_call_ as _call__map,
+}

package/all/map_find/index.d.ts

@@ -0,0 +1,32 @@
+import type { wrap_a_T2 } from '../wrap_a/index.js'
+/**
+ * Returns first return value of `fn(a[idx], idx)` where `fn(a[idx], idx)` is truthy.
+ */
+export declare function map_find<
+	In extends unknown = unknown, Out extends unknown = In
+>(
+	a:wrap_a_T2<In>,
+	fn:(val:In, idx:number)=>Out
+):Out|undefined
+export declare function maybe_map_find<
+	In extends unknown = unknown,
+	Out extends unknown = In,
+	Or = null
+>(
+	maybe_a:wrap_a_T2<In>,
+	fn:(val:In, idx:number)=>Out,
+	or?:Or
+):Out|Or
+export { map_find as find__map, }
+/**
+ * Returns function that returns value from [map_find](#map_find) with `fn` argument.
+ */
+export declare function map_find_<
+	In extends unknown = unknown, Out extends unknown = In
+>(
+	fn:(val:In, idx:number)=>Out
+):(a:wrap_a_T2<In>)=>Out|undefined
+export {
+	map_find_ as _map_find,
+	map_find_ as _find__map,
+}

package/all/map_find/index.js

@@ -0,0 +1,38 @@
+/** @typedef {import('../wrap_a/index.d.ts').wrap_a_T2} */
+/**
+ * Returns first return value of `fn(a[idx], idx)` where `fn(a[idx], idx)` is truthy.
+ * @param {wrap_a_T2}a
+ * @param {(val:unknown, idx:number)=>unknown}fn
+ * @returns {unknown}
+ */
+export function map_find(a, fn) {
+	for (let idx = 0; idx < a.length; idx++) {
+		const val = a[idx]
+		const map_value = fn(val, idx)
+		if (map_value) return map_value
+	}
+	return
+}
+/**
+ * @param {wrap_a_T2}maybe_a
+ * @param {(val:unknown, idx:number)=>unknown}fn
+ * @param {unknown}or
+ * @returns {unknown}
+ */
+export function maybe_map_find(maybe_a, fn, or = null) {
+	if (!maybe_a) return or
+	return map_find(maybe_a, fn)
+}
+export { map_find as find__map, }
+/**
+ * Returns function that returns value from [map_find](#map_find) with `fn` argument.
+ * @param {(val:unknown, idx:number)=>unknown}fn
+ * @returns {(a:wrap_a_T2)=>unknown}
+ */
+export function map_find_(fn) {
+	return (a)=>map_find(a, fn)
+}
+export {
+	map_find_ as _map_find,
+	map_find_ as _find__map,
+}

package/all/map_fn/index.d.ts

@@ -0,0 +1,4 @@
+export declare type map_fn_T<
+	I extends unknown = unknown,
+	Ret extends unknown = unknown
+> = (...arg_a:I[])=>Ret

package/all/map_fn/index.js

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

package/all/map_inverse/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns Array of inverse values (1/n) of each item in `a`.
+ */
+export declare function map_inverse(a:readonly number[]):number[]
+export { map_inverse as map__inverse, }

package/all/map_inverse/index.js

@@ -0,0 +1,9 @@
+/**
+ * Returns Array of inverse values (1/n) of each item in `a`.
+ * @param {number[]}a
+ * @returns {number[]}
+ */
+export function map_inverse(a) {
+	return a.map(val=>val ? 1 / val : 0)
+}
+export { map_inverse as map__inverse, }

package/all/map_obj/index.d.ts

@@ -0,0 +1,30 @@
+import type { nullish } from '../nullish/index.js'
+/**
+ * Maps values in `in_obj` to `fn`, returning object with values returned by `fn`.
+ */
+export declare function map_obj<
+	In extends unknown = unknown,
+	Out = In
+>(
+	in_obj:Record<string, In>,
+	fn:map_obj_fn_T<In, Out>
+):Record<string, Out|nullish>
+export declare type map_obj_fn_T<
+	Val extends unknown = unknown,
+	Out = Val
+> = (in_obj:Val, key:string)=>Out
+export { map_obj as map__obj }
+/**
+ * Returns function to map `obj` to `fn` returning object with values.
+ */
+export declare function map_obj_<
+	In extends unknown = unknown,
+	Out = In
+>(
+	fn:map_obj_fn_T<In, Out>
+):(obj:Record<string, In>)=>Record<string, Out|nullish>
+export {
+	map_obj_ as _map_obj,
+	map_obj_ as _map__obj,
+	map_obj_ as _fn__map__obj,
+}

package/all/map_obj/index.js

@@ -0,0 +1,28 @@
+/**
+ * Maps values in `in_obj` to `fn`, returning object with values returned by `fn`.
+ * @param {object}in_obj
+ * @param {import('../map_obj/index.js').map_obj_fn_T}fn
+ * @returns {object}
+ */
+export function map_obj(in_obj, fn) {
+	const obj = {}
+	for (let key in in_obj) {
+		obj[key] = fn(in_obj[key], key)
+	}
+	return obj
+}
+export { map_obj as map__obj }
+/**
+ * Returns function to map `obj` to `fn` returning object with values.
+ * @param {import('../map_obj/index.js').map_obj_fn_T}fn
+ * @returns {(obj:object)=>object}
+ * @private
+ */
+export function map_obj_(fn) {
+	return obj=>map_obj(obj, fn)
+}
+export {
+	map_obj_ as _map_obj,
+	map_obj_ as _map__obj,
+	map_obj_ as _fn__map__obj,
+}

package/all/map_obj_andand/index.d.ts

@@ -0,0 +1,28 @@
+import type { andand_key_T } from '../andand/index.js'
+import type { nullish } from '../nullish/index.js'
+/**
+ * Map `values` `andand` `key_a` in `obj` to `fn`, returning object with values return by `fn`.
+ */
+export declare function map_obj_andand<
+	In extends unknown = unknown,
+	Out extends unknown = unknown
+>(
+	obj:Record<string, In>,
+	...key_a:andand_key_T<In>[]
+):Record<string, Out|nullish>
+export { map_obj_andand as map__obj__andand }
+/**
+ * Returns function to
+ * map `values` `andand` `key_a` in `obj` to `fn`, returning object with values return by `fn`.
+ */
+export declare function map_obj_andand_<
+	In extends unknown = unknown,
+	Out = In
+>(
+	...key_a:andand_key_T<In>[]
+):(obj:Record<string, In>)=>Record<string, Out|nullish>
+export {
+	map_obj_andand_ as _map_obj_andand,
+	map_obj_andand_ as _map__obj__andand,
+	map_obj_andand_ as _fn__map__obj__andand,
+}

package/all/map_obj_andand/index.js

@@ -0,0 +1,28 @@
+import { map_obj } from '../map_obj/index.js'
+import { one_andand_ } from '../one_andand/index.js'
+/** @typedef {import('../andand/index.d.ts').andand_key_T} */
+/**
+ * Map `values` `andand` `key_a` in `obj` to `fn`, returning object with values return by `fn`.
+ * @param {object}obj
+ * @param {andand_key_T}key_a
+ * @returns {object}
+ */
+export function map_obj_andand(obj, ...key_a) {
+	return map_obj(obj, one_andand_(...key_a))
+}
+export { map_obj_andand as map__obj__andand }
+/**
+ * Returns function to
+ * map `values` `andand` `key_a` in `obj` to `fn`, returning object with values return by `fn`.
+ * @param {andand_key_T}key_a
+ * @returns {(obj:object)=>object}
+ * @private
+ */
+export function map_obj_andand_(...key_a) {
+	return (obj)=>map_obj_andand(obj, ...key_a)
+}
+export {
+	map_obj_andand_ as _map_obj_andand,
+	map_obj_andand_ as _map__obj__andand,
+	map_obj_andand_ as _fn__map__obj__andand,
+}

package/all/matrix__dot/index.d.ts

@@ -0,0 +1,6 @@
+export declare function matrix__dot(...matrices:number[][]):number[]
+export {
+	matrix__dot as mul_dot,
+	matrix__dot as multiply_dot,
+	matrix__dot as dotMultiply,
+}

package/all/matrix__dot/index.js

@@ -0,0 +1,22 @@
+import { matrix__validate_length } from '../matrix__validate_length/index.js'
+/**
+ * @param {number[][]}matrices
+ * @returns {number[]}
+ */
+export function matrix__dot(...matrices) {
+	const length = matrix__validate_length(matrices)
+	const products = []
+	for (let j = 0; j < length; j++) {
+		let product = matrices[0][j]
+		for (let i = 1; i < matrices.length; i++) {
+			product *= matrices[i][j]
+		}
+		products.push(product)
+	}
+	return products
+}
+export {
+	matrix__dot as mul_dot,
+	matrix__dot as multiply_dot,
+	matrix__dot as dotMultiply,
+}

package/all/matrix__dot__scalar/index.d.ts

@@ -0,0 +1 @@
+export declare function matrix__dot__scalar_(...matrices:number[][]):number

package/all/matrix__dot__scalar/index.js

@@ -0,0 +1,9 @@
+import { matrix__dot } from '../matrix__dot/index.js'
+import { numerator_or_0_sum_ } from '../numerator_or_0_sum/index.js'
+/**
+ * @param {number[][]}matrices
+ * @returns {number}
+ */
+export function matrix__dot__scalar_(...matrices) {
+	return numerator_or_0_sum_(matrix__dot(...matrices))
+}

package/all/matrix__normalize/index.d.ts

@@ -0,0 +1,4 @@
+export declare function matrix__normalize(
+	matrix:number[], columns_length?:number
+):number[]
+export { matrix__normalize as normalize__row__major__matrix }

package/all/matrix__normalize/index.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]}matrix
+ * @param {number}columns_length
+ * @returns {number[]}
+ */
+export function matrix__normalize(matrix, columns_length = 2) {
+	const normalized_matrix = []
+	for (let i = 0; i < matrix.length; i += columns_length) {
+		let sum = 0.0
+		for (let j = 0; j < columns_length; j++) {
+			sum += matrix[i + j] || 0
+		}
+		for (let j = 0; j < columns_length; j++) {
+			const normalized = sum ? matrix[i + j] / sum : 0
+			normalized_matrix.push(normalized)
+		}
+	}
+	return normalized_matrix
+}
+export { matrix__normalize as normalize__row__major__matrix }

package/all/matrix__validate_length/index.d.ts

@@ -0,0 +1 @@
+export declare function matrix__validate_length(...arrays:any[][]):number

package/all/matrix__validate_length/index.js

@@ -0,0 +1,13 @@
+/**
+ * @param {any[][]}arrays
+ * @returns {number}
+ */
+export function matrix__validate_length(...arrays) {
+	const length = arrays[0].length
+	for (let i = 1; i < arrays.length; i++) {
+		if (length != arrays[i].length) {
+			throw new Error('array lengths are not equal')
+		}
+	}
+	return length
+}

package/all/maybe/index.d.ts

@@ -0,0 +1,7 @@
+import type { falsy } from '../falsy/index.js'
+export declare type maybe<
+	I,
+	F = falsy
+> = I|F
+export declare type maybe_undefined<I> = maybe<I, undefined>
+export declare type maybe_null<I> = maybe<I, null>

package/all/maybe/index.js

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

package/all/mean/index.d.ts

@@ -0,0 +1,9 @@
+import type { nullish } from '../nullish/index.js'
+/**
+ * Average of the numerator_a
+ */
+export declare function mean_(numerator_a:readonly (number|nullish)[]):number
+export {
+	mean_ as avg,
+	mean_ as mean,
+}

package/all/mean/index.js

@@ -0,0 +1,17 @@
+import { add } from '../add/index.js'
+import { number__count_ } from '../number__count/index.js'
+/**
+ * Average of the numerator_a
+ */
+export function mean_(numerator_a) {
+	const sum = add(numerator_a)
+	const number__count = number__count_(numerator_a)
+	return (
+		sum == null
+			? null
+			: sum / number__count)
+}
+export {
+	mean_ as avg,
+	mean_ as mean,
+}

package/all/mean/index.test.ts

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

package/all/median/index.d.ts

@@ -0,0 +1,4 @@
+export declare function median_(
+	numerator_a:readonly number[], sorted_?:typeof median_sorted_
+):number
+export declare function median_sorted_(a:readonly number[]):number[]

package/all/median/index.js

@@ -0,0 +1,19 @@
+import { isNumber } from '../isNumber/index.js'
+import { mean_ } from '../mean/index.js'
+export function median_(numerator_a, sorted_ = median_sorted_) {
+	if (numerator_a.length === 0) {
+		return 0
+	} else if (numerator_a.length === 1) {
+		return numerator_a[0]
+	}
+	const sorted = sorted_(numerator_a)
+	const half = sorted.length / 2
+	return sorted.length % 2 == 0 ? sorted[half] : mean_([
+		sorted[Math.ceil(half)],
+		sorted[Math.floor(half)]
+	])
+}
+export function median_sorted_(a) {
+	return a.filter(isNumber).sort((val0, val1)=>val0 - val1
+	)
+}

package/all/merge/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Performs a deep merge on the target with each source_a
+ */
+export declare function merge<
+	I extends unknown = unknown,
+	O = I
+>(target:I, ...source_a:O[]):I|undefined

package/all/merge/index.js

@@ -0,0 +1,25 @@
+/**
+ * Performs a deep merge on the target with each source_a
+ * @param {unknown}target
+ * @param {unknown}source_a
+ * @returns {unknown}
+ */
+export function merge(target, ...source_a) {
+	if (!target) return
+	// Loop through each object and conduct a merge
+	for (let i = 0; i < source_a.length; i++) {
+		const source = source_a[i]
+		for (let prop in source) {
+			if (source.hasOwnProperty(prop)) {
+				if (Object.prototype.toString.call(source[prop]) === '[object Object]') {
+					// If we're doing a deep merge and the property is an object
+					(target)[prop] = merge(target[prop], source[prop])
+				} else {
+					// Otherwise, do a regular merge
+					(target)[prop] = source[prop]
+				}
+			}
+		}
+	}
+	return target
+}

package/all/minute/index.d.ts

@@ -0,0 +1,7 @@
+export declare const minute_ms:number
+export declare const minute_sec = 60
+export {
+	minute_ms as minute,
+	minute_ms as minute_milliseconds,
+	minute_ms as milliseconds__minute,
+}

package/all/minute/index.js

@@ -0,0 +1,7 @@
+export const minute_ms = 1000 * 60
+export const minute_sec = 60
+export {
+	minute_ms as minute,
+	minute_ms as minute_milliseconds,
+	minute_ms as milliseconds__minute,
+}

package/all/minute_seconds/index.d.ts

@@ -0,0 +1,2 @@
+export declare const minute_seconds = 60
+export { minute_seconds as seconds__minute }

package/all/minute_seconds/index.js

@@ -0,0 +1,2 @@
+export const minute_seconds = 60
+export { minute_seconds as seconds__minute }

package/all/missing_argument/index.d.ts

@@ -0,0 +1,31 @@
+import type { argument__error_o_T, error_o_error_T, error_o_T } from '../error_o/index.js'
+import type { HttpError } from '../http_error/index.js'
+export declare const missing_argument__default__message:string
+export declare function missing_argument_error_(
+	message?:string,
+	error_o?:missing_argument_error_o_T
+):MissingArgumentError
+/**
+ * Throws a missing_argument error (HTTP 500)
+ * @example
+ * missing_argument__throw('foobar: not defined', { key: 'foobar' })
+ */
+export declare function missing_argument__throw(
+	message?:string,
+	missing_argument_error_o?:missing_argument_error_o_T
+):void
+export declare class MissingArgumentError
+	extends HttpError
+	implements missing_argument_error_o_error_T {
+	key?:string
+}
+export interface missing_argument_error_o_T extends error_o_T {
+	key?:string
+	type?:string
+}
+export interface argument__missing_argument_error_o_T
+	extends missing_argument_error_o_T, argument__error_o_T {
+}
+export interface missing_argument_error_o_error_T
+	extends error_o_error_T, missing_argument_error_o_T {
+}