ctx-core 2.2.0 → 2.2.1

package/all/LessThan/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @see {@link https://stackoverflow.com/a/70468769/142571}
+ */
+export type LessThan<
+	N extends number,
+	A extends any[] = []
+> =
+	N extends A['length']
+		? A[number]
+		: LessThan<N, [...A, A['length']]>

package/all/LessThan/index.js

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

package/all/MAX_INT/index.d.ts

@@ -0,0 +1 @@
+export declare const MAX_INT = 9007199254740991

package/all/MAX_INT/index.js

@@ -0,0 +1 @@
+export const MAX_INT = 9007199254740991

package/all/MIN_INT/index.d.ts

@@ -0,0 +1 @@
+export declare const MIN_INT = -9007199254740991

package/all/MIN_INT/index.js

@@ -0,0 +1 @@
+export const MIN_INT = -9007199254740991

package/all/Map__object/index.d.ts

@@ -0,0 +1,5 @@
+export declare function Map__object_<
+	K extends string|number|symbol,
+	V
+>(M:Map<K, V>):Record<K, V>
+export { Map__object_ as M__o_ }

package/all/Map__object/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {Map<string|number|symbol, unknown>}M
+ * @returns {Record<string|number|symbol, unknown>}
+ * @private
+ */
+export function Map__object_(M) {
+	return Object.fromEntries([...M])
+}
+export { Map__object_ as M__o_ }

package/all/Map__object/index.test.ts

@@ -0,0 +1,7 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { Map__object_ } from '../Map__object/index.js'
+test('has_key_', ()=>{
+	equal({ foo: 'bar', baz: 'quux' }, Map__object_(new Map([['foo', 'bar'], ['baz', 'quux']])))
+})
+test.run()

package/all/NoRepetition/index.d.ts

@@ -0,0 +1,6 @@
+export type NoRepetition<
+	U extends string,
+	ResultT extends any[] = []
+> =
+	ResultT
+	|{ [k in U]:NoRepetition<Exclude<U, k>, [k, ...ResultT]> }[U]

package/all/NoRepetition/index.js

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

package/all/NumericRange/index.d.ts

@@ -0,0 +1,8 @@
+import type { LessThan } from '../LessThan/index.js'
+/**
+ * @see {@link https://stackoverflow.com/a/70468769/142571}
+ */
+export type NumericRange<
+	F extends number,
+	T extends number
+> = Exclude<T|LessThan<T>, LessThan<F>>

package/all/NumericRange/index.js

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

package/all/NumericUnit/index.d.ts

@@ -0,0 +1,4 @@
+import type { TagType } from '../TagType/index.js'
+// From https://github.com/Microsoft/TypeScript/issues/364#issuecomment-719046161
+export type NumericUnit<S> = TagType<number, S>
+export { NumericUnit as NumberUnit }

package/all/NumericUnit/index.js

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

package/all/PHI/index.d.ts

@@ -0,0 +1 @@
+export declare const PHI:number

package/all/PHI/index.js

@@ -0,0 +1,2 @@
+const { sqrt } = Math
+export const PHI = (1 + sqrt(5)) / 2

package/all/Request/index.d.ts

@@ -0,0 +1,2 @@
+export declare const Request:Request
+export declare const RequestInit:RequestInit

package/all/Request/index.js

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

package/all/Response/index.d.ts

@@ -0,0 +1 @@
+export declare const Response:Response

package/all/Response/index.js

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

package/all/TagType/index.d.ts

@@ -0,0 +1,2 @@
+declare const TagTypeSymbol:unique symbol
+export type TagType<P, S> = P&{ [TagTypeSymbol]:S }

package/all/TagType/index.js

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

package/all/Timeout/index.d.ts

@@ -0,0 +1 @@
+export declare type Timeout = ReturnType<typeof setTimeout>

package/all/Timeout/index.js

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

package/all/UnorderedTuple/index.d.ts

@@ -0,0 +1,4 @@
+import type { NoRepetition } from '../NoRepetition/index.js'
+export type UnorderedTuple<
+	MemberA extends any[] = any[]
+> = NoRepetition<string, MemberA>

package/all/UnorderedTuple/index.js

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

package/all/a/index.d.ts

@@ -0,0 +1 @@
+export declare function a_():[]

package/all/a/index.js

@@ -0,0 +1,3 @@
+export function a_() {
+	return []
+}

package/all/a_assign/index.d.ts

@@ -0,0 +1,7 @@
+export declare function a_assign<
+	Val extends object = object
+>(arg_a:Val[]):Val
+export {
+	a_assign as a1_assign,
+	a_assign as assign__a1,
+}

package/all/a_assign/index.js

@@ -0,0 +1,12 @@
+import { assign } from '../assign/index.js'
+/**
+ * @param {object[]}arg_a
+ * @returns {object}
+ */
+export function a_assign(arg_a) {
+	return assign(arg_a[0], ...arg_a.slice(1))
+}
+export {
+	a_assign as a1_assign,
+	a_assign as assign__a1,
+}

package/all/a_in_idx_a_map/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns Array of values from `a` with index in `idx_a`.
+ */
+export declare function a_in_idx_a_map<
+	Val extends unknown = unknown
+>(
+	idx_a:readonly number[], a:readonly Val[]
+):Val[]
+export {
+	a_in_idx_a_map as a1_in_idx_a1_map,
+	a_in_idx_a_map as map__a1__idx__in__a1,
+}

package/all/a_in_idx_a_map/index.js

@@ -0,0 +1,13 @@
+/**
+ * Returns Array of values from `a` with index in `idx_a`.
+ * @param {number[]}idx_a
+ * @param {unknown[]}a
+ * @returns {unknown[]}
+ */
+export function a_in_idx_a_map(idx_a, a) {
+	return idx_a.map(idx=>a[idx])
+}
+export {
+	a_in_idx_a_map as a1_in_idx_a1_map,
+	a_in_idx_a_map as map__a1__idx__in__a1,
+}

package/all/a_item/index.d.ts

@@ -0,0 +1,12 @@
+export declare type a_item_T<
+	I extends unknown = unknown
+> =
+	I extends readonly (infer O)[]
+		? O
+		: I
+export declare type a1_item_type<
+	I extends unknown = unknown
+> = a_item_T<I>
+export declare type a1_item_T<
+	I extends unknown = unknown
+> = a_item_T<I>

package/all/a_item/index.js

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

package/all/a_length/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns length of `in_a`
+ */
+export declare function a_length_<
+	Val extends unknown = unknown
+>(a:readonly Val[]):number
+export declare function maybe_a__length_<
+	Val extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly Val[]|undefined, or?:Or
+):number|Or
+export {
+	a_length_ as a_length_fn,
+	a_length_ as _a1_length,
+	a_length_ as _length__a1,
+	maybe_a__length_ as _maybe_a1_length,
+	maybe_a__length_ as maybe_a1_length_fn,
+}

package/all/a_length/index.js

@@ -0,0 +1,21 @@
+/**
+ * Returns length of `in_a`
+ * @param {unknown[]}a
+ * @returns {number}
+ */
+export function a_length_(a) {
+	return a.length
+}
+export {
+	a_length_ as a_length_fn,
+	a_length_ as _a1_length,
+	a_length_ as _length__a1,
+}
+export function maybe_a__length_(maybe_a, or = false) {
+	return maybe_a ? a_length_(maybe_a) : or
+}
+export {
+	maybe_a__length_ as maybe_a_length$,
+	maybe_a__length_ as _maybe_a1_length,
+	maybe_a__length_ as maybe_a1_length_fn,
+}

package/all/a_nowrap/index.d.ts

@@ -0,0 +1,7 @@
+export declare type a_nowrap_T<
+	I extends unknown = unknown
+> =
+	I
+	|readonly I[]
+	|readonly I[][]
+export declare type ANowrapT = a_nowrap_T

package/all/a_nowrap/index.js

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

package/all/a_present/index.d.ts

@@ -0,0 +1,19 @@
+import { a_length_ } from '../a_length/index.js'
+/**
+ * Returns true if `a` has a length
+ */
+export declare function a_present_<
+	Val extends unknown = unknown
+>(a:readonly Val[]):boolean
+export declare function maybe_a_present_fn<
+	Val extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly Val[]|undefined, or?:Or
+):boolean|Or
+export {
+	a_present_ as a1_present_fn,
+	a_length_ as _a1_present,
+	a_present_ as _present__a1,
+	maybe_a_present_fn as _maybea_present_,
+	maybe_a_present_fn as maybea_present__fn,
+}

package/all/a_present/index.js

@@ -0,0 +1,24 @@
+import { a_length_ } from '../a_length/index.js'
+/**
+ * Returns true if `a` has a length
+ * @param {unknown[]}a
+ * @returns {boolean}
+ */
+export function a_present_(a) {
+	return !!a_length_(a)
+}
+/**
+ * @param maybe_a{unknown[]}
+ * @param {boolean|null|undefined}[or]
+ * @returns {boolean|null|undefined}
+ */
+export function maybe_a_present_fn(maybe_a, or = false) {
+	return maybe_a ? a_present_(maybe_a) : or
+}
+export {
+	a_present_ as a1_present_fn,
+	a_length_ as _a1_present,
+	a_present_ as _present__a1,
+	maybe_a_present_fn as _maybea_present_,
+	maybe_a_present_fn as maybea_present__fn,
+}

package/all/a_some/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns true if some `predicate(value)` is truthy
+ */
+export declare function a_some<
+	Val extends unknown = unknown, POut extends unknown = unknown
+>(
+	a:readonly Val[],
+	predicate:(val:Val, index:number, a:readonly Val[])=>POut
+):boolean
+export {
+	a_some as some_a1,
+	a_some as some__a1,
+}

package/all/a_some/index.js

@@ -0,0 +1,20 @@
+/**
+ * Returns true if some `predicate(value)` is truthy
+ * @param {unknown[]}a
+ * @param {(val:unknown, index:number, a:unknown[])=>unknown}predicate
+ * @returns {boolean}
+ */
+export function a_some(a, predicate) {
+	let index = -1
+	const length = a.length
+	while (++index < length) {
+		if (predicate(a[index], index, a)) {
+			return true
+		}
+	}
+	return false
+}
+export {
+	a_some as some_a1,
+	a_some as some__a1,
+}

package/all/abbrev_month_a/index.d.ts

@@ -0,0 +1,2 @@
+export declare const abbrev_month_a:string[]
+export { abbrev_month_a as a1__month__abbrev }

package/all/abbrev_month_a/index.js

@@ -0,0 +1,15 @@
+export const abbrev_month_a = [
+	'Jan',
+	'Feb',
+	'Mar',
+	'Apr',
+	'May',
+	'Jun',
+	'Jul',
+	'Aug',
+	'Sep',
+	'Oct',
+	'Nov',
+	'Dec'
+]
+export { abbrev_month_a as a1__month__abbrev }

package/all/abbreviate_number_str/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Normalization text for a number
+ * @example
+ * `$${abbreviate__number(amount, {6: 'mm', 9: 'bn', 12: 'tn'})}`
+ */
+export declare function abbreviate_number_str_(number:number|string, denominations:Record<string, string>):string
+export {
+	abbreviate_number_str_ as _abbreviate_number_str,
+	abbreviate_number_str_ as abbreviate__number,
+}

package/all/abbreviate_number_str/index.js

@@ -0,0 +1,28 @@
+/**
+ * Normalization text for a number
+ * @example
+ * `$${abbreviate__number(amount, {6: 'mm', 9: 'bn', 12: 'tn'})}`
+ */
+export function abbreviate_number_str_(number, denominations) {
+	const float = parseFloat(number)
+	if (!float) return '0'
+	const exp10 = Math.floor(Math.log10(float))
+	const exp10_step = exp10 >= 0 ? -1 : 1
+	let denomination = '', denomination_i = exp10
+	set_denomination()
+	const normalized_float = denomination ? float / Math.pow(10, denomination_i) : float
+	const normalized_fixed = normalized_float.toFixed(2)
+	return `${normalized_fixed}${denomination}`
+	function set_denomination() {
+		denomination_i = exp10
+		while (denomination_i) {
+			denomination = denominations[denomination_i]
+			if (denomination) break
+			denomination_i = denomination_i + exp10_step
+		}
+	}
+}
+export {
+	abbreviate_number_str_ as _abbreviate_number_str,
+	abbreviate_number_str_ as abbreviate__number,
+}

package/all/acronym/index.d.ts

@@ -0,0 +1,2 @@
+export declare function acronym_(string:string):string
+export { acronym_ as _acronym, }

package/all/acronym/index.js

@@ -0,0 +1,8 @@
+/**
+ * @param {string}string
+ * @returns {string}
+ */
+export function acronym_(string) {
+	return string && string.match(/\b(\w)/g)?.join('') || ''
+}
+export { acronym_ as _acronym, }

package/all/add/index.d.ts

@@ -0,0 +1,11 @@
+import type { nullish } from '../nullish/index.js'
+/**
+ * Adds the arguments
+ */
+export declare function add(
+	numerator_a:readonly (number|nullish)[]|nullish
+):number|null
+/**
+ * Sum of the numerators
+ */
+export { add as _sum, add as sum, add as sum_, }

package/all/add/index.js

@@ -0,0 +1,24 @@
+/** @typedef {import('../nullish/index.d.ts').nullish} */
+/**
+ * Adds the arguments
+ * @param {readonly (number|nullish)[]|nullish}numerator_a
+ * @returns {null}
+ */
+export function add(numerator_a) {
+	if (!numerator_a) return null
+	let sum = null
+	for (const $ of numerator_a) {
+		if ($ != null) {
+			sum = sum == null ? $ : sum + $
+		}
+	}
+	return sum
+}
+/**
+ * Sum of the numerators
+ */
+export {
+	add as _sum,
+	add as sum,
+	add as sum_,
+}

package/all/add/index.test.ts

@@ -0,0 +1,14 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { add } from '../add/index.js'
+test('add|value', ()=>{
+	equal(add([2, 1, 3, 0]), 6)
+	equal(add([2, 1, 3, null]), 6)
+	equal(add([NaN, NaN]), NaN)
+	equal(add([1, NaN]), NaN)
+	equal(add([null, null, null, null]), null)
+	equal(add([undefined, undefined]), null)
+	equal(add(null), null)
+	equal(add(undefined), null)
+})
+test.run()

package/all/all_union_a/index.d.ts

@@ -0,0 +1,10 @@
+declare function all_union_a__<T>():
+	<U extends T[]>(
+		a:all_union_a_T<T, U>
+	)=>all_union_a_T<T, U>
+export type all_union_a_T<T, U extends T[]> =
+	U
+	&([T] extends [U[number]] ? unknown : 'Invalid')
+	&{
+	0:T
+}

package/all/all_union_a/index.js

@@ -0,0 +1,8 @@
+/** @typedef {import('../add/index.js').all_union_a_T}all_union_a_T */
+/**
+ * @return {(a:all_union_a_T)=>all_union_a_T}
+ * @see {@link https://stackoverflow.com/questions/60131681/make-sure-array-has-all-types-from-a-union/75418615#75418615}
+ */
+export function all_union_a__() {
+	return a=>a
+}

package/all/and/index.d.ts

@@ -0,0 +1,29 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+import type { falsy } from '../falsy/index.js'
+/**
+ * Returns the first falsy or last item.
+ */
+export declare function and<
+	I extends unknown = unknown,
+	O extends unknown = I
+>(a_nowrap:a_nowrap_T<I>):O|falsy
+/**
+ * Returns the first falsy or last item function call or value in `in_value_a` .
+ */
+export declare function and_<
+	I extends unknown = unknown,
+	O extends unknown = I
+>(a_nowrap:I):O|falsy
+export { and_ as and__fn }
+/**
+ * Returns function that returns the first falsy or last item function call or value in `in_value_a` .
+ */
+export declare function and_2<
+	A_outer extends unknown[] = unknown[],
+	A_inner extends unknown[] = unknown[],
+	O extends unknown = unknown
+>(in_value_a:A_inner):(fn_value_a:A_outer)=>O|falsy
+export {
+	and_2 as _and_fn,
+	and_2 as _and__fn,
+}

package/all/and/index.js

@@ -0,0 +1,45 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns the first falsy or last item in `a_nowrap`.
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
+ * @returns {unknown}
+ */
+export function and(a_nowrap) {
+	const value_a = wrap_a_(a_nowrap)
+	for (let i = 0; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (!value) return value
+	}
+	return value_a[value_a.length - 1]
+}
+/**
+ * Returns the first falsy or last item function call or value in `in_value_a` .
+ * @param {unknown}a_nowrap
+ * @returns {unknown}
+ */
+export function and_(a_nowrap) {
+	const value_a = wrap_a_(a_nowrap)
+	for (let i = 0; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (!value) return value
+		if (typeof value === 'function') {
+			const out_fn_value = value()
+			if (!out_fn_value) return out_fn_value
+		}
+	}
+	return
+}
+export { and_ as and__fn }
+/**
+ * Returns function that returns the first falsy or last item function call or value in `in_value_a` .
+ * @param {unknown[]}in_value_a
+ * @returns {(fn_value_a:unknown[])=>unknown}
+ */
+export function and_2(in_value_a) {
+	return (fn_value_a)=>and_(wrap_concat(in_value_a, fn_value_a))
+}
+export {
+	and_2 as _and_fn,
+	and_2 as _and__fn,
+}

package/all/and/index.test.ts

@@ -0,0 +1,10 @@
+import { test } from 'uvu'
+import { is } from 'uvu/assert'
+import { and } from '../and/index.js'
+test('and', ()=>{
+	const obj = { obj: 1 }
+	const obj2 = { obj2: 1 }
+	const obj3 = { obj3: 1 }
+	is(obj3, and([obj, obj2, obj3]))
+})
+test.run()

package/all/and_call/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns a function than returns the called fn_a(value) chained with ands
+ */
+export declare function and_call_<
+	I extends unknown = unknown,
+	O extends unknown = unknown
+>(fn_a:((in_value:I)=>O)[]):and_fn_call_T<I, O>;
+export declare type and_fn_call_T<
+	I extends unknown = unknown,
+	O extends unknown = unknown
+> = (in_value:I)=>O|null
+export {
+	and_call_ as and_fn_call_fn,
+	and_call_ as _and_fn_call,
+	and_call_ as _and__fn__call,
+}

package/all/and_call/index.js

@@ -0,0 +1,20 @@
+/**
+ * Returns a function than returns the called fn_a(value) chained with ands
+ * @param {unknown[]}fn_a
+ * @returns {(fn_value_a:unknown[])=>unknown}
+ */
+export function and_call_(fn_a) {
+	return in_value=>{
+		let out_value = null
+		for (const fn of fn_a) {
+			out_value = fn(in_value)
+			if (!out_value) return out_value
+		}
+		return out_value
+	}
+}
+export {
+	and_call_ as and_fn_call_fn,
+	and_call_ as _and_fn_call,
+	and_call_ as _and__fn__call,
+}

package/all/andand/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Applies `&&` to a chain of properties from `obj`.
+ */
+export declare function andand<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+>(obj:Val, ...name_a:andand_key_T<Val>[]):Out|null
+export declare type andand_key_T<
+	Val extends unknown = unknown
+> = keyof Val|andand_key__T<Val>
+export declare type andand_key__T<
+	Val extends unknown = unknown
+> = (val:Val)=>keyof Val
+export declare type andand_key_fn_T = andand_key__T