ctx-core 2.2.0 → 2.2.2

package/all/distribution_random_float/index.d.ts

@@ -0,0 +1,4 @@
+export declare function distribution_random_float_(
+	min:number|undefined, max:number|undefined, distribution_:()=>number
+):number
+export { distribution_random_float_ as _float__random__distribution }

package/all/distribution_random_float/index.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number}min
+ * @param {number}max
+ * @param {()=>number}distribution_
+ * @returns {number}
+ */
+export function distribution_random_float_(
+	min = 0.0, max = 1.0, distribution_
+) {
+	return distribution_() * (max - min) + min
+}
+export { distribution_random_float_ as _float__random__distribution }

package/all/distribution_random_int/index.d.ts

@@ -0,0 +1,4 @@
+export declare function distribution_random_int_(
+	min:number|undefined, max:number|undefined, distribution_:()=>number
+):number
+export { distribution_random_int_ as _int__random__distribution }

package/all/distribution_random_int/index.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number}min
+ * @param {number}max
+ * @param {()=>number}distribution_
+ * @returns {number}
+ */
+export function distribution_random_int_(
+	min = 0, max = 1, distribution_
+) {
+	return Math.floor(min + distribution_() * (max - min))
+}
+export { distribution_random_int_ as _int__random__distribution }

package/all/div/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Divides rest of values from the first val
+ */
+export declare function div(values:readonly number[]):number

package/all/div/index.js

@@ -0,0 +1,10 @@
+/**
+ * Divides rest of values from the first val
+ */
+export function div(values) {
+	let val = values[0]
+	for (let i = 1; i < values.length; i++) {
+		val /= values[i]
+	}
+	return val
+}

package/all/each/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Iterate over each item in `a` with `fn(a[i], i)`.
+ */
+export declare function each<
+	I extends unknown = unknown
+>(
+	a:readonly I[], fn:each_fn_T<I>
+):I[]
+export declare function maybe_each<
+	I extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly I[]|undefined, fn:each_fn_T<I>, or?:Or
+):I[]|Or
+export declare type each_fn_T<I> = (val:I, idx:number)=>void

package/all/each/index.js

@@ -0,0 +1,23 @@
+/** @typedef {import('../each/index.d.ts').each_fn_T}each_fn_T */
+/**
+ * Iterate over each item in `a` with `fn(a[i], i)`.
+ * @param {unknown[]}a
+ * @param {each_fn_T}fn
+ * @returns {unknown[]}
+ */
+export function each(a, fn) {
+	for (let i = 0; i < a.length; i++) {
+		fn(a[i], i)
+	}
+	return a
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {each_fn_T}fn
+ * @param {unknown[]|null|undefined}[or]
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_each(maybe_a, fn, or = null) {
+	if (!maybe_a) return or
+	return each(maybe_a, fn)
+}

package/all/ensure/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ensures that the keys in `rest_ctx_a` are added to val
+ *   only if the key is not defined on val (== null).
+ * The order of precedence is from left to right.
+ * @example
+ * val = {baz: 99}
+ * ensure(val, {foo: 1, baz: 4}, {foo: 2, bar: 3}) // {baz:99, foo: 1, bar: 3}
+ */
+export declare function ensure<
+	I extends unknown = unknown
+>(val:I, ...rest_ctx_a:Partial<I>[]):I|undefined

package/all/ensure/index.js

@@ -0,0 +1,26 @@
+import { keys } from '../keys/index.js'
+/**
+ * Ensures that the keys in `rest_ctx_a` are added to val
+ *   only if the key is not defined on val (== null).
+ * The order of precedence is from left to right.
+ * @param {unknown}val
+ * @param {unknown}rest_ctx_a
+ * @returns {unknown}
+ * @example
+ * val = {baz: 99}
+ * ensure(val, {foo: 1, baz: 4}, {foo: 2, bar: 3}) // {baz:99, foo: 1, bar: 3}
+ */
+export function ensure(val, ...rest_ctx_a) {
+	if (!val) return
+	for (let i = 0; i < rest_ctx_a.length; i++) {
+		const rest = rest_ctx_a[i]
+		const rest_ctx_key_a = keys(rest || {})
+		for (let j = 0; j < rest_ctx_key_a.length; j++) {
+			const key = rest_ctx_key_a[j]
+			if (val[key] == null) {
+				val[key] = rest[key]
+			}
+		}
+	}
+	return val
+}

package/all/ensure__refresh/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `ensure` `obj[key]` is present or call `ensure(obj)`. Then call `refresh(obj, obj[key])`.
+ */
+export declare function ensure__refresh<
+	I extends unknown = unknown
+>(
+	obj:ensure_refresh__o_T<I>,
+	...refresh_ctx_a:ensure__refresh_opts_T<I>[]
+):I|undefined
+export {
+	ensure__refresh as ensure_refresh,
+}
+export interface ensure__refresh_opts_T<T> {
+	key:string
+	ensure:(obj:ensure_refresh__o_T<T>)=>T
+	refresh:(obj:ensure_refresh__o_T<T>, val:T)=>void
+}
+export declare type refresh_ctx_T<T> = ensure__refresh_opts_T<T>
+export declare type ensure_refresh__o_T<T> = Record<string, T>
+export declare type ensure_refresh_obj_type<T> = ensure_refresh__o_T<T>

package/all/ensure__refresh/index.js

@@ -0,0 +1,23 @@
+import { clone } from '../clone/index.js'
+/**
+ * `ensure` `obj[key]` is present or call `ensure(obj)`. Then call `refresh(obj, obj[key])`.
+ * @param {import('../ensure__refresh/index.js').ensure_refresh__o_T}obj
+ * @param {import('../ensure__refresh/index.js').ensure__refresh_opts_T}ensure__refresh_opts_a
+ * @returns {unknown}
+ */
+export function ensure__refresh(
+	obj,
+	...ensure__refresh_opts_a
+) {
+	if (!obj) return
+	const refresh_ctx = clone(...ensure__refresh_opts_a)
+	const { key, ensure, refresh } = refresh_ctx
+	if (!obj[key]) {
+		obj[key] = ensure(obj)
+	}
+	refresh(obj, obj[key])
+	return obj[key]
+}
+export {
+	ensure__refresh as ensure_refresh,
+}

package/all/entries_gen/index.d.ts

@@ -0,0 +1,5 @@
+export declare function entries_gen_<T>(
+	obj:{
+		[s:string]:T
+	}|ArrayLike<T>
+):Generator<[string, T]>

package/all/entries_gen/index.js

@@ -0,0 +1,12 @@
+/**
+ * @param {object|ArrayLike}obj
+ * @returns {Generator<[string, unknown]}
+ * @private
+ */
+export function* entries_gen_(obj) {
+	for (const key in obj) {
+		if (obj.hasOwnProperty(key)) {
+			yield [key, obj[key]]
+		}
+	}
+}

package/all/entries_gen/index.test.ts

@@ -0,0 +1,20 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { entries_gen_ } from '../entries_gen/index.js'
+test('entries_gen_', ()=>{
+	const date = new Date()
+	const obj = {
+		id: 1,
+		name: 'My name',
+		date
+	}
+	const key_a:string[] = []
+	const val_a:any[] = []
+	for (const [key, val] of entries_gen_(obj)) {
+		key_a.push(key)
+		val_a.push(val)
+	}
+	equal(key_a, ['id', 'name', 'date'])
+	equal(val_a, [1, 'My name', date])
+})
+test.run()

package/all/eq/index.d.ts

@@ -0,0 +1,21 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+/**
+ * Returns `==` operator to all values in `a_nowrap`.
+ */
+export declare function eq<
+	In extends unknown = unknown
+>(a_nowrap:a_nowrap_T<In>):boolean
+export declare type eq_T<I extends unknown = unknown> = (a_nowrap:I)=>boolean
+/**
+ * Returns function that returns `==` operator to all values in `in_value_aS`.
+ */
+export declare function eq_<
+	In extends unknown = unknown
+>(a_nowrap:a_nowrap_T<In>):eq_fn_T<In>
+export {
+	eq_ as _eq,
+	eq_ as _fn__eq,
+}
+export declare type eq_fn_T<
+	In extends unknown = unknown
+> = (value:In)=>boolean

package/all/eq/index.js

@@ -0,0 +1,28 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns `==` operator to all values in `a_nowrap`.
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
+ * @returns {boolean}
+ */
+export function eq(a_nowrap) {
+	const value_a = wrap_a_(a_nowrap)
+	let current_value = value_a[0]
+	for (let i = 1; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (current_value != value) return false
+	}
+	return true
+}
+/**
+ * Returns function that returns `==` operator to all values in `in_value_aS`.
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
+ * @returns {import('../eq/index.js').eq_fn_T}
+ */
+export function eq_(a_nowrap) {
+	return (value)=>eq(wrap_concat(a_nowrap, value))
+}
+export {
+	eq_ as _eq,
+	eq_ as _fn__eq,
+}

package/all/eql/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns `===` operator to all values in `a_unwrap`.
+ */
+export declare function eql<
+	I extends unknown = unknown
+>(a_unwrap:I):boolean
+/**
+ * Returns function that returns `===` operator to all values in `in_value_a`.
+ */
+export declare function eql_<
+	Val extends unknown = unknown
+>(in_value_a:Val[]):(val:Val)=>boolean
+export { eql_ as _eql, }
+/**
+ * Returns function that applies `===` operator to `compare` & `value`.
+ */
+export declare function eql_2<
+	Val extends unknown = unknown
+>(compare:Val):(val:Val)=>boolean
+export {
+	eql_2 as _eql_fn,
+	eql_2 as _fn__eql,
+}

package/all/eql/index.js

@@ -0,0 +1,37 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns `===` operator to all values in `a_unwrap`.
+ * @param {unknown}a_unwrap
+ * @returns {boolean}
+ */
+export function eql(a_unwrap) {
+	const value_a = wrap_a_(a_unwrap)
+	let current_value = value_a[0]
+	for (let i = 1; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (current_value !== value) return false
+	}
+	return true
+}
+/**
+ * Returns function that returns `===` operator to all values in `in_value_a`.
+ * @param {unknown[]}in_value_a
+ * @returns {(val:unknown)=>boolean}
+ */
+export function eql_(in_value_a) {
+	return val=>eql(wrap_concat(in_value_a, val))
+}
+export { eql_ as _eql, }
+/**
+ * Returns function that applies `===` operator to `compare` & `value`.
+ * @param {unknown}compare
+ * @returns {(val:unknown)=>boolean}
+ */
+export function eql_2(compare) {
+	return val=>val === compare
+}
+export {
+	eql_2 as _eql_fn,
+	eql_2 as _fn__eql,
+}

package/all/eql_a/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Is e0_a `===` e1_a? Checks first level equality.
+ */
+export declare function eql_a_<
+	I extends unknown = unknown
+>(e0_a:readonly I[], e1_a:readonly I[]):boolean
+export {
+	eql_a_ as eql_a1_fn,
+	eql_a_ as _eql_a1,
+	eql_a_ as _eql__a1,
+}

package/all/eql_a/index.js

@@ -0,0 +1,20 @@
+/**
+ * Is e0_a `===` e1_a? Checks first level equality.
+ * @param {unknown[]}e0_a
+ * @param {unknown[]}e1_a
+ * @returns {boolean}
+ */
+export function eql_a_(e0_a, e1_a) {
+	if (e0_a === e1_a) return true
+	if (e0_a == null || e1_a == null) return false
+	if (e0_a.length != e1_a.length) return false
+	for (let i = 0; i < e0_a.length; ++i) {
+		if (e0_a[i] !== e1_a[i]) return false
+	}
+	return true
+}
+export {
+	eql_a_ as eql_a1_fn,
+	eql_a_ as _eql_a1,
+	eql_a_ as _eql__a1,
+}

package/all/eql_fn_a/index.d.ts

@@ -0,0 +1,16 @@
+import type { a_item_T } from '../a_item/index.js'
+/**
+ * Is i0_a `===` to i1_a based on `fn(a, b, i)`? Checks first level equality.
+ */
+export declare function eql_fn_a_<
+	I extends unknown = unknown
+>(
+	i0_a:readonly I[],
+	i1_a:readonly I[],
+	fn:(a:a_item_T<I>, b:a_item_T<I>, idx:number)=>boolean,
+):boolean
+export {
+	eql_fn_a_ as eql_fn_a1_fn,
+	eql_fn_a_ as _eql_fn_a1,
+	eql_fn_a_ as _eql__a1__fn,
+}

package/all/eql_fn_a/index.js

@@ -0,0 +1,22 @@
+/** @typedef {import('../a_item/index.d.ts').a_item_T}a_item_T */
+/**
+ * Is i0_a `===` to i1_a based on `fn(a, b, i)`? Checks first level equality.
+ * @param i0_a{unknown[]}
+ * @param i1_a{unknown[]}
+ * @param fn{(a:a_item_T, b:a_item_T, idx:number)=>boolean}
+ * @returns {boolean}
+ */
+export function eql_fn_a_(i0_a, i1_a, fn) {
+	if (i0_a === i1_a) return true
+	if (i0_a == null || i1_a == null) return false
+	if (i0_a.length != i1_a.length) return false
+	for (let i = 0; i < i0_a.length; ++i) {
+		if (!fn(i0_a[i], i1_a[i], i)) return false
+	}
+	return true
+}
+export {
+	eql_fn_a_ as eql_fn_a1_fn,
+	eql_fn_a_ as _eql_fn_a1,
+	eql_fn_a_ as _eql__a1__fn,
+}

package/all/equidistant_segment_point_a/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns an array of equidistant segment boundaries from the count & range
+ */
+export declare function equidistant_segment_point_a_(
+	opts:equidistant_segment_point_a__opts_I
+):number[]
+export interface equidistant_segment_point_a__opts_I {
+	length?:number
+	range?:readonly number[]
+}
+export {
+	equidistant_segment_point_a_ as _equidistant_segment_point_a1,
+	equidistant_segment_point_a_ as _a1__point__segment__equidistant,
+}

package/all/equidistant_segment_point_a/index.js

@@ -0,0 +1,25 @@
+import { last_ } from '../last/index.js'
+/**
+ * Returns an array of equidistant segment boundaries from the count & range
+ */
+export function equidistant_segment_point_a_(opts) {
+	const { length = 1, range = [], } = opts
+	const low = range[0] || 0
+	const high = last_(range) || 1
+	const step = 1 * (high - low) / length
+	let equidistant_segment_point_a = [
+		low
+	]
+	let i = 0
+	let segment_current_boundary = low
+	while (i < length) {
+		i++
+		segment_current_boundary += step
+		equidistant_segment_point_a.push(segment_current_boundary)
+	}
+	return equidistant_segment_point_a
+}
+export {
+	equidistant_segment_point_a_ as _equidistant_segment_point_a1,
+	equidistant_segment_point_a_ as _a1__point__segment__equidistant,
+}

package/all/error__print/index.d.ts

@@ -0,0 +1,5 @@
+import type { error_o_error_T } from '../error_o/index.js'
+/**
+ * Prints the given `error_o` to stderr
+ */
+export declare function error__print(error_o_error:error_o_error_T):void

package/all/error__print/index.js

@@ -0,0 +1,18 @@
+/** @typedef {import('../error_o/index.d.ts').argument__error_o_T} */
+/**
+ * Prints the given `error_o_error` to stderr
+ * @param {error_o_error_T}error_o_error
+ * @type {typeof import('../error__print/index.js').error__print}
+ */
+export function error__print(error_o_error) {
+	const {
+		http__message = 'Error',
+		message = 'Error'
+	} = error_o_error
+	console.error(`
+error__print|catch
+${error_o_error}
+http__message: ${http__message}
+message: ${message}
+${error_o_error.stack}`.trim())
+}

package/all/error_o/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Assigns & coerces to ctx.ctx__error
+ */
+export declare function error_o_(
+	message?:string,
+	error_o?:argument__error_o_T
+):argument__error_o_T
+/**
+ * Throws an error
+ * @throws Decorate & throw error given by the arguments.
+ */
+export declare function error_o__throw(
+	message?:string,
+	error_o?:argument__error_o_T
+):void
+export {
+	error_o__throw as error__throw,
+}
+export interface error_o_T {
+	data?:any
+	http__message?:string
+	http__status?:number
+	url?:string
+}
+export type argument__error_o_T = error_o_T&Partial<Error>
+export interface error_o_error_T extends Error, error_o_T {
+}

package/all/error_o/index.js

@@ -0,0 +1,25 @@
+import { assign } from '../assign/index.js'
+/** @typedef {import('./index.d.ts').argument__error_o_T} */
+/** @typedef {import('../error_o/index.d.ts').error_o_error_T} */
+/**
+ * argument__error_o_T factory function
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @returns {error_o_error_T}
+ */
+export function error_o_(message, error_o) {
+	const error = new Error(message)
+	return assign(error, error_o)
+}
+/**
+ * Throws an error_o
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @throws Decorate & throw error given by the arguments.
+ */
+export function error_o__throw(message, error_o) {
+	throw error_o_(message, error_o)
+}
+export {
+	error_o__throw as error__throw,
+}

package/all/every/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Returns true if every `predicate(value)` is truthy
+ */
+export declare function every<
+	I extends unknown = unknown
+>(
+	a:readonly I[],
+	predicate:(item:I, idx:number, a:readonly I[])=>boolean
+):boolean
+export declare function maybe_every<
+	I extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly I[]|undefined,
+	predicate:(item:I, idx:number, a:readonly I[])=>boolean,
+	or?:Or
+):boolean|Or
+export {
+	every as every_a1,
+	every as every__a1,
+}
+/**
+ * Returns a function that returns from [every](#every) with the given `predicate` function.
+ */
+export declare function every_<
+	I extends unknown = unknown
+>(
+	predicate:(item:I, idx:number, a:readonly I[])=>boolean
+):(a:readonly I[])=>boolean
+export {
+	every_ as _every,
+	every_ as _every_fn,
+	every_ as _fn__every,
+}

package/all/every/index.js

@@ -0,0 +1,43 @@
+/**
+ * Returns true if every `predicate(value)` is truthy
+ * @param {unknown[]}a
+ * @param {(item:unknown, idx:number, a:unknown[])=>boolean}predicate
+ * @returns {boolean}
+ */
+export function every(a, predicate) {
+	let idx = -1
+	const length = a.length
+	while (++idx < length) {
+		if (!predicate(a[idx], idx, a)) {
+			return false
+		}
+	}
+	return true
+}
+export {
+	every as every_a1,
+	every as every__a1,
+}
+/**
+ * @param maybe_a{unknown[]|undefined}
+ * @param predicate{(item:unknown, idx:number, a:unknown[])=>boolean}
+ * @param or{boolean|null|unknown}
+ * @returns {boolean|null|unknown}
+ */
+export function maybe_every(maybe_a, predicate, or = null) {
+	if (!maybe_a) return or
+	return every(maybe_a, predicate)
+}
+/**
+ * Returns a function that returns from [every](#every) with the given `predicate` function.
+ * @param predicate{(item:unknown, idx:number, a:unknown[])=>boolean}
+ * @returns {(a:unknown[])=>boolean}
+ */
+export function every_(predicate) {
+	return a=>every(a, predicate)
+}
+export {
+	every_ as _every,
+	every_ as _every_fn,
+	every_ as _fn__every,
+}

package/all/every_arg/index.d.ts

@@ -0,0 +1,15 @@
+import type { nullish } from '../nullish/index.js'
+/**
+ * If the function args pass every_fn condition, the return value is the function; else return or value
+ */
+export declare function every_arg_<
+	F extends (...args:any[])=>any,
+	E extends (
+		$:Parameters<F>,
+		index?:number,
+		$a?:any[]
+	)=>any,
+	O extends ()=>ReturnType<F>|nullish
+>(
+	fn:F, every_fn?:E, or_?:O
+):F

package/all/every_arg/index.js

@@ -0,0 +1,15 @@
+/**
+ * @param {(...args:unknown[])=>unknown}fn
+ * @param {($:Parameters<unknown>, index?:number, $a?:unknown[])=>unknown}[every_fn]
+ * @param {unknown}[or]
+ * @return {(fn:(...args:unknown[])=>unknown)}
+ */
+export function every_arg_(
+	fn,
+	every_fn = $=>$ != null,
+	or = ()=>null
+) {
+	return (...arg_a)=>{
+		return arg_a.every(every_fn) ? fn(...arg_a) : or()
+	}
+}