ctx-core 2.2.0 → 2.2.2

package/all/r_val_a/index.js

@@ -0,0 +1,28 @@
+/**
+ * Returns Array of `r[key_a[]]`.
+ * @param {Record<string, unknown>}r
+ * @param {string}key_a
+ * @returns {unknown[]}
+ */
+export function r_val_a_(r, key_a) {
+	return key_a ? key_a.map(key=>r[key]) : Object.values(r)
+}
+/**
+ * @param {Record<string, unknown>|undefined}r
+ * @param {string}key_a
+ * @param {unknown[]|null|undefined}or
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_r_val_a_(r, key_a, or = null) {
+	if (!r) return or
+	return r_val_a_(r, key_a)
+}
+export {
+	r_val_a_ as key_a_from_val_a_,
+	r_val_a_ as key_a1_from_val_a1_fn,
+	r_val_a_ as _key_a1_from_val_a1,
+	r_val_a_ as _a1__val__from__a1__key,
+	maybe_r_val_a_ as maybe_key_a_from_val_a_,
+	maybe_r_val_a_ as maybe_key_a1_from_val_a1_fn,
+	maybe_r_val_a_ as _maybe_key_a1_from_val_a1,
+}

package/all/rad_deg/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Radians to Degrees
+ */
+export declare function rad_deg_(rad:number):number
+export { rad_deg_ as _rad_deg, rad_deg_ as _deg__rad, }

package/all/rad_deg/index.js

@@ -0,0 +1,7 @@
+/**
+ * Radians to Degrees
+ */
+export function rad_deg_(rad) {
+	return rad * (180 / Math.PI)
+}
+export { rad_deg_ as _rad_deg, rad_deg_ as _deg__rad, }

package/all/random_idx/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a random index in `a`.
+ */
+export declare function random_idx_(a:readonly unknown[]):number
+export {
+	random_idx_ as _random_idx,
+	random_idx_ as idx__random,
+}

package/all/random_idx/index.js

@@ -0,0 +1,12 @@
+/**
+ * Returns a random index in `a`.
+ * @param {unknown[]}a
+ * @returns {number}
+ */
+export function random_idx_(a) {
+	return Math.floor(Math.random() * a.length)
+}
+export {
+	random_idx_ as _random_idx,
+	random_idx_ as idx__random,
+}

package/all/rank/index.d.ts

@@ -0,0 +1,10 @@
+import type { compare_1_T } from '../array_types/index.js'
+/**
+ * Returns the rank of the items where the compare function === 0
+ */
+export declare function rank<
+	I extends unknown = unknown
+>(
+	a:readonly I[], compare_1:compare_1_T
+):number
+export { rank as rank__a1, }

package/all/rank/index.js

@@ -0,0 +1,16 @@
+/**
+ * Returns the rank of the items where the compare function === 0
+ * @param {unknown[]}a
+ * @param {import('../array_types/index.js').compare_1_T}compare_1
+ * @returns {number}
+ */
+export function rank(a, compare_1) {
+	let i_rank = 1
+	for (let i = 0; i < a.length; i++) {
+		if (compare_1(a[i]) > 0) {
+			i_rank++
+		}
+	}
+	return i_rank
+}
+export { rank as rank__a1, }

package/all/rate_limit/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Rate limit function factory.
+ * @link {@see https://www.matteoagosti.com/blog/2013/01/22/rate-limiting-function-calls-in-javascript/}
+ */
+export declare function rate_limit_<Out>(
+	ops_max:number, interval:number, allow_bursts?:boolean
+):rate_limit__T<Out>
+export declare type rate_limit__T<Out> = (fn:rate_limit_fn_T<Out>)=>Promise<Out>
+export declare type rate_limit_fn_T<Out> = ()=>Promise<Out>
+export { rate_limit_ as _rate_limit, }

package/all/rate_limit/index.js

@@ -0,0 +1,49 @@
+/**
+ * Rate limit function factory.
+ * @param {number}ops_max
+ * @param {number}interval_millis
+ * @param {boolean}allow_bursts
+ * @returns {import('./index.d.ts').rate_limit__T}
+ * @link {@see https://www.matteoagosti.com/blog/2013/01/22/rate-limiting-function-calls-in-javascript/}
+ */
+export function rate_limit_(
+	ops_max, interval_millis, allow_bursts = false
+) {
+	const max_rate = allow_bursts ? ops_max : ops_max / interval_millis
+	let ops_num = 0
+	let start = new Date().getTime()
+	const queue_a = []
+	function rate_limit(fn) {
+		let rate = 0
+		const now = new Date().getTime()
+		const elapsed = now - start
+		if (elapsed > interval_millis) {
+			ops_num = 0
+			start = now
+		}
+		rate = ops_num / (allow_bursts ? 1 : elapsed)
+		return new Promise(async (resolve, reject)=>{
+			try {
+				if (rate < max_rate) {
+					if (queue_a.length) {
+						if (fn) queue_a.push(async ()=>resolve(await fn())
+						)
+						ops_num += 1
+						queue_a.shift()().then()
+					} else {
+						ops_num += 1
+						resolve(await fn())
+					}
+				} else {
+					if (fn) queue_a.push(async ()=>resolve(await fn())
+					)
+					setTimeout(rate_limit, 1 / max_rate)
+				}
+			} catch (err) {
+				reject(err)
+			}
+		})
+	}
+	return rate_limit
+}
+export { rate_limit_ as _rate_limit, }

package/all/rc_be/index.d.ts

@@ -0,0 +1,9 @@
+import type { Ctx } from '../be_/index.js'
+import type { rc_be__val__T } from '../rc_be_/index.js'
+export declare function rc_be<
+	Out extends NonNullable<unknown>
+>(ctx:Ctx, val_:rc_be__val__T<Out>):Out
+export declare function rc_be<
+	Out extends NonNullable<unknown>
+>(ctx:Ctx, key:string, val_:rc_be__val__T<Out>):Out
+export { rc_be as rc_b, }

package/all/rc_be/index.js

@@ -0,0 +1,17 @@
+import { rc_be_ } from '../rc_be_/index.js'
+/** @typedef {import('../be_/index.d.ts').Ctx}Ctx */
+/** @typedef {import('../rc_be_/index.d.ts').rc_be__val__T}rc_be__val__T */
+/**
+ * @param {Ctx}ctx
+ * @param {string|rc_be__val__T<NonNullable<unknown>>}key_or_val
+ * @param {rc_be__val__T<NonNullable<unknown>>}[val_]
+ * @returns {NonNullable<unknown>}
+ */
+export function rc_be(
+	ctx,
+	key_or_val,
+	val_
+) {
+	return val_ ? rc_be_(key_or_val, val_)(ctx) : rc_be_(key_or_val)(ctx)
+}
+export { rc_be as rc_b, }

package/all/rc_be_/index.d.ts

@@ -0,0 +1,42 @@
+import type { Be, be__val__T, be_params_T, Ctx } from '../be_/index.js'
+export declare const be_m_set_key:unique symbol
+/**
+ * Returns _be with referencing counting.
+ * When all unsubscribes have been called, the ctx[key] is deleted.
+ */
+export declare function rc_be_<
+	Out extends NonNullable<unknown>
+>(val_:rc_be__val__T<Out>):rc_be__return_T<Out>
+export declare function rc_be_<
+	Out extends NonNullable<unknown>
+>(key:string, val_:rc_be__val__T<Out>):rc_be__return_T<Out>
+export declare type rc_be__return_T<
+	Out extends NonNullable<unknown>
+> = (ctx:Ctx, opts?:rc_be_params_T)=>RcBe_return_T<Out>
+export {
+	rc_be_ as _rc_be,
+	rc_be_ as _rc_b,
+}
+export declare type be_m_set_T<
+	Out extends NonNullable<unknown>
+> = Map<Be<Out>, Set<any>>
+export declare type val_this_on_destroy_T = (...destroy_a:rc_be_destroy_T[])=>void
+export interface val_this_T {
+	on_destroy:val_this_on_destroy_T
+	onDestroy:val_this_on_destroy_T
+}
+export interface rc_be_params_T extends be_params_T {
+	owner?:object
+}
+export declare type rc_be__val__T<
+	Out extends NonNullable<unknown>
+> = be__val__T<Out>&((this:val_this_T, ctx:Ctx, key:Be<Out>, opts?:rc_be_params_T)=>Out)
+export declare type rc_be_destroy_T = ()=>void
+export interface RcBe_return_T<Out extends unknown = unknown> {
+	value:Out
+	destroy:rc_be_destroy_T
+}
+export declare type RcBe<
+	Out extends NonNullable<unknown>
+> = (ctx:Ctx, opts?:be_params_T)=>RcBe_return_T<Out>
+export declare type RcB<Out extends NonNullable<unknown>> = RcBe<Out>

package/all/rc_be_/index.js

@@ -0,0 +1,62 @@
+import { be_ } from '../be_/index.js'
+/** @typedef {import('../rc_be_/index.d.ts').rc_be__val__T}rc_be__val__T */
+export const be_m_set_key = Symbol('be_m_set')
+/**
+ * @param {string|rc_be__val__T}key_or_val_
+ * @param {rc_be__val__T}[val_]
+ * @returns {import('./index.d.ts').rc_be__return_T}
+ * @private
+ */
+export function rc_be_(key_or_val_, val_) {
+	return (ctx1, opts1)=>{
+		const ctx_any = ctx1
+		const destroy_cb_a = []
+		const val_this = {
+			on_destroy,
+			onDestroy: on_destroy
+		}
+		/** @type {rc_be__val__T} */
+		const val_ = val_ ? val_ : key_or_val_
+		const key = val_ ? key_or_val_ : null
+		const be1 =
+			val_
+				? be_(val_)
+				: be_(
+					key,
+					(ctx, be, opts)=>
+						val_.call(val_this, ctx, be, opts)
+				)
+		let be_m_set = ctx_any[be_m_set_key]
+		if (!be_m_set) {
+			be_m_set = new Map()
+			ctx_any[be_m_set_key] = be_m_set
+		}
+		let rc_set = be_m_set.get(be1)
+		if (!rc_set) {
+			rc_set = new Set()
+			be_m_set.set(be1, rc_set)
+		}
+		const owner = (opts1 === null || opts1 === void 0 ? void 0 : opts1.owner) || {}
+		rc_set.add(owner)
+		let destroy = ()=>{
+			rc_set.delete(owner)
+			if (!rc_set.size) {
+				for (const destroy_cb of destroy_cb_a) {
+					destroy_cb()
+				}
+				ctx1.delete(be1)
+			}
+		}
+		return {
+			value: be1(ctx1, opts1),
+			destroy
+		}
+		function on_destroy(...in_destroy_cb_a) {
+			destroy_cb_a.push(...in_destroy_cb_a)
+		}
+	}
+}
+export {
+	rc_be_ as _rc_be,
+	rc_be_ as _rc_b,
+}

package/all/re_/index.d.ts

@@ -0,0 +1 @@
+export declare function re_(pattern:RegExp|string, flags?:string):RegExp

package/all/re_/index.js

@@ -0,0 +1,8 @@
+/**
+ * @param {RegExp|string}pattern
+ * @param {string}flags
+ * @returns {RegExp}
+ */
+export function re_(pattern, flags) {
+	return new RegExp(pattern, flags)
+}

package/all/readable_stream_OR_reader/index.d.ts

@@ -0,0 +1,7 @@
+export type readable_stream_OR_reader_T =
+	{ getReader():ReadableStreamDefaultReader<any> }
+	|ReadableStreamDefaultReader
+	|ReadableStreamBYOBReader
+export type readable_stream_or_reader_T = readable_stream_OR_reader_T
+export declare type readable_reader_T = readable_stream_OR_reader_T
+export declare type line_iterator__readable_reader_T = readable_stream_OR_reader_T

package/all/readable_stream_OR_reader/index.js

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

package/all/reduce/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Returns reduced `memo` iterating over `a` with `fn(memo, a[], i, a)`.
+ */
+export declare function reduce<
+	I extends unknown = unknown, O extends unknown = unknown
+>(
+	a:readonly I[],
+	fn:reduce_fn_T<I, O>,
+	memo:O
+):O
+export declare type reduce_fn_T<
+	I extends unknown = unknown, O extends unknown = unknown
+> = (
+	memo:O, item:I, idx:number, a:readonly I[]
+)=>O
+export declare function maybe_reduce<
+	I extends unknown = unknown,
+	O extends unknown = unknown,
+	Or = null
+>(
+	maybe_a:readonly I[]|undefined,
+	fn:reduce_fn_T<I, O>,
+	memo:O,
+	or?:Or
+):O|Or
+/**
+ * Return Function that returns from `reduce` with `fn` and factory `memo_(a)`.
+ */
+export declare function reduce_<
+	I extends unknown = unknown, O extends unknown = unknown
+>(
+	fn:reduce_fn_T<I, O>, memo_:memo_fn_T<I, O>
+):(a:readonly I[], memo:O)=>O
+export declare type memo_fn_T<
+	I extends unknown = unknown, O extends unknown = unknown
+> =
+	(a:readonly I[])=>O
+export declare function maybe_reduce_<
+	I extends unknown = unknown,
+	O extends unknown = unknown,
+	Or = null
+>(
+	fn:reduce_fn_T<I, O|undefined>,
+	memo_fn:memo_fn_T<I, O>|undefined,
+	or?:Or
+):(a:readonly I[], memo:O)=>O|Or
+export {
+	reduce_ as _reduce,
+	reduce_ as _fn__reduce,
+	maybe_reduce_ as _maybe_reduce,
+}

package/all/reduce/index.js

@@ -0,0 +1,51 @@
+/** @typedef {import('../reduce/index.d.ts').reduce_fn_T}reduce_fn_T */
+/**
+ * Returns reduced `memo` iterating over `a` with `fn(memo, a[], i, a)`.
+ * @param {unknown[]}a
+ * @param {reduce_fn_T}fn
+ * @param {unknown}memo
+ * @returns {unknown}
+ */
+export function reduce(a, fn, memo) {
+	for (let i = 0; i < a.length; i++) {
+		const o = a[i]
+		memo = fn(memo, o, i, a)
+	}
+	return memo
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {reduce_fn_T}fn
+ * @param {unknown}memo
+ * @param {unknown}or
+ * @returns {unknown}
+ */
+export function maybe_reduce(
+	maybe_a, fn, memo, or = null
+) {
+	if (!maybe_a) return or
+	return reduce(maybe_a, fn, memo)
+}
+/**
+ * Return Function that returns from `reduce` with `fn` and factory `memo_(a)`.
+ * @param {reduce_fn_T}fn
+ * @param {memo_fn_T}memo_
+ * @returns {(a:unknown, memo:unknown)=>unknown}
+ */
+export function reduce_(fn, memo_) {
+	return (a, memo)=>a.reduce(fn, memo == null ? memo_ && memo_(a) : memo)
+}
+/**
+ * @param {reduce_fn_T}fn
+ * @param {memo_fn_T}memo_fn
+ * @param {unknown}or
+ * @returns {(a:unknown[], memo:unknown)=>unknown}
+ */
+export function maybe_reduce_(fn, memo_fn, or = null) {
+	return (a, memo)=>a ? a.reduce(fn, memo == null ? memo_fn && memo_fn(a) : memo) : or
+}
+export {
+	reduce_ as _reduce,
+	reduce_ as _fn__reduce,
+	maybe_reduce_ as _maybe_reduce,
+}

package/all/regex_indexOf/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @see {@link https://github.com/capaj/index-of-regex}
+ */
+/**
+ * indexOf with regex
+ */
+export declare function regex_indexOf(
+	str:string, regex:RegExp, in_startpos?:number
+):number
+export { regex_indexOf as indexOf__regex }

package/all/regex_indexOf/index.js

@@ -0,0 +1,14 @@
+/**
+ * indexOf with regex
+ * @param {str}str
+ * @param {RegExp}regex
+ * @param {number}in_startpos
+ * @returns {number}
+ * @see {@link https://github.com/capaj/index-of-regex}
+ */
+export function regex_indexOf(str, regex, in_startpos) {
+	const startpos = in_startpos || 0
+	const indexOf = str.substring(startpos).search(regex)
+	return indexOf >= 0 ? indexOf + startpos : indexOf
+}
+export { regex_indexOf as indexOf__regex }

package/all/regex_lastIndexOf/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * lastIndexOf with regex
+ */
+export declare function regex_lastIndexOf(
+	str:string, regex:RegExp, startpos?:number
+):number
+export { regex_lastIndexOf as lastIndexOf__regex }

package/all/regex_lastIndexOf/index.js

@@ -0,0 +1,25 @@
+/**
+ * lastIndexOf with regex
+ * @param {string}str
+ * @param {RegExp}regex
+ * @param {number}startpos
+ * @returns {number}
+ */
+export function regex_lastIndexOf(str, regex, startpos) {
+	regex = regex.global ? regex : new RegExp(regex.source, 'g' + (regex.ignoreCase ? 'i' : '') + (regex.multiline ? 'm' : ''))
+	if (typeof startpos === 'undefined') {
+		startpos = str.length
+	} else if (startpos < 0) {
+		startpos = 0
+	}
+	const stringToWorkWith = str.substring(0, startpos + 1)
+	let lastIndexOf = -1
+	let nextStop = 0
+	let result
+	while ((result = regex.exec(stringToWorkWith)) != null) {
+		lastIndexOf = result.index
+		regex.lastIndex = ++nextStop
+	}
+	return lastIndexOf
+}
+export { regex_lastIndexOf as lastIndexOf__regex }

package/all/reject/index.d.ts

@@ -0,0 +1,39 @@
+import type { is_match__T } from '../array_types/index.js'
+/**
+ * Returns Array of items not rejected by `fn`.
+ */
+export declare function reject<
+	Val extends unknown = unknown, Out extends unknown = readonly Val[]
+>(
+	a:readonly Val[], is_match_:is_match__T<Val>
+):Out
+export declare function maybe_reject<
+	Val extends unknown = unknown,
+	Out extends unknown = readonly Val[],
+	Or = null
+>(
+	maybe_a:readonly Val[]|undefined,
+	is_match_:is_match__T<Val>,
+	or?:Or
+):Out|Or
+/**
+ * Returns function that returns value from [reject](#reject) with `fn` argument.
+ */
+export declare function reject_<
+	I extends unknown = unknown, O extends unknown = readonly I[]
+>(
+	is_match_:is_match__T<I>
+):(a:readonly I[])=>O
+export declare function maybe_reject_<
+	I extends unknown = unknown,
+	O extends unknown = readonly I[],
+	Or = null
+>(
+	is_match_:is_match__T<I>,
+	or?:Or
+):(a:readonly I[]|undefined)=>O|Or
+export {
+	reject_ as _reject,
+	reject_ as _fn__reject,
+	maybe_reject_ as _maybe_reject,
+}

package/all/reject/index.js

@@ -0,0 +1,40 @@
+/** @typedef {import('../array_types/index.d.ts').is_match__T}is_match__T */
+/**
+ * Returns Array of items not rejected by `fn`.
+ * @param {unknown[]}a
+ * @param {is_match__T}is_match_
+ * @returns {unknown}
+ */
+export function reject(a, is_match_) {
+	return a.filter((value, idx)=>!is_match_(value, idx))
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {is_match__T}is_match_
+ * @param {unknown}or
+ * @returns {unknown}
+ */
+export function maybe_reject(maybe_a, is_match_, or = null) {
+	return maybe_a ? maybe_a.filter((value, idx)=>!is_match_(value, idx)) : or
+}
+/**
+ * Returns function that returns value from [reject](#reject) with `fn` argument.
+ * @param {is_match__T}is_match_
+ * @returns {(a:unknown[])=>unknown}
+ */
+export function reject_(is_match_) {
+	return a=>reject(a, is_match_)
+}
+/**
+ * @param {is_match__T}is_match_
+ * @param {unknown}or
+ * @returns {(a:unknown[]|undefined)=>unknown}
+ */
+export function maybe_reject_(is_match_, or = null) {
+	return a=>maybe_reject(a, is_match_, or)
+}
+export {
+	reject_ as _reject,
+	reject_ as _fn__reject,
+	maybe_reject_ as _maybe_reject,
+}

package/all/remove/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Remove each `...item_a` from `a`.
+ */
+export declare function remove<
+	I extends unknown = unknown, O extends unknown = readonly I[]
+>(
+	a:readonly I[],
+	...item_a:readonly I[]
+):O
+export declare function maybe_remove<
+	I extends unknown = unknown, O extends unknown = readonly I[]
+>(
+	maybe_a:readonly I[]|undefined,
+	...item_a:readonly I[]
+):O|undefined
+export { remove as remove__a1, }

package/all/remove/index.js

@@ -0,0 +1,27 @@
+import { remove_idx } from '../remove_idx/index.js'
+/**
+ * Remove each `...item_a` from `a`.
+ * @param {unknown[]}a
+ * @param {unknown}item_a
+ * @returns {unknown}
+ */
+export function remove(a, ...item_a) {
+	for (let i = 0; i < item_a.length; i++) {
+		const key = item_a[i]
+		let index
+		while ((index = a.lastIndexOf(key)) > -1) {
+			remove_idx(a, index)
+		}
+	}
+	return a
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {unknown}item_a
+ * @returns {unknown}
+ */
+export function maybe_remove(maybe_a, ...item_a) {
+	if (!maybe_a) return
+	return remove(maybe_a, ...item_a)
+}
+export { remove as remove__a1, }

package/all/remove_idx/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Remove `count = 1` items from `a` at position `idx`.
+ */
+export declare function remove_idx<
+	I extends unknown = unknown, O extends unknown = readonly I[]
+>(
+	a:readonly I[], idx:number, count?:number
+):O
+export {
+	remove_idx as remove__idx,
+	remove_idx as remove__index,
+}

package/all/remove_idx/index.js

@@ -0,0 +1,14 @@
+/**
+ * Remove `count = 1` items from `a` at position `idx`.
+ * @param {unknown[]}a
+ * @param {number}idx
+ * @param {number}count
+ * @returns {unknown[]}
+ */
+export function remove_idx(a, idx, count = 1) {
+	return a.splice(idx, count)
+}
+export {
+	remove_idx as remove__idx,
+	remove_idx as remove__index,
+}

package/all/resolver_curry/index.d.ts

@@ -0,0 +1,6 @@
+export type resolver_curry_T<ResolverArg extends unknown = unknown> = (
+	...resolver_arg_a:ResolverArg[]
+)=>resolver_curry_T<ResolverArg>
+export type append_current_T<ResolverArg extends unknown = unknown> = (
+	local:ResolverArg[], arg_a:ResolverArg[]
+)=>any

package/all/resolver_curry/index.js

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

package/all/response_o/index.d.ts

@@ -0,0 +1,10 @@
+export declare function response_o__new(response:Response):response_o_T
+export interface response_o_T {
+	headers:Headers
+	ok:boolean
+	redirected:boolean
+	status:number
+	statusText:string
+	type:ResponseType
+	url:string
+}