ctx-core 2.2.0 → 2.2.1

package/all/bind_map_apply/index.js

@@ -0,0 +1,19 @@
+import { bind_apply_ } from '../bind_apply/index.js'
+/** @typedef {import('../call/index.d.ts').call_fn_T} */
+/**
+ * Returns function returning map of calls to fn_a bound to self that applies arg_a with ...arg_a_
+ * @param {call_fn_T[]}fn_a
+ * @param {unknown}self
+ * @param {unknown}in_arg_a
+ * @returns {(...fn_arg_a:unknown[])=>unknown[]}
+ */
+export function bind_map_apply_(fn_a, self, in_arg_a) {
+	return (...fn_arg_a)=>
+		fn_a.map(fn=>
+			bind_apply_(fn, self, in_arg_a)(...fn_arg_a))
+}
+export {
+	bind_map_apply_ as _bind_map_apply,
+	bind_map_apply_ as bind_map_fn_apply_fn,
+	bind_map_apply_ as _apply__map__bind
+}

package/all/bind_map_call/index.d.ts

@@ -0,0 +1,18 @@
+import type { call_fn_T } from '../call/index.js'
+/**
+ * Returns function bound to self that returns a map of fn_al calls with ...fac_arg_a concat with ...fn_arg_a passed
+ * to function
+ */
+export declare function bind_map_call_<
+	A_inner extends unknown[] = unknown[],
+	A_outer extends unknown[] = unknown[],
+	Out extends unknown = unknown,
+	Self extends unknown = unknown
+>(
+	fn_a:call_fn_T<A_outer, Out>[], self:Self, ...fac_arg_a:A_outer
+):(...fn_arg_a:A_inner)=>A_outer
+export {
+	bind_map_call_ as _bind_map_call,
+	bind_map_call_ as bind_map_fn_call_fn,
+	bind_map_call_ as _call__map__bind,
+}

package/all/bind_map_call/index.js

@@ -0,0 +1,21 @@
+/** @typedef {import('../call/index.d.ts').call_fn_T} */
+/**
+ * Returns function bound to self that returns a map of fn_al calls with ...fac_arg_a concat with ...fn_arg_a passed
+ * to function
+ * @param {call_fn_T[]}fn_a
+ * @param {unknown}self
+ * @param {unknown}fac_arg_a
+ * @returns {(...fn_arg_a:unknown[])=>unknown}
+ */
+export function bind_map_call_(fn_a, self, ...fac_arg_a) {
+	return (...fn_arg_a)=>fn_a.map((fn)=>fn.call(self, ...[
+			...fac_arg_a,
+			...fn_arg_a
+		])
+	)
+}
+export {
+	bind_map_call_ as _bind_map_call,
+	bind_map_call_ as bind_map_fn_call_fn,
+	bind_map_call_ as _call__map__bind,
+}

package/all/btoa/index.d.ts

@@ -0,0 +1,3 @@
+export declare function btoa(decodedData:string):string
+export declare function btoa_():(decoded_data:string)=>string
+export { btoa_ as _btoa, }

package/all/btoa/index.js

@@ -0,0 +1,18 @@
+/**
+ * @param {string}str
+ * @returns {string}
+ */
+export function btoa(str) {
+	return (
+		globalThis['window']
+			? window.btoa(str)
+			: new Buffer(str).toString('base64')
+	)
+}
+/**
+ * @return {typeof import('../btoa').btoa}
+ */
+export function btoa_() {
+	return btoa
+}
+export { btoa_ as _btoa, }

package/all/btoa/index.test.ts

@@ -0,0 +1,7 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { btoa } from './index.js'
+test('btoa', ()=>{
+	equal(btoa('test'), 'dGVzdA==')
+})
+test.run()

package/all/btoa_Uint32Array/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * btoa helper functions
+ */
+export declare function btoa_Uint32Array_(b64:string):Uint32Array
+export {
+	btoa_Uint32Array_ as _btoa_Uint32Array,
+	btoa_Uint32Array_ as _Uint32Array__btoa,
+}

package/all/btoa_Uint32Array/index.js

@@ -0,0 +1,20 @@
+import { btoa_ } from '../btoa/index.js'
+/**
+ * btoa helper functions
+ */
+/** @type {typeof import('../btoa_Uint32Array/index.d.ts').btoa_Uint32Array_} */
+export const btoa_Uint32Array_ = b64=>{
+	const btoa = btoa_()
+	const $ = btoa(b64)
+	const { length } = $
+	/** @type {Uint32Array} */
+	let btoa_Uint32Array = new Uint32Array(length)
+	for (let i = 0; i < length; i++) {
+		btoa_Uint32Array[i] = $.charCodeAt(i)
+	}
+	return btoa_Uint32Array
+}
+export {
+	btoa_Uint32Array_ as _btoa_Uint32Array,
+	btoa_Uint32Array_ as _Uint32Array__btoa,
+}

package/all/buffer__base64/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare function buffer__base64_(buffer:ArrayBuffer|Buffer):string
+export {
+	buffer__base64_ as buffer_base64_,
+	buffer__base64_ as _buffer_base64,
+}

package/all/buffer__base64/index.js

@@ -0,0 +1,22 @@
+/**
+ * @param {ArrayBuffer|Buffer}buffer
+ * @return {string}
+ * @private
+ */
+export function buffer__base64_(buffer) {
+	if (globalThis['window']) {
+		let binary = ''
+		const bytes = new Uint8Array(buffer)
+		const len = bytes.byteLength
+		for (let i = 0; i < len; i++) {
+			binary += String.fromCharCode(bytes[i])
+		}
+		return window.btoa(binary)
+	} else {
+		return buffer.toString('base64')
+	}
+}
+export {
+	buffer__base64_ as buffer_base64_,
+	buffer__base64_ as _buffer_base64,
+}

package/all/buffer__hex/index.d.ts

@@ -0,0 +1 @@
+export declare function buffer__hex_(buffer:ArrayBuffer):string

package/all/buffer__hex/index.js

@@ -0,0 +1,14 @@
+/**
+ * Buffer to hex string:
+ * - convert buffer to byte array
+ * - convert bytes to hex string
+ * @param {ArrayBuffer}buffer
+ * @returns {string}
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest#converting_a_digest_to_a_hex_string
+ * @see https://lukasmurdock.com/web-hmac/
+ */
+export function buffer__hex_(buffer) {
+	return Array.from(new Uint8Array(buffer))
+		.map((b)=>b.toString(16).padStart(2, '0'))
+		.join('')
+}

package/all/call/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Calls the fn with ...arg_a.
+ */
+export declare function call<
+	A extends unknown[] = unknown[],
+	O extends unknown = unknown
+>(fn:call_fn_T<A, O>, ...arg_a:A):O
+/**
+ * Returns function that calls ...in_arg_a concat with ...fn_arg_a passed to function
+ */
+export declare function call_<
+	A_first extends unknown[] = unknown[],
+	A_second extends unknown[] = unknown[],
+	A extends unknown[] = [...A_first, ...A_second],
+	Out extends unknown = unknown
+>(fn:call_fn_T<A, Out>, ...in_arg_a:A_first):call_fn_T<A_second, Out>
+export { call_ as _call, }
+export declare type call_fn_T<
+	A extends readonly unknown[] = readonly unknown[],
+	O extends unknown = unknown
+> = (...args:A)=>O
+export declare type call_fn_type = call_fn_T

package/all/call/index.js

@@ -0,0 +1,23 @@
+/** @typedef {import('../call/index.d.ts').call_fn_T} */
+/**
+ * Calls the fn with ...arg_a.
+ * @param {call_fn_T}fn
+ * @param {unknown}arg_a
+ * @returns {unknown}
+ */
+export function call(fn, ...arg_a) {
+	return fn(...arg_a)
+}
+/**
+ * Returns function that calls ...in_arg_a concat with ...fn_arg_a passed to function
+ * @param {call_fn_T}fn
+ * @param {unknown}in_arg_a
+ * @returns {(fn:call_fn_T, ...in_arg_a:unknown[])=>call_fn_T}
+ */
+export function call_(fn, ...in_arg_a) {
+	return (...fn_arg_a)=>call(fn, ...[
+		...in_arg_a,
+		...fn_arg_a
+	])
+}
+export { call_ as _call, }

package/all/call_assign/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Assigns function calls into obj
+ */
+export declare function call_assign<
+	I extends unknown = unknown
+>(
+	obj:Record<string, I>,
+	...assign_fn_h_a:Record<string, assign_fn_T<I>>[]
+):Record<string, I>
+export declare type assign_fn_T<
+	I extends unknown = unknown
+> = (value:I, obj?:Record<string, I>, key?:string)=>I
+export { call_assign as assign__call }

package/all/call_assign/index.js

@@ -0,0 +1,18 @@
+/** @typedef {import('../call_assign/index.d.ts').assign_fn_T}assign_fn_T */
+/**
+ * Assigns function calls into obj
+ * @param {object}obj
+ * @param {Record<string, assign_fn_T>}assign_fn_h_a
+ * @returns {Record<string, unknown>}
+ */
+export function call_assign(obj, ...assign_fn_h_a) {
+	for (let i = 0; i < assign_fn_h_a.length; i++) {
+		const assign_fn_h = assign_fn_h_a[i]
+		for (let prop_name in assign_fn_h) {
+			const assign_fn = assign_fn_h[prop_name]
+			obj[prop_name] = assign_fn(obj[prop_name], obj, prop_name)
+		}
+	}
+	return obj
+}
+export { call_assign as assign__call }

package/all/call_fn_a/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Calls functions in fn_a with ...arg_a
+ */
+export declare function call_fn_a<
+	RVal extends unknown = unknown
+>(fn_a:((...arg_a:unknown[])=>RVal)[], ...arg_a:unknown[]):RVal[]
+export { call_fn_a as call__a1__fn, }

package/all/call_fn_a/index.js

@@ -0,0 +1,14 @@
+/**
+ * Calls functions in fn_a with ...arg_a
+ * @param {(...arg_a:unknown[])=>unknown}fn_a
+ * @param {unknown}arg_a
+ * @returns {unknown[]}
+ */
+export function call_fn_a(fn_a, ...arg_a) {
+	const returns = []
+	for (let i = 0; i < fn_a.length; i++) {
+		returns.push(fn_a[i](...arg_a))
+	}
+	return returns
+}
+export { call_fn_a as call__a1__fn, }

package/all/call_or_fn/index.d.ts

@@ -0,0 +1,13 @@
+import type { falsy } from '../falsy/index.js'
+/**
+ * Returns a function than returns first truthy value from fn_a
+ */
+export declare function call_or_fn_<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+>(fn_a:((value:Val)=>Out)[]):(value:Val)=>Out|falsy
+export {
+	call_or_fn_ as _call_or_fn,
+	call_or_fn_ as _or_fn__call,
+	call_or_fn_ as _or__fn__call,
+}

package/all/call_or_fn/index.js

@@ -0,0 +1,20 @@
+/**
+ * Returns a function than returns first truthy value from fn_a
+ * @param {(value:unknown)=>unknown}fn_a
+ * @returns {(value:unknown)=>unknown}
+ */
+export function call_or_fn_(fn_a) {
+	return (value)=>{
+		let out_value = null
+		for (let i = 0; i < fn_a.length; i += 1) {
+			out_value = fn_a[i](value)
+			if (out_value) return out_value
+		}
+		return out_value
+	}
+}
+export {
+	call_or_fn_ as _call_or_fn,
+	call_or_fn_ as _or_fn__call,
+	call_or_fn_ as _or__fn__call,
+}

package/all/case_insensitive_eql/index.d.ts

@@ -0,0 +1 @@
+export declare function case_insensitive_eql(a_unwrap:string[]):boolean

package/all/case_insensitive_eql/index.js

@@ -0,0 +1,14 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+/**
+ * @param {string[]}a_unwrap
+ * @returns {boolean}
+ */
+export function case_insensitive_eql(a_unwrap) {
+	const value_a = wrap_a_(a_unwrap)
+	let current_value = value_a[0]?.toString()?.toLowerCase()
+	for (let i = 1; i < value_a.length; i++) {
+		const value = value_a[i]?.toString()?.toLowerCase()
+		if (current_value !== value) return false
+	}
+	return true
+}

package/all/chain/index.d.ts

@@ -0,0 +1,22 @@
+export declare function chain_<
+	O extends unknown = unknown
+>(
+	chain__o:chain__o_T,
+	...key_a:chain_key__T[]
+):O
+export interface chain__o_T extends Record<string, any> {
+}
+export declare type chain__ctx_I = chain__o_T
+export type chain_key__fn_T = (this:any, head:any)=>string
+export type chain_key__T = string|string[]|number|chain_key__fn_T
+export { chain_ as _chain, }
+export declare function chain__<
+	O extends unknown = unknown
+>(
+	obj:object,
+	or:O
+):(...keys:chain_key__T[])=>O
+export {
+	chain__ as chain_2,
+	chain__ as __chain,
+}

package/all/chain/index.js

@@ -0,0 +1,48 @@
+import { isArray } from '../isArray/index.js'
+/**
+ * @param {import('../chain/index.js').chain__o_T}chain__o
+ * @param {import('../chain/index.js').chain_key__T[]}key_a
+ * @returns {*}
+ */
+export function chain_(chain__o, ...key_a) {
+	let head = chain__o
+	for (let i = 0; i < key_a.length; i++) {
+		let key = key_a[i]
+		if (typeof key === 'function') {
+			process_key(key.call(head, head))
+			continue
+		}
+		process_key(key)
+	}
+	return head
+	function process_key(key) {
+		if (typeof key === 'string') {
+			walk_key(key)
+		} else if (isArray(key)) {
+			const in_key_a = key
+			const args = in_key_a.slice(1)
+			key = in_key_a[0]
+			const key_ = key.split('.')
+			const n1_key = key_.slice(0, key_.length - 1).join('.')
+			if (n1_key) walk_key(n1_key)
+			key = key_[key_.length - 1]
+			head = head[key] && head[key](...args)
+		} else {
+			head = head[key]
+		}
+	}
+	function walk_key(key) {
+		const key_ = key.split('.')
+		for (const key of key_) {
+			head = head == null ? head : head[key]
+		}
+	}
+}
+export { chain_ as _chain, }
+export function chain__(obj, or) {
+	return (...keys)=>chain_(obj, ...keys) || or
+}
+export {
+	chain__ as chain_2,
+	chain__ as __chain,
+}

package/all/chunk_aa/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Splits array into chunks
+ */
+export declare function chunk_aa_<
+	I extends unknown = unknown,
+	Length extends number = number
+>(
+	a:readonly I[], chunk_length:Length
+):chunk_aa_T<I, Length>
+export {
+	chunk_aa_ as chunk_a2_,
+	chunk_aa_ as _a2__chunk,
+	chunk_aa_ as _chunk_a2,
+	chunk_aa_ as chunk_couple_fn,
+}
+export type chunk_aa_T<I, Length extends number> =
+	Length extends 1
+		? [I][]
+		: Length extends 2
+			? [I, I][]
+			: Length extends 3
+				? [I, I, I][]
+				: Length extends 4
+					? [I, I, I, I][]
+					: Length extends 5
+						? [I, I, I, I, I][]
+						: Length extends 6
+							? [I, I, I, I, I, I][]
+							: Length extends 7
+								? [I, I, I, I, I, I, I][]
+								: Length extends 8
+									? [I, I, I, I, I, I, I, I][]
+									: Length extends 9
+										? [I, I, I, I, I, I, I, I, I][]
+										: I[][]

package/all/chunk_aa/index.js

@@ -0,0 +1,20 @@
+import { slice } from '../slice/index.js'
+/**
+ * Splits array into chunks
+ * @param {unknown[]}a
+ * @param {number}chunk_length
+ * @returns {unknown[][]}
+ */
+export function chunk_aa_(a, chunk_length) {
+	let chunk_aa = []
+	for (let i = 0; i < a.length; i += chunk_length) {
+		chunk_aa.push(slice(a, i, i + chunk_length))
+	}
+	return chunk_aa
+}
+export {
+	chunk_aa_ as chunk_a2_,
+	chunk_aa_ as _a2__chunk,
+	chunk_aa_ as _chunk_a2,
+	chunk_aa_ as chunk_couple_fn,
+}

package/all/chunk_aa/index.test.ts

@@ -0,0 +1,11 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { chunk_aa_ } from '../chunk_aa/index.js'
+test('chunk_aa_', ()=>{
+	const a = ['foo', 'bar', 'baz']
+	equal(chunk_aa_(a, 2), [
+		['foo', 'bar'],
+		['baz']
+	])
+})
+test.run()

package/all/circular_idx/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns `idx` % `length`.
+ */
+export declare function circular_idx_(
+	length:number, idx?:number
+):number
+export {
+	circular_idx_ as _circular_idx,
+	circular_idx_ as _idx__circular,
+}

package/all/circular_idx/index.js

@@ -0,0 +1,13 @@
+/**
+ * Returns `idx` % `length`.
+ * @param {number}length
+ * @param {number}[idx]
+ * @returns {number}
+ */
+export function circular_idx_(length, idx = 0) {
+	return (length + idx % length) % length || 0
+}
+export {
+	circular_idx_ as _circular_idx,
+	circular_idx_ as _idx__circular,
+}

package/all/clear_ctx/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns obj with keys in `key_` having `clear_value`.
+ */
+export declare function clear_ctx_<
+	I extends unknown = unknown
+>(key_a:string[], clear_value:I):Record<string, I>
+export {
+	clear_ctx_ as _clear_ctx,
+	clear_ctx_ as _ctx__clear,
+}

package/all/clear_ctx/index.js

@@ -0,0 +1,19 @@
+/**
+ * Returns obj with keys in `key_a` having `clear_value`.
+ * @param {string[]}key_a
+ * @param {unknown}clear_value
+ * @returns {object}
+ * @private
+ */
+export function clear_ctx_(key_a, clear_value) {
+	const clear_ctx = {}
+	for (let i = 0; i < key_a.length; i++) {
+		const key = key_a[i]
+		clear_ctx[key] = clear_value
+	}
+	return clear_ctx
+}
+export {
+	clear_ctx_ as _clear_ctx,
+	clear_ctx_ as _ctx__clear,
+}

package/all/clone/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Assigns arguments to a new object
+ */
+export declare function clone<
+	I extends object = object
+>(...arg_a:Partial<I>[]):I

package/all/clone/index.js

@@ -0,0 +1,9 @@
+import { assign } from '../assign/index.js'
+/**
+ * Assigns arguments to a new object
+ * @param {unknown[]}arg_a
+ * @returns {unknown}
+ */
+export function clone(...arg_a) {
+	return assign({}, ...arg_a)
+}

package/all/clone_assign_fn_key_a/index.d.ts

@@ -0,0 +1,14 @@
+import type { fn_key_a_tuple_T } from '../assign_fn_key_a/index.js'
+/**
+ * Assigns to a cloned obj array of keys the return value of function in key_a_fn_aa.
+ */
+export declare function clone_assign_fn_key_a<
+	I extends object = object
+>(
+	obj:Record<string, I>,
+	...key_a_fn_aa:fn_key_a_tuple_T<I>[]
+):Record<string, I>
+export {
+	clone_assign_fn_key_a as clone_assign_fn_key_a1,
+	clone_assign_fn_key_a as clone__assign__key_a1__fn,
+}

package/all/clone_assign_fn_key_a/index.js

@@ -0,0 +1,18 @@
+import { assign_fn_key_a } from '../assign_fn_key_a/index.js'
+import { clone } from '../clone/index.js'
+/**
+ * Assigns to a cloned obj array of keys the return value of function in key_a_fn_aa.
+ * @param {Record<string, object>}obj
+ * @param {import('../assign_fn_key_a/index.js').fn_key_a_tuple_T}key_a_fn_aa
+ * @returns {Record<string, object>}
+ */
+export function clone_assign_fn_key_a(
+	obj,
+	...key_a_fn_aa
+) {
+	return assign_fn_key_a(clone(obj), ...key_a_fn_aa)
+}
+export {
+	clone_assign_fn_key_a as clone_assign_fn_key_a1,
+	clone_assign_fn_key_a as clone__assign__key_a1__fn,
+}

package/all/color_hex_rgb__comma_delim_str/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Convert hex to a comma-delimited rgb string
+ * @example
+ * color_hex_rgb__comma_delim_str_('ABC') // '170,187,204'
+ * color_hex_rgb__comma_delim_str_('123456') // '18,52,86'
+ */
+export declare function color_hex_rgb__comma_delim_str_(hex:string):string
+export {
+	color_hex_rgb__comma_delim_str_ as rgb_color_hex_comma_delim_str_,
+	color_hex_rgb__comma_delim_str_ as _str__hex__color__rgb__comma_delim,
+}

package/all/color_hex_rgb__comma_delim_str/index.js

@@ -0,0 +1,16 @@
+import { color_rgb_hex_a_ } from '../color_rgb/index.js'
+/**
+ * Convert hex to a comma-delimited rgb string
+ * @param {string}hex
+ * @return {string}
+ * @example
+ * color_hex_rgb__comma_delim_str_('ABC'..// '170,187,204/index.js'
+ * color_hex_rgb__comma_delim_str_('123456'..// '18,52,86/index.js'
+ */
+export function color_hex_rgb__comma_delim_str_(hex) {
+	return color_rgb_hex_a_(hex).join(',')
+}
+export {
+	color_hex_rgb__comma_delim_str_ as rgb_color_hex_comma_delim_str_,
+	color_hex_rgb__comma_delim_str_ as _str__hex__color__rgb__comma_delim
+}

package/all/color_hsv/index.d.ts

@@ -0,0 +1,18 @@
+import { color_rgb_a_T } from '../color_rgb/index.js'
+/**
+ * Returns a rgb array value from the given `(h,s,v)` (Hue, Saturation, Value)
+ *
+ * @see {@link http://en.wikipedia.org/wiki/HSL_and_HSV#Converting_to_RGB}
+ */
+export declare function color_rgb_a__color_hsv_a_(
+	hsv_color_a:color_hsv_a_T
+):color_rgb_a_T
+export {
+	color_rgb_a__color_hsv_a_ as hsv_color_a_from_rgb_color_a_,
+	color_rgb_a__color_hsv_a_ as hsv_color_a1_from_rgb_color_a1_,
+	color_rgb_a__color_hsv_a_ as _hsv_color_a1_from_rgb_color_a1,
+	color_rgb_a__color_hsv_a_ as _a1__color__rgb__from__a1__color__hsv,
+}
+export declare type color_hsv_a_T = [number, number, number]
+export declare type hsv_color_a_T = color_hsv_a_T
+export declare type hsv_color_a1_T = color_hsv_a_T