ctx-core 2.2.0 → 2.2.2

package/all/omit/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * New `obj` without `key_a` keys.
+ */
+export declare function omit<
+	I extends object = object
+>(obj:I, ...key_a:string[]):I|undefined
+/**
+ * Returns a function that calls [omit](#omit) with the given `...in_key_a`
+ */
+export declare function omit_<
+	T extends object = object
+>(
+	...in_key_a:string[]
+):(obj:T, ...fn_key_a:string[])=>T|undefined
+export { omit_ as _omit, }

package/all/omit/index.js

@@ -0,0 +1,26 @@
+/**
+ * New `obj` without `key_a` keys.
+ * @param {object}obj
+ * @param {string}key_a
+ * @returns {object|undefined}
+ */
+export function omit(obj, ...key_a) {
+	if (!obj) return
+	let memo = {}
+	for (const key in obj) {
+		if (!~key_a.indexOf(key)) {
+			memo[key] = obj[key]
+		}
+	}
+	return memo
+}
+/**
+ * Returns a function that calls [omit](#omit) with the given `...in_key_a`
+ * @param {string}in_key_a
+ * @returns {(obj:object, ...fn_key_a:string[])=>object|undefined}
+ * @private
+ */
+export function omit_(...in_key_a) {
+	return (obj, ...fn_key_a)=>omit(obj, ...in_key_a, ...fn_key_a)
+}
+export { omit_ as _omit, }

package/all/omit/index.test.ts

@@ -0,0 +1,12 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { omit } from '../omit/index.js'
+test('omit', ()=>{
+	const o = {
+		foo: 1,
+		bar: 1,
+		baz: 1,
+	}
+	equal(omit(o, 'bar', 'baz'), { foo: 1 })
+})
+test.run()

package/all/one_andand/index.d.ts

@@ -0,0 +1,13 @@
+import type { andand_key_T } from '../andand/index.js'
+/**
+ * Returns a function that calls `andand(obj, ...name_a)`
+ */
+export declare function one_andand_<
+	Val extends unknown = unknown, Out extends unknown = unknown
+>(...name_a:andand_key_T<Val>[]):(obj:Val)=>Out|null
+export {
+	one_andand_ as andand_,
+	one_andand_ as _one_andand,
+	one_andand_ as _andand,
+	one_andand_ as _andand__one,
+}

package/all/one_andand/index.js

@@ -0,0 +1,15 @@
+import { andand } from '../andand/index.js'
+/**
+ * Returns a function that calls `andand(obj, ...name_a)`
+ * @param {import('../andand/index.js').andand_key_T}name_a
+ * @returns {(obj:unknown)=>unknown}
+ */
+export function one_andand_(...name_a) {
+	return obj=>andand(obj, ...name_a)
+}
+export {
+	one_andand_ as andand_,
+	one_andand_ as _one_andand,
+	one_andand_ as _andand,
+	one_andand_ as _andand__one,
+}

package/all/one_andand_or/index.d.ts

@@ -0,0 +1,19 @@
+import type { andand_key_T } from '../andand/index.js'
+import type { andand_or_T } from '../andand_or/index.js'
+/**
+ * Returns function that calls `andand_or(obj, name_a, or_fn)`
+ */
+export declare function one_andand_or_<
+	In extends unknown = unknown,
+	Out extends unknown = unknown
+>(
+	name_a:andand_key_T<In>[], or_:andand_or_T<In, Out>
+):(obj:In)=>Out
+export {
+	one_andand_or_ as andand_or_,
+	one_andand_or_ as _one_andand_or,
+	one_andand_or_ as _andand_or,
+	one_andand_or_ as _andand__or,
+	one_andand_or_ as _andand_or__one,
+	one_andand_or_ as _andand_or__or__one,
+}

package/all/one_andand_or/index.js

@@ -0,0 +1,18 @@
+import { andand_or } from '../andand_or/index.js'
+/**
+ * Returns function that calls `andand_or(obj, name_a, or_)`
+ * @param {import('../andand/index.js').andand_key_T[]}name_a
+ * @param {import('../andand_or/index.js').andand_or_T}or_
+ * @returns {(obj:unknown)=>unknown}
+ */
+export function one_andand_or_(name_a, or_) {
+	return (obj)=>andand_or(obj, name_a, or_)
+}
+export {
+	one_andand_or_ as andand_or_,
+	one_andand_or_ as _one_andand_or,
+	one_andand_or_ as _andand_or,
+	one_andand_or_ as _andand__or,
+	one_andand_or_ as _andand_or__one,
+	one_andand_or_ as _andand_or__or__one,
+}

package/all/or/index.d.ts

@@ -0,0 +1,41 @@
+import { a_nowrap_T } from '../a_nowrap/index.js'
+import type { wrap_a_T } from '../wrap_a/index.js'
+/**
+ * Returns first truthy or last item in `a_unwrap`.
+ */
+export declare function or<
+	Val extends unknown = unknown
+>(
+	a_unwrap:Val|wrap_a_T<Val>
+):Val|undefined
+/**
+ * Returns first truthy or last item call or value in `a_unwrap`.
+ */
+export declare function or_<
+	Val extends unknown,
+	Ret extends unknown
+>(a_unwrap:a_nowrap_T<Val>):or_T<Val, Ret>
+export interface or_fn_callable_T<I extends unknown = unknown> {
+	(...args:wrap_a_T<I>):I
+}
+export declare type or_T<Val extends unknown, Ret extends unknown> =
+	(Val extends or_fn_callable_T<Val> ? Ret : Val)
+	|undefined
+/**
+ * Returns function that returns first truthy or last item call or value in `a_unwrap`.
+ */
+export declare function or_fn_<
+	Val extends unknown,
+	Ret extends unknown
+>(
+	a_unwrap:a_nowrap_T<Val>
+):(val:Val)=>or_T<Val, Ret>
+export declare type or_fn_T<
+	Val extends unknown,
+	Ret extends unknown
+> = (val:Val)=>or_T<Val, Ret>
+export {
+	or_ as on__fn,
+	or_fn_ as _or__fn,
+	or_fn_ as _fn__or__fn,
+}

package/all/or/index.js

@@ -0,0 +1,47 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns first truthy or last item in `a_unwrap`.
+ * @param {unknown|import('../_function_types/index.js').wrap_a_T}a_unwrap
+ * @returns {unknown}
+ */
+export function or(a_unwrap) {
+	const value_a = wrap_a_(a_unwrap)
+	for (let i = 0; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (value) return value
+	}
+	return
+}
+/** @typedef {import('../a_nowrap/index.d.ts').a_nowrap_T}a_nowrap_T */
+/** @typedef {import('./index.d.ts').or_T}or_T */
+/**
+ * Returns first truthy or last item call or value in `a_unwrap`.
+ * @param {a_nowrap_T}a_unwrap
+ * @returns {or_T}
+ */
+export function or_(a_unwrap) {
+	const value_a = wrap_a_(a_unwrap)
+	for (let i = 0; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (!value) continue
+		const fn_value = typeof value === 'function' ? value() : value
+		if (fn_value) return fn_value
+	}
+	return
+}
+export {
+	or_ as on__fn,
+}
+/**
+ * Returns function that returns first truthy or last item call or value in `a_unwrap`.
+ * @param {a_nowrap_T}a_unwrap
+ * @returns {(val:unknown)=>or_T}
+ */
+export function or_fn_(a_unwrap) {
+	return (val)=>or_(wrap_concat(a_unwrap, val))
+}
+export {
+	or_fn_ as _or__fn,
+	or_fn_ as _fn__or__fn,
+}

package/all/or_in/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns first obj property in the obj
+ */
+export declare function or_in<
+	obj_T extends object = object
+>(
+	obj:obj_T, name_a:string[]
+):string|undefined
+export { or_in as or__in }

package/all/or_in/index.js

@@ -0,0 +1,14 @@
+/**
+ * Returns first obj property in the obj
+ * @param {object}obj
+ * @param {string[]}name_a
+ * @returns {string|undefined}
+ */
+export function or_in(obj, name_a) {
+	for (let i = 0; i < name_a.length; i++) {
+		const name = name_a[i]
+		if (name in obj) return name
+	}
+	return
+}
+export { or_in as or__in }

package/all/or_null/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * return the `value` if not null or `or_value`
+ */
+export declare function or_null(opts?:or_null__opts_T):any
+export { or_null as or__null }
+export interface or_null__opts_T {
+	value?:any
+	or_value?:any
+	nor_value?:any
+}
+export declare type opts_or = or_null__opts_T

package/all/or_null/index.js

@@ -0,0 +1,10 @@
+/**
+ * return the `value` if not null or `or_value`
+ * @param {import('../or_null/index.js').or_null__opts_T}opts
+ * @returns {unknown}
+ */
+export function or_null(opts = {}) {
+	const { value, or_value, nor_value } = opts
+	return value == null ? or_value : nor_value || value
+}
+export { or_null as or__null }

package/all/or_property/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns first obj property that is truthy
+ */
+export declare function or_property<
+	I extends unknown = unknown
+>(
+	obj:I, name_a:string[]
+):I[keyof I]|undefined
+export { or_property as or__property }

package/all/or_property/index.js

@@ -0,0 +1,15 @@
+/**
+ * Returns first obj property that is truthy
+ * @param {unknown}obj
+ * @param {string[]}name_a
+ * @returns {unknown}
+ */
+export function or_property(obj, name_a) {
+	for (let i = 0; i < name_a.length; i++) {
+		const name = name_a[i]
+		const value = obj[name]
+		if (value) return value
+	}
+	return
+}
+export { or_property as or__property }

package/all/pad2/index.d.ts

@@ -0,0 +1 @@
+export declare function pad2(n:number):string

package/all/pad2/index.js

@@ -0,0 +1,7 @@
+/**
+ * @param {number}n
+ * @returns {string}
+ */
+export function pad2(n) {
+	return (n < 10 ? '0' : '') + n
+}

package/all/parseFloat_andor/index.d.ts

@@ -0,0 +1,3 @@
+export declare function parseFloat_andor_<And_Val, Or_Val>(
+	val:any, and_val_?:(val:any)=>And_Val, or_val_?:(val:any)=>Or_Val
+):And_Val|Or_Val

package/all/parseFloat_andor/index.js

@@ -0,0 +1,5 @@
+import { isFloat_andor_ } from '../isFloat_andor/index.js'
+import { null_ } from '../null/index.js'
+export function parseFloat_andor_(val, and_val_ = $=>$, or_val_ = null_) {
+	return isFloat_andor_(parseFloat(val), and_val_, or_val_)
+}

package/all/parseFloat_andor/index.test.ts

@@ -0,0 +1,11 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { null_ } from '../null/index.js'
+import { parseFloat_andor_ } from '../parseFloat_andor/index.js'
+test('parseFloat_andor_', ()=>{
+	equal(parseFloat_andor_('12.3'), 12.3)
+	equal(parseFloat_andor_('12.3', $=>$ * 2), 12.3 * 2)
+	equal(parseFloat_andor_('not-a-number', $=>$, null_), null)
+	equal(parseFloat_andor_('not-a-number', $=>$, $=>$), NaN)
+})
+test.run()

package/all/parseFloat_or/index.d.ts

@@ -0,0 +1 @@
+export declare function parseFloat_or_<Or_Val>(val:any, or_val_?:(val:any)=>Or_Val):any

package/all/parseFloat_or/index.js

@@ -0,0 +1,5 @@
+import { isNumber_or_ } from '../isNumber_or/index.js'
+import { null_ } from '../null/index.js'
+export function parseFloat_or_(val, or_val_ = null_) {
+	return isNumber_or_(parseFloat(val), or_val_)
+}

package/all/parseFloat_or/index.test.ts

@@ -0,0 +1,9 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { null_ } from '../null/index.js'
+import { parseFloat_or_ } from '../parseFloat_or/index.js'
+test('parseFloat_or_', ()=>{
+	equal(parseFloat_or_('12.3', null_), 12.3)
+	equal(parseFloat_or_('not-a-number', null_), null)
+})
+test.run()

package/all/parseInt_andor/index.d.ts

@@ -0,0 +1,5 @@
+export declare function parseInt_andor_<And_Val, Or_Val>(
+	val:any,
+	and_val_?:(val:number)=>And_Val,
+	or_val_?:(val:any)=>Or_Val
+):number

package/all/parseInt_andor/index.js

@@ -0,0 +1,5 @@
+import { isNumber_andor_ } from '../isNumber_andor/index.js'
+import { null_ } from '../null/index.js'
+export function parseInt_andor_(val, and_val_, or_val_ = null_) {
+	return isNumber_andor_(parseInt(val), and_val_, or_val_)
+}

package/all/parseInt_andor/index.test.ts

@@ -0,0 +1,11 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { null_ } from '../null/index.js'
+import { parseInt_andor_ } from '../parseInt_andor/index.js'
+test('parseInt_andor_', ()=>{
+	equal(parseInt_andor_('11'), 11)
+	equal(parseInt_andor_('11', $=>$ * 2, null_), 22)
+	equal(parseInt_andor_('12.3'), 12)
+	equal(parseInt_andor_('not-a-number', $=>$, $=>$), NaN)
+})
+test.run()

package/all/parseInt_or/index.d.ts

@@ -0,0 +1 @@
+export declare function parseInt_or_<Or_Val>(val:any, or_val_?:(val:any)=>Or_Val):any

package/all/parseInt_or/index.js

@@ -0,0 +1,5 @@
+import { isNumber_or_ } from '../isNumber_or/index.js'
+import { null_ } from '../null/index.js'
+export function parseInt_or_(val, or_val_ = null_) {
+	return isNumber_or_(parseInt(val), or_val_)
+}

package/all/parseInt_or/index.test.ts

@@ -0,0 +1,10 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { null_ } from '../null/index.js'
+import { parseInt_or_ } from '../parseInt_or/index.js'
+test('parseInt_or_', ()=>{
+	equal(parseInt_or_('11', null_), 11)
+	equal(parseInt_or_('12.3', null_), 12)
+	equal(parseInt_or_('not-a-number', null_), null)
+})
+test.run()

package/all/pathname/index.d.ts

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

package/all/pathname/index.js

@@ -0,0 +1,8 @@
+/**
+ * @returns {string}
+ */
+export function pathname_() {
+	const pathname = typeof window === 'object' && window.location.pathname || ''
+	return pathname
+}
+export { pathname_ as _pathname, }

package/all/percentage_str/index.d.ts

@@ -0,0 +1,2 @@
+export declare function percentage_str_(number:number):string
+export { percentage_str_ as _percentage_str, percentage_str_ as format__percentage, }

package/all/percentage_str/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {number}number
+ * @returns {string}
+ * @private
+ */
+export function percentage_str_(number) {
+	return `${number}%`
+}
+export { percentage_str_ as _percentage_str, percentage_str_ as format__percentage, }

package/all/percentage_str_float/index.d.ts

@@ -0,0 +1,2 @@
+export declare function percentage_str_float_(percentage:string):number
+export { percentage_str_float_ as _percentage_str_float, percentage_str_float_ as unformat__percentage, }

package/all/percentage_str_float/index.js

@@ -0,0 +1,4 @@
+export function percentage_str_float_(percentage) {
+	return parseFloat(percentage.replace(/%/g, ''))
+}
+export { percentage_str_float_ as _percentage_str_float, percentage_str_float_ as unformat__percentage, }

package/all/performance__now/index.d.ts

@@ -0,0 +1 @@
+export declare const performance__now_:()=>number

package/all/performance__now/index.js

@@ -0,0 +1,32 @@
+const has_performance = typeof performance !== 'undefined'
+const has_process = typeof process !== 'undefined'
+const has_hrtime = has_process && typeof process['hrtime'] !== 'undefined'
+const has_Date_now = typeof Date.now !== 'undefined'
+const load_time =
+	has_performance
+		? performance.now()
+		: has_hrtime
+			? getNanoSeconds()
+			: has_Date_now
+				? Date.now()
+				: new Date().getTime()
+/** @type {typeof import('./index.d.ts').performance__now_} */
+export const performance__now_ =
+	has_performance
+		? ()=>performance.now()
+		: has_hrtime
+			? ()=>{
+				const up_time = process.uptime() * 1000000000
+				const node_load_time = load_time - up_time
+				return (getNanoSeconds() - node_load_time) / 1000000
+			}
+			: has_Date_now
+				? ()=>Date.now() - load_time
+				: ()=>new Date().getTime() - load_time
+export {
+	performance__now_ as performance_now,
+}
+function getNanoSeconds() {
+	const hr = process.hrtime()
+	return hr[0] * 1000000000 + hr[1]
+}

package/all/pick/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * New `obj` with only `key_a` keys.
+ */
+export declare function pick<
+	I extends object = object
+>(obj:I, ...key_a:string[]):Partial<I>
+export declare function maybe_pick<
+	I extends object = object
+>(obj:I, ...key_a:string[]):Partial<I>|unknown
+/**
+ * Returns a function that calls [pick](#pick) with the given `...in_key_a`
+ */
+export declare function pick_<
+	I extends object = object
+>(
+	...in_key_a:string[]
+):(obj:I, ...fn_key_a:string[])=>Partial<I>
+export { pick_ as _pick, }

package/all/pick/index.js

@@ -0,0 +1,35 @@
+/**
+ * New `obj` with only `key_a` keys.
+ * @param {object}obj
+ * @param {string}key_a
+ * @returns {object}
+ */
+export function pick(obj, ...key_a) {
+	const memo = {}
+	for (let i = 0; i < key_a.length; i++) {
+		const key = key_a[i]
+		if (key in obj) {
+			memo[key] = obj[key]
+		}
+	}
+	return memo
+}
+/**
+ * @param {object}obj
+ * @param {string}key_a
+ * @returns {object|unknown}
+ */
+export function maybe_pick(obj, ...key_a) {
+	if (!obj) return
+	return pick(obj, ...key_a)
+}
+/**
+ * Returns a function that calls [pick](#pick) with the given `...in_key_a`
+ * @param {string}in_key_a
+ * @returns {(obj:object, ...fn_key_a:string[])=>object}
+ * @private
+ */
+export function pick_(...in_key_a) {
+	return (obj, ...fn_key_a)=>pick(obj, ...in_key_a, ...fn_key_a)
+}
+export { pick_ as _pick, }

package/all/pick_keys/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Picks the keys on `in_key_obj` from `obj`
+ */
+export declare function pick_keys<
+	I extends object = object,
+	KEYS_OBJ extends object = object
+>(obj:I, in_key_obj:KEYS_OBJ):Partial<I>
+export { pick_keys as pick__keys }

package/all/pick_keys/index.js

@@ -0,0 +1,12 @@
+import { keys } from '../keys/index.js'
+import { pick } from '../pick/index.js'
+/**
+ * Picks the keys on `in_key_obj` from `obj`
+ * @param {object}obj
+ * @param {object}in_key_obj
+ * @returns {object}
+ */
+export function pick_keys(obj, in_key_obj) {
+	return pick(obj, ...keys(in_key_obj))
+}
+export { pick_keys as pick__keys }

package/all/pick_val_a/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns an array of objects with [pick](#pick) applied.
+ */
+export declare function pick_val_a_<
+	Obj extends object = object
+>(
+	obj:Obj,
+	...key_a:(keyof Obj)[]
+):Obj[keyof Obj][]|undefined
+export {
+	pick_val_a_ as pick_value_a_,
+	pick_val_a_ as _pick_value_a1,
+	pick_val_a_ as _a1__value__pick,
+}

package/all/pick_val_a/index.js

@@ -0,0 +1,22 @@
+/**
+ * Returns an array of objects with [pick](#pick) applied.
+ * @param {object}obj
+ * @param {string}key_a
+ * @returns {unknown[]|undefined}
+ * @private
+ */
+export function pick_val_a_(obj, ...key_a) {
+	if (!obj) return
+	const val_a = []
+	for (let i = 0; i < key_a.length; i++) {
+		const key = key_a[i]
+		const val = obj[key]
+		val_a.push(val)
+	}
+	return val_a
+}
+export {
+	pick_val_a_ as pick_value_a_,
+	pick_val_a_ as _pick_value_a1,
+	pick_val_a_ as _a1__value__pick,
+}

package/all/prev_idx/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns Index of the previous item, circular wrapping to the end (`length - 1`).
+ */
+export declare function prev_idx_(length:number, index?:number):number
+export {
+	prev_idx_ as _prev_idx,
+	prev_idx_ as _idx__prev,
+}

package/all/prev_idx/index.js

@@ -0,0 +1,14 @@
+import { circular_idx_ } from '../circular_idx/index.js'
+/**
+ * Returns Index of the previous item, circular wrapping to the end (`length - 1`).
+ * @param {number}length
+ * @param {number}index
+ * @returns {number}
+ */
+export function prev_idx_(length, index = 0) {
+	return circular_idx_(length, index - 1)
+}
+export {
+	prev_idx_ as _prev_idx,
+	prev_idx_ as _idx__prev,
+}

package/all/promise/index.d.ts

@@ -0,0 +1,2 @@
+export declare type promise_resolve_T<T> = (value:T|PromiseLike<T>)=>void
+export declare type promise_reject_T = (reason?:any)=>void

package/all/promise/index.js

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

package/all/promise_o/index.d.ts

@@ -0,0 +1,7 @@
+import type { promise_reject_T, promise_resolve_T } from '../promise/index.js'
+export declare function promise_o_<T>():promise_o_T<T>
+export interface promise_o_T<T> {
+	promise:Promise<T>
+	resolve:promise_resolve_T<T>
+	reject:promise_reject_T
+}

package/all/promise_o/index.js

@@ -0,0 +1,11 @@
+/**
+ * @returns {import('../promise_o/index.js').promise_o_T}
+ */
+export function promise_o_() {
+	let resolve = null, reject = null
+	const promise = new Promise((in_resolve, in_reject)=>{
+		resolve = in_resolve
+		reject = in_reject
+	})
+	return { promise, resolve, reject, }
+}

package/all/promise_timeout/index.d.ts

@@ -0,0 +1,5 @@
+export declare function promise_timeout<
+	O extends unknown = unknown
+>(
+	promise:(()=>Promise<O>)|Promise<O>, ms:number, error?:Error
+):Promise<O>