ctx-core 2.2.0 → 2.2.1

package/all/ctx/index.test.ts

@@ -0,0 +1,16 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { ctx__new, is_ctx_ } from '../ctx/index.js'
+test('is_ctx_', ()=>{
+	const ctx0 = ctx__new()
+	const ctx1 = ctx__new()
+	const ctx2 = ctx__new()
+	const not_ctx = {}
+	equal(is_ctx_(ctx0), true)
+	equal(is_ctx_([ctx0, [ctx1], [[ctx2]]]), true)
+	equal(is_ctx_([[[ctx0]]]), true)
+	equal(is_ctx_([ctx0, [ctx1], [[[]]]]), true)
+	equal(is_ctx_(not_ctx), false)
+	equal(is_ctx_([ctx0, [ctx1], [[ctx2]], [not_ctx]]), false)
+})
+test.run()

package/all/currencies/index.d.ts

@@ -0,0 +1,3 @@
+export declare const currencies:currencies_T
+export interface currencies_T extends Record<string, string> {
+}

package/all/currencies/index.js

@@ -0,0 +1,120 @@
+export const currencies = {
+	ALL: 'L',
+	AFN: '؋',
+	ARS: '$',
+	AWG: 'ƒ',
+	AUD: '$',
+	AZN: '₼',
+	BSD: '$',
+	BBD: '$',
+	BYR: 'p.',
+	BZD: 'BZ$',
+	BMD: '$',
+	BOB: 'Bs.',
+	BAM: 'KM',
+	BWP: 'P',
+	BGN: 'лв',
+	BRL: 'R$',
+	BND: '$',
+	KHR: '៛',
+	CAD: '$',
+	KYD: '$',
+	CLP: '$',
+	CNY: '¥',
+	COP: '$',
+	CRC: '₡',
+	HRK: 'kn',
+	CUP: '₱',
+	CZK: 'Kč',
+	DKK: 'kr',
+	DOP: 'RD$',
+	XCD: '$',
+	EGP: '£',
+	SVC: '$',
+	EEK: 'kr',
+	EUR: '€',
+	FKP: '£',
+	FJD: '$',
+	GHC: '₵',
+	GIP: '£',
+	GTQ: 'Q',
+	GGP: '£',
+	GYD: '$',
+	HNL: 'L',
+	HKD: '$',
+	HUF: 'Ft',
+	ISK: 'kr',
+	INR: '₹',
+	IDR: 'Rp',
+	IRR: '﷼',
+	IMP: '£',
+	ILS: '₪',
+	JMD: 'J$',
+	JPY: '¥',
+	JEP: '£',
+	KES: 'KSh',
+	KPW: '₩',
+	KRW: '₩',
+	KGS: 'лв',
+	LAK: '₭',
+	LVL: 'Ls',
+	LBP: '£',
+	LRD: '$',
+	LTL: 'Lt',
+	MKD: 'ден',
+	MYR: 'RM',
+	MUR: '₨',
+	MXN: '$',
+	MNT: '₮',
+	MZN: 'MT',
+	NAD: '$',
+	NPR: '₨',
+	ANG: 'ƒ',
+	NZD: '$',
+	NIO: 'C$',
+	NGN: '₦',
+	NOK: 'kr',
+	OMR: '﷼',
+	PKR: '₨',
+	PAB: 'B/.',
+	PYG: 'Gs',
+	PEN: 'S/.',
+	PHP: '₱',
+	PLN: 'zł',
+	QAR: '﷼',
+	RON: 'lei',
+	RUB: '₽',
+	RMB: '￥',
+	SHP: '£',
+	SAR: '﷼',
+	RSD: 'Дин.',
+	SCR: '₨',
+	SGD: '$',
+	SBD: '$',
+	SOS: 'S',
+	ZAR: 'R',
+	LKR: '₨',
+	SEK: 'kr',
+	CHF: 'CHF',
+	SRD: '$',
+	SYP: '£',
+	TZS: 'TSh',
+	TWD: 'NT$',
+	THB: '฿',
+	TTD: 'TT$',
+	TRY: '₺',
+	TRL: '₤',
+	TVD: '$',
+	UGX: 'USh',
+	UAH: '₴',
+	GBP: '£',
+	USD: '$',
+	UYU: '$U',
+	UZS: 'лв',
+	VEF: 'Bs',
+	VND: '₫',
+	YER: '﷼',
+	ZWD: 'Z$',
+	GEL: '₾',
+	KZT: '₸'
+}

package/all/currency_code/index.d.ts

@@ -0,0 +1,4 @@
+export interface currency_code_o_T {
+	currency_code?:string
+	currency?:string
+}

package/all/currency_code/index.js

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

package/all/currency_str/index.d.ts

@@ -0,0 +1,23 @@
+export declare function currency_str_(
+	amount:string|number,
+	params?:currency_str__default_params_T|string
+):string
+export {
+	currency_str_ as _currency_str,
+	currency_str_ as format__currency,
+}
+export interface currency_str__default_params_T {
+	default?:string
+	currency_code?:string
+	currency?:string
+	digits?:number
+}
+export declare type currency_str_default_params_I = currency_str__default_params_T
+export declare function currency_str__(
+	params?:currency_str__default_params_T|string
+):(amount:number)=>string
+export {
+	currency_str__ as currency_str_2,
+	currency_str__ as _currency_str_fn,
+	currency_str__ as _format__currency,
+}

package/all/currency_str/index.js

@@ -0,0 +1,38 @@
+import { currency_symbol_ } from '../currency_symbol/index.js'
+import { money_str_ } from '../money_str/index.js'
+/**
+ * Formats currency to USD ($) with commas
+ * @param {string|number}amount
+ * @param {import('./index').currency_str__default_params_T|string}params
+ * @returns {string} * @example
+ * currency_str_(1000000) // $1,000,000.00
+ * @example
+ * currency_str_(1000000, {digits: 0}) // $1,000,000
+ */
+export function currency_str_(
+	amount,
+	params
+) {
+	const amount_num = parseFloat(amount)
+	return (
+		Number.isNaN(amount_num)
+			? params && params.default || ''
+			: `${currency_symbol_(params)}${money_str_(amount_num, params)}`
+	)
+}
+export {
+	currency_str_ as _currency_str,
+	currency_str_ as format__currency,
+}
+/**
+ * @param {import('../currency_str').currency_str__default_params_T|string}params
+ * @returns {(amount:number)=>string}
+ */
+export function currency_str__(params) {
+	return amount=>currency_str_(amount, params)
+}
+export {
+	currency_str__ as currency_str_2,
+	currency_str__ as _currency_str_fn,
+	currency_str__ as _format__currency,
+}

package/all/currency_symbol/index.d.ts

@@ -0,0 +1,8 @@
+import type { currency_code_o_T } from '../currency_code/index.js'
+export declare function currency_symbol_(
+	currency_code_?:currency_code_o_T|string
+):string
+export {
+	currency_symbol_ as _currency_symbol,
+	currency_symbol_ as _symbol__currency,
+}

package/all/currency_symbol/index.js

@@ -0,0 +1,19 @@
+import { currencies } from '../currencies/index.js'
+/**
+ * Returns the symbol for the given `currency_code_.currency`. Defaults to `$`
+ * @param {import('../currency_code').currency_code_o_T|string}currency_code_
+ * @returns {string} * @see {@link https://github.com/bengourley/currency-symbol-map}
+ * @see {@link https://raw.githubusercontent.com/bengourley/currency-symbol-map/master/map.js}
+ */
+export function currency_symbol_(currency_code_) {
+	const currency_code =
+		currency_code_
+		&& (currency_code_.currency_code || currency_code_.currency)
+		|| currency_code_
+	const currency_symbol = currencies[currency_code] || '$'
+	return currency_symbol
+}
+export {
+	currency_symbol_ as _currency_symbol,
+	currency_symbol_ as _symbol__currency,
+}

package/all/curry/index.d.ts

@@ -0,0 +1,14 @@
+import type { append_current_T, resolver_curry_T } from '../resolver_curry/index.js'
+export declare function curry<
+	ResolverArg extends unknown = unknown
+>(append:append_current_T<ResolverArg>):resolver_curry_T<ResolverArg>
+/**
+ * @param append
+ * @returns {function(*=): *}
+ * @see {@link https://medium.com/@kevincennis/currying-in-javascript-c66080543528}
+ */
+export declare function curry_<
+	ResolverArg extends unknown = unknown
+>(
+	append:append_current_T<ResolverArg>
+):(fn:Function)=>resolver_curry_T<ResolverArg>

package/all/curry/index.js

@@ -0,0 +1,32 @@
+/**
+ * @param append{import('../resolver_curry/index.js').append_current_T}
+ * @returns {import('../resolver_curry/index.js').resolver_curry_T}
+ */
+export function curry(append) {
+	return curry_((local, arg_a)=>Array.prototype.push.apply(local, arg_a))(append)
+}
+/**
+ * @param append{import('../resolver_curry/index.js').append_current_T}
+ * @returns {(fn:Function)=>import('../resolver_curry/index.js').resolver_curry_T}
+ * @see {@link https://medium.com/@kevincennis/currying-in-javascript-c66080543528}
+ */
+export function curry_(append) {
+	return (fn)=>{
+		const arity = fn.length
+		return resolver
+		function resolver(...resolver_arg_a) {
+			const memory = Array.prototype.slice.call(resolver_arg_a)
+			return resolver2
+			function resolver2(...arg_a) {
+				const local = memory.slice()
+				const remaining = Math.max(arity - local.length, 0)
+				append(local, arg_a.slice(0, remaining))
+				const next =
+					local.length >= arity
+						? fn
+						: resolver
+				return next(...local)
+			}
+		}
+	}
+}

package/all/date/index.d.ts

@@ -0,0 +1,15 @@
+export declare const date_:Date__T
+export interface Date__T {
+	():Date
+	(value:number|string|Date):Date
+	(
+		year:number,
+		month:number,
+		date?:number,
+		hours?:number,
+		minutes?:number,
+		seconds?:number,
+		ms?:number
+	):Date
+}
+export { date_ as _date, }

package/all/date/index.js

@@ -0,0 +1,5 @@
+/** @type {typeof import('../date/index.d.ts').date_} */
+export const date_ =
+	(...arg_a)=>
+		new Date(/** @type {any} */...arg_a)
+export { date_ as _date, }

package/all/date_append_local_tz/index.d.ts

@@ -0,0 +1,2 @@
+export declare function date_append_local_tz_(date_txt:string):Date
+export { date_append_local_tz_ as _date_append_local_tz, }

package/all/date_append_local_tz/index.js

@@ -0,0 +1,9 @@
+import { toLocalDateString } from '../toLocalDateString/index.js'
+/**
+ * @param {string}date_txt
+ * @returns {Date}
+ */
+export function date_append_local_tz_(date_txt) {
+	return new Date(`${date_txt} (${toLocalDateString()})`)
+}
+export { date_append_local_tz_ as _date_append_local_tz, }

package/all/day/index.d.ts

@@ -0,0 +1,7 @@
+export declare const day_ms:number
+export declare const day_sec:number
+export {
+	day_ms as day,
+	day_ms as day_milliseconds,
+	day_ms as milliseconds__day
+}

package/all/day/index.js

@@ -0,0 +1,8 @@
+import { hour_ms, hour_sec } from '../hour/index.js'
+export const day_ms = 24 * hour_ms
+export const day_sec = 24 * hour_sec
+export {
+	day_ms as day,
+	day_ms as day_milliseconds,
+	day_ms as milliseconds__day
+}

package/all/day_seconds/index.d.ts

@@ -0,0 +1,2 @@
+export declare const day_seconds = 86400
+export { day_seconds as seconds__day }

package/all/day_seconds/index.js

@@ -0,0 +1,2 @@
+export const day_seconds = 86400
+export { day_seconds as seconds__day }

package/all/debounce/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns an async function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed, trigger the function on the
+ * leading edge, instead of the trailing.
+ * @see {@link https://davidwalsh.name/javascript-debounce-function}
+ */
+export declare function debounce<
+	Out extends unknown = unknown, Args extends any[] = []
+>(
+	func:(...args:Args)=>Out, wait:number, immediate?:boolean
+):(this:unknown, ...args:Args)=>Out
+export declare function debounce<
+	Out extends unknown = unknown, Args extends any[] = []
+>(
+	func:(...args:Args)=>Promise<Out>, wait:number, immediate?:boolean
+):(this:unknown, ...args:Args)=>Promise<Out>
+export declare function debounce<
+	Out extends unknown = unknown, Args extends any[] = []
+>(
+	func:(...args:Args)=>Out|Promise<Out>, wait:number, immediate?:boolean
+):(this:unknown, ...args:Args)=>Out|Promise<Out>

package/all/debounce/index.js

@@ -0,0 +1,44 @@
+import { isPromise } from '../isPromise/index.js'
+/**
+ * Returns an async function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed, trigger the function on the
+ * leading edge, instead of the trailing.
+ * @param {(...args:unknown[])=>unknown}func
+ * @param {number}wait
+ * @param {boolean}[immediate]
+ * @returns {(this:unknown, ...args:unknown[])=>(unknown|Promise<unknown>)}
+ * @see {@link https://davidwalsh.name/javascript-debounce-function}
+ */
+export function debounce(func, wait, immediate) {
+	let timeout, promise, resolve, reject
+	return async function(...arg_a) {
+		if (!promise) promise = new Promise((in_resolve, in_reject)=>{
+			resolve = in_resolve
+			reject = in_reject
+		})
+		const apply_this = this
+		const later = async ()=>{
+			timeout = null
+			promise = null
+			if (!immediate) {
+				await invoke()
+			}
+		}
+		const callNow = immediate && !timeout
+		clearTimeout(timeout)
+		timeout = setTimeout(later, wait)
+		if (callNow) {
+			await invoke()
+		}
+		return promise
+		async function invoke() {
+			try {
+				const in_rv = func.apply(apply_this, arg_a)
+				resolve(isPromise(in_rv) ? await in_rv : in_rv)
+			} catch (e) {
+				reject(e)
+			}
+		}
+	}
+}

package/all/debounce_mapreduce/index.d.ts

@@ -0,0 +1,6 @@
+export function debounce_mapreduce<A, MapVal>(
+	arg_:()=>A,
+	map:(arg_a:A)=>Promise<MapVal>,
+	arg_match_:(v0_arg:A, v1_arg:A)=>boolean,
+	reduce:(val:MapVal, arg_a:A)=>void
+):Promise<void>

package/all/debounce_mapreduce/index.js

@@ -0,0 +1,18 @@
+/**
+ * @template A
+ * @template MapVal
+ * @param {()=>A}arg_
+ * @param {(arg_a:A)=>Promise<MapVal>}map
+ * @param {(v0_arg:A, v1_arg:A)=>boolean}arg_match_
+ * @param {(val:MapVal, arg_a:A)=>void}reduce
+ * @returns {Promise<void>}
+ */
+export async function debounce_mapreduce(
+	arg_, map, arg_match_, reduce
+) {
+	const arg = arg_()
+	const map_val = await map(arg)
+	if (arg_match_(arg, arg_())) {
+		reduce(map_val, arg)
+	}
+}

package/all/debounce_mapreduce/index.test.ts

@@ -0,0 +1,26 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { debounce_mapreduce } from '../debounce_mapreduce/index.js'
+import { eql_a_ } from '../eql_a/index.js'
+test('debounce_mapreduce: match', async ()=>{
+	const arg_ = ()=>[0, 1, 2]
+	let reduce_called = false
+	await debounce_mapreduce(
+		arg_,
+		async $a=>$a[0] + $a[1] + $a[2],
+		(v0, v1)=>eql_a_(v0, v1),
+		()=>reduce_called = true)
+	equal(reduce_called, true)
+})
+test('debounce_mapreduce: no match', async ()=>{
+	const arg_aa = [[0, 1, 2], [0, 1, 3]]
+	const arg_ = ()=>arg_aa.shift() as number[]
+	let reduce_called = false
+	await debounce_mapreduce(
+		arg_,
+		async $a=>$a[0] + $a[1] + $a[2],
+		(v0, v1)=>eql_a_(v0, v1),
+		()=>reduce_called = true)
+	equal(reduce_called, false)
+})
+test.run()

package/all/deep_clone/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Performs a deep clone of the value
+ */
+export declare function deep_clone(obj:unknown):any
+export { deep_clone as clone__deep }

package/all/deep_clone/index.js

@@ -0,0 +1,10 @@
+/**
+ * Performs a deep clone of the value
+ * @param {unknown}obj
+ * @returns {unknown}
+ */
+export function deep_clone(obj) {
+	if (obj === undefined) return obj
+	return JSON.parse(JSON.stringify(obj))
+}
+export { deep_clone as clone__deep }

package/all/defaults/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the obj with default values. If `obj[key] == null`, use `default[key]`
+ */
+export declare function defaults<
+	I extends object = object
+>(obj:I, ...defaults_a:Partial<I>[]):I

package/all/defaults/index.js

@@ -0,0 +1,14 @@
+import { clone } from '../clone/index.js'
+/**
+ * Returns the obj with default values. If `obj[key] == null`, use `default[key]`
+ * @param {object}obj
+ * @param {unknown}defaults_a
+ * @returns {unknown}
+ */
+export function defaults(obj, ...defaults_a) {
+	const defaults1 = clone(...defaults_a)
+	for (let key in obj) {
+		if (obj[key] == null) obj[key] = defaults1[key]
+	}
+	return obj
+}

package/all/deg_rad/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Degrees to Radians
+ */
+export declare function deg_rad_(deg:number):number
+export { deg_rad_ as _deg_rad, deg_rad_ as _rad__deg, }

package/all/deg_rad/index.js

@@ -0,0 +1,7 @@
+/**
+ * Degrees to Radians
+ */
+export function deg_rad_(deg) {
+	return deg * (Math.PI / 180)
+}
+export { deg_rad_ as _deg_rad, deg_rad_ as _rad__deg, }

package/all/diff_date/index.d.ts

@@ -0,0 +1 @@
+export declare function diff_date(diff:number):Date

package/all/diff_date/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {number}diff
+ * @returns {Date}
+ */
+export function diff_date(diff) {
+	const now = new Date()
+	now.setTime(now.valueOf() + diff)
+	return now
+}

package/all/difference_a/index.d.ts

@@ -0,0 +1,12 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+import type { wrap_aa_item_T } from '../wrap_aa_item/index.js'
+/**
+ * Returns the _difference of n arrays
+ * @see {@link http://www.2ality.com/2015/01/es6-set-operations.html}
+ */
+export declare function difference_a_<
+	I extends unknown = unknown
+>(aa_nowrap:a_nowrap_T<I>):wrap_aa_item_T<I>[]
+export {
+	difference_a_ as _difference__a1,
+}

package/all/difference_a/index.js

@@ -0,0 +1,15 @@
+import { difference_set_ } from '../difference_set/index.js'
+import { wrap_aa_ } from '../wrap_aa/index.js'
+/**
+ * Returns the difference of n arrays
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}aa_nowrap
+ * @returns {import('../wrap_aa/index.js').wrap_aa_T[]}
+ * @see {@link http://www.2ality.com/2015/01/es6-set-operations.html}
+ */
+export function difference_a_(aa_nowrap) {
+	const aa = wrap_aa_(aa_nowrap)
+	return Array.from(difference_set_(/** @type {unknown} */aa))
+}
+export {
+	difference_a_ as _difference__a1,
+}

package/all/difference_by/index.d.ts

@@ -0,0 +1,9 @@
+export declare function difference_by_<
+	I extends unknown = unknown, O extends unknown = unknown
+>(
+	aa_nowrap:I, by_?:(item:I)=>O
+):I[]
+export {
+	difference_by_ as _difference_by,
+	difference_by_ as _difference__by,
+}

package/all/difference_by/index.js

@@ -0,0 +1,30 @@
+import { wrap_aa_ } from '../wrap_aa/index.js'
+/**
+ * @param {unknown}aa_nowrap
+ * @param {(item:unknown)=>unknown}[by_]
+ * @returns {unknown[]}
+ */
+export function difference_by_(aa_nowrap, by_ = item=>item) {
+	const a2 = wrap_aa_(aa_nowrap)
+	const set = new Set()
+	const difference = []
+	const { length } = a2
+	for (let i_ = 0; i_ < length; i_++) {
+		const i = length - 1 - i_
+		const a = a2[i]
+		for (let j = 0; j < a.length; j++) {
+			const item = a[j]
+			const by = by_(item)
+			if (i) {
+				set.add(by)
+			} else if (!set.has(by)) {
+				difference.push(item)
+			}
+		}
+	}
+	return difference
+}
+export {
+	difference_by_ as _difference_by,
+	difference_by_ as _difference__by,
+}

package/all/difference_set/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a new set with a _difference of the array-like arguments.
+ * @see {@link http://www.2ality.com/2015/01/es6-set-operations.html}
+ */
+export declare function difference_set_<
+	I extends unknown = unknown
+>(
+	member_a_nowrap_a_nowrap:Set<I>
+):Set<I>
+export {
+	difference_set_ as set_difference_,
+	difference_set_ as _difference__set,
+}

package/all/difference_set/index.js

@@ -0,0 +1,23 @@
+import { union_set_ } from '../union_set/index.js'
+import { wrap_a_ } from '../wrap_a/index.js'
+/**
+ * Returns a new set with a _difference of the array-like arguments.
+ * @see {@link http://www.2ality.com/2015/01/es6-set-operations.html}
+ */
+export function difference_set_(member_a_nowrap_a_nowrap) {
+	const member_a_nowrap_a = wrap_a_(member_a_nowrap_a_nowrap)
+	const root_a_nowrap = member_a_nowrap_a[0]
+	const rest_a_nowrap_a = member_a_nowrap_a.slice(1)
+	const root_a = wrap_a_(root_a_nowrap)
+	const rest_set = union_set_(rest_a_nowrap_a)
+	let set_member_a = []
+	for (let i = 0; i < root_a.length; i++) {
+		const x = root_a[i]
+		if (!rest_set.has(x)) set_member_a.push(x)
+	}
+	return new Set(set_member_a)
+}
+export {
+	difference_set_ as set_difference_,
+	difference_set_ as _difference__set,
+}

package/all/digest__algorithm/index.d.ts

@@ -0,0 +1 @@
+export type digest__algorithm_T = 'SHA-1'|'SHA-256'|'SHA-384'|'SHA-512'|Algorithm

package/all/digest__algorithm/index.js

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