ctx-core 2.2.0 → 2.2.2

package/all/promise_timeout/index.js

@@ -0,0 +1,23 @@
+/**
+ * @param {(()=>Promise<unknown>)|Promise<unknown>}promise
+ * @param {number}ms
+ * @param {Error}[error]
+ * @returns {Promise<unknown>}
+ */
+export async function promise_timeout(
+	promise,
+	ms,
+	error = new Error(`Timed out after ${ms}ms.`),
+) {
+	let id
+	let timeout = new Promise((_resolve, reject)=>{
+		id = setTimeout(()=>reject(error), ms)
+	})
+	return Promise.race([
+		typeof promise === 'function' ? promise() : promise,
+		timeout
+	]).then(result=>{
+		clearTimeout(id)
+		return result
+	})
+}

package/all/prototype_mixin/index.d.ts

@@ -0,0 +1,8 @@
+export declare function prototype_mixin<
+	target_T extends Function&{ prototype:object },
+	source_T extends Function&{ prototype:object },
+	out_T extends Function&{ prototype:object } = target_T&{ prototype:target_T['prototype']&source_T['prototype'] },
+>(
+	target:target_T,
+	source:source_T
+):out_T

package/all/prototype_mixin/index.js

@@ -0,0 +1,20 @@
+/**
+ * @param {Function&{ prototype:object }}target
+ * @param {Function&{ prototype:object }}source
+ * @returns {Function&{ prototype:object }}
+ */
+export function prototype_mixin(target, source) {
+	const target_prototype = target.prototype
+	const source_prototype = source.prototype
+	const propertyNames = Object.getOwnPropertyNames(source_prototype)
+	for (let i = 0; i < propertyNames.length; i++) {
+		const propertyName = propertyNames[i]
+		if (propertyName !== 'constructor') {
+			Object.defineProperty(
+				target_prototype,
+				propertyName,
+				Object.getOwnPropertyDescriptor(source_prototype, propertyName))
+		}
+	}
+	return target
+}

package/all/push/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Calls push on an array
+ */
+export declare function push<
+	I extends unknown = unknown
+>(
+	a:readonly I[],
+	...arg_a:readonly I[]
+):number
+export declare function maybe_push<
+	I extends unknown = unknown
+>(
+	maybe_a:readonly I[]|undefined,
+	...arg_a:readonly I[]
+):number|undefined

package/all/push/index.js

@@ -0,0 +1,17 @@
+/**
+ * Calls push on an array
+ * @param {unknown[]}a
+ * @param {unknown}arg_a
+ * @returns {number}
+ */
+export function push(a, ...arg_a) {
+	return a.push.apply(a, arg_a)
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {unknown}arg_a
+ * @returns {number|undefined}
+ */
+export function maybe_push(maybe_a, ...arg_a) {
+	return maybe_a ? push(maybe_a, ...arg_a) : void 0
+}

package/all/quantile/index.d.ts

@@ -0,0 +1,5 @@
+export declare function quantile_<Bound extends readonly number[]>(
+	a:readonly number[], bound_a:Bound, sorted_?:typeof quantile_sorted_
+):Bound
+export declare function quantile_sorted_(a:readonly number[]):number[]
+export { quantile_ as quantile }

package/all/quantile/index.js

@@ -0,0 +1,16 @@
+import { isNumber } from '../isNumber/index.js'
+export function quantile_(a, bound_a, sorted_ = quantile_sorted_) {
+	const sorted = sorted_(a)
+	return bound_a.map((q)=>{
+		if (sorted.length === 0) return 0
+		const pos = Math.floor((sorted.length - 1) * q)
+		const base = pos
+		const rest = pos - base
+		return sorted[base + 1] !== undefined ? sorted[base] + rest * (sorted[base + 1] - sorted[base]) : sorted[base]
+	})
+}
+export function quantile_sorted_(a) {
+	return a.filter(isNumber).sort((val0, val1)=>val0 - val1
+	)
+}
+export { quantile_ as quantile }

package/all/query_str/index.d.ts

@@ -0,0 +1,27 @@
+export declare function query_str_(
+	query?:query_T,
+	prefix?:string
+):string
+export {
+	query_str_ as _str__query,
+	query_str_ as _query_str,
+}
+export declare type query_T =
+	string|
+	{
+		[key:string]:query_value_T
+	}|
+	Record<string, query_value_T>|
+	Map<string, query_value_T>
+export declare type query_value_T =
+	string
+	|number
+	|boolean
+	|string[]
+	|number[]
+	|boolean[]
+	|(string|number)[]
+	|(string|boolean)[]
+	|(number|boolean)[]
+	|(string|number|boolean)[]
+export declare type query_type = query_T

package/all/query_str/index.js

@@ -0,0 +1,46 @@
+import { isArray } from '../isArray/index.js'
+/**
+ * @param {import('./index.d.ts').query_T}[query]
+ * @param {string}[prefix]
+ * @returns {string}
+ * @private
+ */
+export function query_str_(
+	query = '',
+	prefix = query[0] === '?' ? '' : '?'
+) {
+	if (typeof query === 'string') return `${prefix}${query}`
+	const query_str_a = []
+	if (query instanceof Map) {
+		for (let [key, val] of query.entries()) {
+			query_str_a__push(key, val)
+		}
+	} else {
+		for (let key in query) {
+			query_str_a__push(key, query[key])
+		}
+	}
+	return query_str_a.length ? `${prefix}${query_str_a.join('&')}` : ''
+	/**
+	 * @param {string}key
+	 * @param {import('./index.d.ts').query_value_T}in_query_value
+	 */
+	function query_str_a__push(
+		key,
+		in_query_value
+	) {
+		const query_value =
+			in_query_value == null ? '' : in_query_value
+		if (isArray(query_value)) {
+			for (const $value_item of query_value) {
+				query_str_a.push(`${encodeURIComponent(key)}[]=${encodeURIComponent($value_item)}`)
+			}
+		} else {
+			query_str_a.push(`${encodeURIComponent(key)}=${encodeURIComponent(query_value)}`)
+		}
+	}
+}
+export {
+	query_str_ as _str__query,
+	query_str_ as _query_str,
+}

package/all/query_str/index.test.ts

@@ -0,0 +1,43 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import type { query_value_T } from './index.js'
+import { query_str_ } from './index.js'
+test('query_str_|interface', ()=>{
+	equal(
+		query_str_({
+			number: 1, string: 'a', boolean: true,
+			number_a: [1, 2, 3], string_a: ['a', 'b', 'c'],
+			string_or_number_a: ['a', 1],
+			string_or_boolean_a: ['a', true],
+			number_or_boolean_a: [true, 1],
+			string_or_number_or_boolean_a: ['a', true, 1],
+		} as query_I),
+		'?number=1&string=a&boolean=true&number_a[]=1&number_a[]=2&number_a[]=3&string_a[]=a&string_a[]=b&string_a[]=c&string_or_number_a[]=a&string_or_number_a[]=1&string_or_boolean_a[]=a&string_or_boolean_a[]=true&number_or_boolean_a[]=true&number_or_boolean_a[]=1&string_or_number_or_boolean_a[]=a&string_or_number_or_boolean_a[]=true&string_or_number_or_boolean_a[]=1'
+	)
+})
+test('query_str_|record', ()=>{
+	equal(
+		query_str_({
+			number: 1, string: 'a', boolean: true,
+			number_a: [1, 2, 3], string_a: ['a', 'b', 'c'],
+			string_or_number_a: ['a', 1],
+			string_or_boolean_a: ['a', true],
+			number_or_boolean_a: [true, 1],
+			string_or_number_or_boolean_a: ['a', true, 1],
+		}),
+		'?number=1&string=a&boolean=true&number_a[]=1&number_a[]=2&number_a[]=3&string_a[]=a&string_a[]=b&string_a[]=c&string_or_number_a[]=a&string_or_number_a[]=1&string_or_boolean_a[]=a&string_or_boolean_a[]=true&number_or_boolean_a[]=true&number_or_boolean_a[]=1&string_or_number_or_boolean_a[]=a&string_or_number_or_boolean_a[]=true&string_or_number_or_boolean_a[]=1'
+	)
+})
+test.run()
+interface query_I {
+	[key:string]:query_value_T
+	number:number
+	string:string
+	boolean:boolean
+	number_a:number[]
+	string_a:string[]
+	string_or_number_a:(string|number)[]
+	string_or_boolean_a:(string|boolean)[]
+	number_or_boolean_a:(boolean|number)[]
+	string_or_number_or_boolean_a:(string|boolean|number)[]
+}

package/all/query_str__searchParams/index.d.ts

@@ -0,0 +1 @@
+export declare function query_str__searchParams_(query_str:string):URLSearchParams

package/all/query_str__searchParams/index.js

@@ -0,0 +1,8 @@
+/**
+ * @param {string}query_str
+ * @returns {URLSearchParams}
+ * @private
+ */
+export function query_str__searchParams_(query_str) {
+	return new URL(`https://no-domain.ai${query_str}`).searchParams
+}

package/all/query_str__searchParams_o/index.d.ts

@@ -0,0 +1,3 @@
+export declare function query_str__searchParams_o_<
+	O extends object = object
+>(query_str:string):O

package/all/query_str__searchParams_o/index.js

@@ -0,0 +1,11 @@
+import { query_str__searchParams_ } from '../query_str__searchParams/index.js'
+import { searchParams_o_ } from '../searchParams_o/index.js'
+/**
+ * @param {string}query_str
+ * @returns {URLSearchParams}
+ * @private
+ */
+export function query_str__searchParams_o_(query_str) {
+	const searchParams = query_str__searchParams_(query_str)
+	return searchParams_o_(searchParams)
+}

package/all/queue/index.d.ts

@@ -0,0 +1,23 @@
+export declare function queue_(
+	queue_size?:number
+):queue_T
+export { queue_ as _queue, }
+export interface queue_T {
+	add<Out>(fn:()=>Promise<Out>):Promise<Out>
+	add_sync<Out>(fn:()=>Promise<Out>):number
+	close():Promise<number>
+	cancel():number
+	get pending():number
+	throttle(
+		max_item_count_OR_throttle__continue_:
+			number
+			|((item_count:number)=>boolean)
+	):Promise<number>
+	get item_count():number
+}
+export interface queue_waiting_T {
+	fn:()=>Promise<any>
+	fulfil:(v:any)=>void
+	reject:(err:any)=>void
+}
+export type queue_item_T = queue_waiting_T

package/all/queue/index.js

@@ -0,0 +1,130 @@
+import { noop } from '../noop/index.js'
+const default_queue_size = 4
+/**
+ * @param queue_size
+ * @returns {queue_T}
+ * @private
+ */
+export function queue_(
+	queue_size = default_queue_size
+) {
+	if (!queue_size) queue_size = default_queue_size
+	const waiting_a = []
+	let pending = 0
+	let closed = false
+	let close__resolve
+	let cancelled = false
+	/** @type {Set<(item_count:number)=>void>} */
+	const throttle__subscriber_S = new Set()
+	let processed__count = 0
+	return /** @type {queue_T} */{
+		add(fn) {
+			if (closed) {
+				throw new Error('Cannot add to a closed queue')
+			}
+			return new Promise((resolve, reject)=>{
+				waiting_a.push({ fn, resolve, reject })
+				throttle__notify()
+				dequeue()
+			})
+		},
+		add_sync(fn) {
+			if (closed) {
+				throw new Error('Cannot add to a closed queue')
+			}
+			waiting_a.push({ fn, resolve: noop, reject: noop })
+			throttle__notify()
+			dequeue()
+			return item_count_()
+		},
+		close() {
+			closed = true
+			return new Promise(resolve=>{
+				if (pending) {
+					close__resolve = resolve
+				} else {
+					resolve(processed__count)
+				}
+			})
+		},
+		cancel() {
+			closed = true
+			cancelled = true
+			if (close__resolve) close__resolve(processed__count)
+			return pending
+		},
+		get pending() {
+			return pending
+		},
+		get item_count() {
+			return item_count_()
+		},
+		/**
+		 * @param {number|((item_count:number)=>boolean)}max_item_count_OR_throttle__continue_
+		 * @returns {Promise<number>}
+		 */
+		throttle(max_item_count_OR_throttle__continue_) {
+			const throttle__continue_ =
+				typeof max_item_count_OR_throttle__continue_ === 'function'
+					? max_item_count_OR_throttle__continue_
+					: item_count=>item_count <= max_item_count_OR_throttle__continue_
+			let resolve
+			const pending__wait__promise =
+				new Promise(res=>{
+					resolve = res
+				})
+			const throttle__subscriber =
+				item_count=>{
+					if (throttle__continue_(item_count)) {
+						throttle__subscriber_S.delete(throttle__subscriber)
+						resolve(item_count)
+					}
+				}
+			throttle__subscriber_S.add(throttle__subscriber)
+			throttle__subscriber(item_count_())
+			return pending__wait__promise
+		}
+	}
+	function item_count_() {
+		return pending + waiting_a.length
+	}
+	function dequeue() {
+		if (cancelled) return
+		if (pending >= queue_size) return
+		if (!waiting_a.length) {
+			if (!pending && close__resolve) close__resolve(processed__count)
+			return
+		}
+		pending++
+		const { fn, resolve, reject } = waiting_a.shift()
+		const promise = fn()
+		try {
+			promise
+				.then($res=>{
+					if (!cancelled) return resolve($res)
+				}, $rej=>{
+					if (!cancelled) return reject($rej)
+				})
+				.then(()=>{
+					processed__count++
+					if (!cancelled) pending__decrement()
+					dequeue()
+				})
+		} catch (err) {
+			reject(err)
+			pending__decrement()
+			dequeue()
+		}
+		dequeue()
+	}
+	function pending__decrement() {
+		pending--
+		throttle__notify()
+	}
+	function throttle__notify() {
+		const item_count = item_count_()
+		throttle__subscriber_S.forEach(throttle__subscriber=>
+			throttle__subscriber(item_count))
+	}
+}
+export { queue_ as _queue, }

package/all/queue/index.test.ts

@@ -0,0 +1,207 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { promise_o_ } from '../promise_o/index.js'
+import { queue_ } from '../queue/index.js'
+import { run } from '../run/index.js'
+import { tick } from '../tick/index.js'
+test('queue_(1).add|queue length of 1 at a time', async ()=>{
+	const queue = queue_(1)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
+	const ret_a:any[] = [null, null, null]
+	queue.add(()=>promise_o_a[0].promise).then(ret=>ret_a[0] = ret)
+	queue.add(()=>promise_o_a[1].promise).then(ret=>ret_a[1] = ret)
+	queue.add(()=>promise_o_a[2].promise).then(ret=>ret_a[2] = ret)
+	equal(ret_a, [null, null, null])
+	promise_o_a[1].resolve('val1')
+	await tick()
+	equal(ret_a, [null, null, null])
+	promise_o_a[0].resolve('val0')
+	await tick()
+	equal(ret_a, ['val0', null, null])
+	await tick()
+	equal(ret_a, ['val0', 'val1', null])
+	promise_o_a[2].resolve('val2')
+	await tick()
+	equal(ret_a, ['val0', 'val1', 'val2'])
+	const close__promise__arg_aa:any[][] = []
+	queue.close()
+	.then((...arg_a)=>
+		close__promise__arg_aa.push(arg_a))
+	await tick()
+	equal(close__promise__arg_aa, [[3]])
+})
+test('queue_(2).add|queue length of 2 at a time', async ()=>{
+	const queue = queue_(2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_(), promise_o_()]
+	const ret_a:any[] = [null, null, null, null]
+	queue.add(()=>promise_o_a[0].promise).then(ret=>ret_a[0] = ret)
+	queue.add(()=>promise_o_a[1].promise).then(ret=>ret_a[1] = ret)
+	queue.add(()=>promise_o_a[2].promise).then(ret=>ret_a[2] = ret)
+	queue.add(()=>promise_o_a[3].promise).then(ret=>ret_a[3] = ret)
+	equal(ret_a, [null, null, null, null])
+	promise_o_a[2].resolve('val2')
+	await tick()
+	equal(ret_a, [null, null, null, null])
+	promise_o_a[3].resolve('val3')
+	await tick()
+	equal(ret_a, [null, null, null, null])
+	promise_o_a[0].resolve('val0')
+	await tick()
+	equal(ret_a, ['val0', null, null, null])
+	await tick()
+	equal(ret_a, ['val0', null, 'val2', null])
+	await tick()
+	equal(ret_a, ['val0', null, 'val2', 'val3'])
+	promise_o_a[1].resolve('val1')
+	await tick()
+	equal(ret_a, ['val0', 'val1', 'val2', 'val3'])
+	const close__promise__arg_aa:any[][] = []
+	queue.close()
+	.then((...arg_a)=>
+		close__promise__arg_aa.push(arg_a))
+	await tick()
+	equal(close__promise__arg_aa, [[4]])
+})
+test('queue_(1).add_sync|queue length of 1 at a time', async ()=>{
+	const queue = queue_(1)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
+	const ret_a:any[] = [null, null, null]
+	ret_a[0] = queue.add_sync(()=>promise_o_a[0].promise)
+	equal(ret_a, [1, null, null])
+	ret_a[1] = queue.add_sync(()=>promise_o_a[1].promise)
+	equal(ret_a, [1, 2, null])
+	ret_a[2] = queue.add_sync(()=>promise_o_a[2].promise)
+	equal(ret_a, [1, 2, 3])
+})
+test('queue_(2).add_sync|queue length of 2 at a time', async ()=>{
+	const queue = queue_(2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_(), promise_o_()]
+	const ret_a:any[] = [null, null, null, null]
+	ret_a[0] = queue.add_sync(()=>promise_o_a[0].promise)
+	equal(ret_a, [1, null, null, null])
+	ret_a[1] = queue.add_sync(()=>promise_o_a[1].promise)
+	equal(ret_a, [1, 2, null, null])
+	ret_a[2] = queue.add_sync(()=>promise_o_a[2].promise)
+	equal(ret_a, [1, 2, 3, null])
+	ret_a[3] = queue.add_sync(()=>promise_o_a[3].promise)
+	equal(ret_a, [1, 2, 3, 4])
+})
+test('queue_(2).cancel|immediately stops queue discarding pending jobs|returns pending count', async ()=>{
+	const queue = queue_(2)
+	let pending:number|undefined = undefined
+	const promise_o_a = [
+		promise_o_(),
+		run(()=>{
+			const promise_o = promise_o_()
+			promise_o.promise.then($=>{
+				pending = queue.cancel()
+				return $
+			})
+			return promise_o
+		}),
+		promise_o_(),
+		promise_o_()
+	]
+	const ret_a:any[] = [null, null, null, null]
+	queue.add(()=>promise_o_a[0].promise).then(ret=>ret_a[0] = ret)
+	queue.add(()=>promise_o_a[1].promise).then(ret=>ret_a[1] = ret)
+	queue.add(()=>promise_o_a[2].promise).then(ret=>ret_a[2] = ret)
+	queue.add(()=>promise_o_a[3].promise).then(ret=>ret_a[3] = ret)
+	const close__promise__arg_aa:any[][] = []
+	queue.close()
+	.then((...arg_a)=>
+		close__promise__arg_aa.push(arg_a))
+	equal(ret_a, [null, null, null, null])
+	equal(pending, undefined)
+	equal(close__promise__arg_aa, [])
+	promise_o_a[2].resolve('val2')
+	await tick()
+	equal(ret_a, [null, null, null, null])
+	equal(pending, undefined)
+	equal(close__promise__arg_aa, [])
+	promise_o_a[3].resolve('val3')
+	await tick()
+	equal(ret_a, [null, null, null, null])
+	equal(pending, undefined)
+	equal(close__promise__arg_aa, [])
+	promise_o_a[1].resolve('val1')
+	await tick()
+	equal(ret_a, [null, null, null, null])
+	equal(pending, 2)
+	equal(close__promise__arg_aa, [[0]])
+})
+test('throttle|number', async ()=>{
+	const queue = queue_(2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_(), promise_o_(), promise_o_()]
+	promise_o_a.map(pending_o=>queue.add(()=>pending_o.promise))
+	const pending__wait__arg_aa:any[][] = []
+	const throttle__then = (...arg_a:any[])=>{
+		pending__wait__arg_aa.push(arg_a)
+	}
+	queue.throttle(5)
+	.then(throttle__then)
+	await tick()
+	equal(pending__wait__arg_aa, [[5]])
+	queue.throttle(3)
+	.then(throttle__then)
+	await tick()
+	equal(pending__wait__arg_aa, [[5]])
+	promise_o_a[0].resolve(true)
+	await tick()
+	await tick()
+	equal(pending__wait__arg_aa, [[5]])
+	promise_o_a[1].resolve(true)
+	await tick()
+	await tick()
+	equal(pending__wait__arg_aa, [[5], [3]])
+})
+test('throttle|fn', async ()=>{
+	const queue = queue_(2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_(), promise_o_(), promise_o_()]
+	promise_o_a.map(pending_o=>queue.add(()=>pending_o.promise))
+	const pending__wait__arg_aa:any[][] = []
+	const throttle__then = (...arg_a:any[])=>{
+		pending__wait__arg_aa.push(arg_a)
+	}
+	queue.throttle(item_count=>
+		item_count <= 5
+	).then(throttle__then)
+	await tick()
+	equal(pending__wait__arg_aa, [[5]])
+	queue.throttle(item_count=>
+		item_count <= 3
+	).then(throttle__then)
+	await tick()
+	equal(pending__wait__arg_aa, [[5]])
+	promise_o_a[0].resolve(true)
+	await tick()
+	await tick()
+	equal(pending__wait__arg_aa, [[5]])
+	promise_o_a[1].resolve(true)
+	await tick()
+	await tick()
+	equal(pending__wait__arg_aa, [[5], [3]])
+})
+test('pending', async ()=>{
+	const queue = queue_(2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
+	equal(queue.pending, 0)
+	queue.add(()=>promise_o_a[0].promise).then()
+	equal(queue.pending, 1)
+	queue.add(()=>promise_o_a[1].promise).then()
+	equal(queue.pending, 2)
+	queue.add(()=>promise_o_a[2].promise).then()
+	equal(queue.pending, 2)
+})
+test('item_count', async ()=>{
+	const queue = queue_(2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
+	equal(queue.item_count, 0)
+	queue.add(()=>promise_o_a[0].promise).then()
+	equal(queue.item_count, 1)
+	queue.add(()=>promise_o_a[1].promise).then()
+	equal(queue.item_count, 2)
+	queue.add(()=>promise_o_a[2].promise).then()
+	equal(queue.item_count, 3)
+})
+test.run()

package/all/rPad/index.d.ts

@@ -0,0 +1 @@
+export declare function rPad(str:string, padString:string, length:number):string

package/all/rPad/index.js

@@ -0,0 +1,11 @@
+/**
+ * @param {string}str
+ * @param {string}padString
+ * @param {number}length
+ * @returns {string}
+ */
+export function rPad(str, padString, length) {
+	let str2 = str.toString()
+	while (str2.length < length) str2 = str2 + padString
+	return str2
+}

package/all/r_val_a/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns Array of `obj[key_a[]]`.
+ */
+export declare function r_val_a_<
+	Val extends unknown = unknown
+>(
+	obj:Record<string, Val>,
+	key_a?:readonly string[]
+):Val[]
+export declare function maybe_r_val_a_<
+	Val extends unknown = unknown, Or = null
+>(
+	obj:Record<string, Val>|undefined,
+	key_a?:readonly string[],
+	or?:Or
+):Val[]|Or
+export {
+	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_a1_from_val_a1_fn,
+	maybe_r_val_a_ as _maybe_key_a1_from_val_a1,
+}