ctx-core 2.2.0 → 2.2.2

package/all/value_r/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Returns a Hash with a key for each item in `value_a` & value set to the return of `value_`.
+ */
+export declare function value_r_<
+	Out extends unknown = unknown
+>(
+	in_key_a:readonly string[]|undefined,
+	value_:(key:string, i:number)=>Out
+):Record<string, Out>
+export {
+	value_r_ as value_h_,
+	value_r_ as value_hash_fn,
+	value_r_ as _value_hash,
+	value_r_ as _hash__value,
+}
+/**
+ * Returns a Function that returns from [_value_hash](#_value_hash).
+ */
+export declare function value_r_2<
+	Out extends unknown = unknown
+>(
+	value_:(key:string, idx:number)=>Out
+):(value_a:readonly string[])=>Record<string, Out>
+export {
+	value_r_2 as value_h_2,
+	value_r_2 as value_hash_fn2,
+	value_r_2 as _value_hash_fn,
+	value_r_2 as _fn__hash__value,
+}

package/all/value_r/index.js

@@ -0,0 +1,37 @@
+/**
+ * Returns a Hash with a key for each item in `value_a` & value set to the return of `value_`.
+ * @param {string[]|undefined}in_key_a
+ * @param {(key:string, i:number)=>unknown}value_
+ * @returns {Record<string, unknown>}
+ */
+export function value_r_(in_key_a, value_) {
+	const value_r = {}
+	if (in_key_a) {
+		const key_a = in_key_a
+		for (let i = 0; i < key_a.length; i++) {
+			const key = key_a[i]
+			value_r[key] = value_(key, i)
+		}
+	}
+	return value_r
+}
+export {
+	value_r_ as value_h_,
+	value_r_ as value_hash_fn,
+	value_r_ as _value_hash,
+	value_r_ as _hash__value,
+}
+/**
+ * Returns a Function that returns from [_value_hash](#_value_hash).
+ * @param value_{(key:string, idx:number)=>unknown}
+ * @returns {(value_a:string[])=>Record<string, unknown>}
+ */
+export function value_r_2(value_) {
+	return value_a=>value_r_(value_a, value_)
+}
+export {
+	value_r_2 as value_h_2,
+	value_r_2 as value_hash_fn2,
+	value_r_2 as _value_hash_fn,
+	value_r_2 as _fn__hash__value,
+}

package/all/valueof/index.d.ts

@@ -0,0 +1 @@
+export declare type valueof<T> = T[keyof T]

package/all/valueof/index.js

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

package/all/values/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Object values
+ * @function values
+ */
+export const values:typeof Object.values

package/all/values/index.js

@@ -0,0 +1,5 @@
+/**
+ * Object values
+ * @type {unknown[]}
+ */
+export const values = Object.values.bind(Object)

package/all/waitfor/index.d.ts

@@ -0,0 +1,5 @@
+export declare function waitfor(
+	fn:()=>Promise<boolean>|boolean,
+	timeout:number,
+	period?:number
+):Promise<void>

package/all/waitfor/index.js

@@ -0,0 +1,16 @@
+import { promise_timeout } from '../promise_timeout/index.js'
+import { sleep } from '../sleep/index.js'
+/**
+ * @param {()=>Promise<boolean>}fn
+ * @param {unknown}timeout
+ * @param {unknown}[period]
+ * @returns {Promise<void>}
+ */
+export async function waitfor(fn, timeout, period = 0) {
+	await promise_timeout(async ()=>{
+		for (; ;) {
+			if (await fn()) return
+			await sleep(period)
+		}
+	}, timeout)
+}

package/all/waitfor_fibonacci_backoff/index.d.ts

@@ -0,0 +1,8 @@
+export declare function waitfor_fibonacci_backoff(
+	fn:()=>Promise<Response>,
+	delay?:number
+):Promise<Response>
+export {
+	waitfor_fibonacci_backoff as waitfor__backoff__fibonacci,
+	waitfor_fibonacci_backoff as _waitfor__ratelimit__backoff__fibonacci,
+}

package/all/waitfor_fibonacci_backoff/index.js

@@ -0,0 +1,27 @@
+import { fibonacci_number_ } from '../fibonacci_number/index.js'
+import { sleep } from '../sleep/index.js'
+/**
+ * @param {()=>Promise<Response>}fn
+ * @param {number}[delay]
+ * @returns {Promise<Response>}
+ */
+export async function waitfor_fibonacci_backoff(fn, delay = 500) {
+	let response
+	let delay_n = 1
+	while (true) {
+		response = await fn()
+		if (response.status === 429) {
+			const fibonacci_number = fibonacci_number_(delay_n)
+			const _delay = fibonacci_number * 500
+			delay = delay + _delay
+			await sleep(delay)
+			delay_n++
+			continue
+		}
+		return response
+	}
+}
+export {
+	waitfor_fibonacci_backoff as waitfor__backoff__fibonacci,
+	waitfor_fibonacci_backoff as _waitfor__ratelimit__backoff__fibonacci,
+}

package/all/waitfor_val/index.d.ts

@@ -0,0 +1,6 @@
+export declare function waitfor_val<Val>(
+	fn:()=>Promise<Val>,
+	condition_fn:(val:Val)=>any,
+	timeout:number,
+	period?:number
+):Promise<Val>

package/all/waitfor_val/index.js

@@ -0,0 +1,20 @@
+import { promise_timeout } from '../promise_timeout/index.js'
+import { sleep } from '../sleep/index.js'
+/**
+ * @param {()=>Promise<unknown>}fn
+ * @param {(val:unknown)=>unknown}condition_fn
+ * @param {number}timeout
+ * @param {number}[period]
+ * @returns {Promise<unknown>}
+ */
+export async function waitfor_val(
+	fn, condition_fn, timeout, period = 0
+) {
+	return await promise_timeout(async ()=>{
+		for (; ;) {
+			const val = await fn()
+			if (condition_fn(val)) return val
+			await sleep(period)
+		}
+	}, timeout)
+}

package/all/weak_r/index.d.ts

@@ -0,0 +1,28 @@
+import type { keyof_T } from '../keyof/index.js'
+declare const add_strong_sym:unique symbol
+declare const delete_strong_sym:unique symbol
+export declare function weak_r_<
+	Obj extends object = object
+>(back_o?:{}):Obj
+export { weak_r_ as weak_ctx_, }
+export declare function strong__call<
+	Obj extends weak_r_T
+>(obj:Obj, prop:keyof_T):void
+export { strong__call as ref_strong }
+export declare function strong__assign<
+	Obj extends weak_r_T,
+	Val extends unknown = unknown
+>(obj:Obj, prop:keyof_T, val:Val):void
+export { strong__assign as set_strong }
+export declare function weak__call<
+	Obj extends weak_r_T
+>(obj:Obj, prop:keyof_T):void
+export { weak__call as ref_weak }
+export declare function weak__unset<
+	Obj extends weak_r_T
+>(obj:Obj, prop:keyof_T):void
+export { weak__unset as unset_weak }
+export interface weak_r_T {
+	[add_strong_sym](prop:keyof_T, key?:any):void
+	[delete_strong_sym](prop:keyof_T):void
+}

package/all/weak_r/index.js

@@ -0,0 +1,87 @@
+import { assign } from '../assign/index.js'
+/** @typedef {import('../weak_r/index.d.ts').weak_r_T}weak_r_T */
+const { get } = Reflect
+const add_strong_sym = Symbol('add_strong')
+const delete_strong_sym = Symbol('delete_strong')
+/**
+ * @param {object}[back_o]
+ * @returns {object}
+ * @private
+ */
+export function weak_r_(back_o = {}) {
+	const strong_set = new Set()
+	assign(back_o, {
+		[add_strong_sym](key) {
+			strong_set.add(key)
+		},
+		[delete_strong_sym](key) {
+			strong_set.delete(key)
+		}
+	})
+	const proxy_o = new Proxy(back_o, {
+		getOwnPropertyDescriptor(back_ctx, prop) {
+			let value = get(back_ctx, prop)
+			if ((value === null || value === void 0 ? void 0 : value.deref) && !strong_set.has(prop)) {
+				value = value.deref()
+			}
+			return value === undefined ? undefined : {
+				configurable: true,
+				enumerable: true,
+				value,
+				writable: true
+			}
+		},
+		get(back_ctx, prop) {
+			const uw_val = get(back_ctx, prop)
+			return (uw_val === null || uw_val === void 0 ? void 0 : uw_val.deref) && !strong_set.has(prop) ? uw_val.deref() : uw_val
+		},
+		set(back_ctx, prop, val) {
+			const t = typeof val
+			assign(back_ctx, {
+				[prop]: (t === 'object' || t === 'function') && !strong_set.has(prop) ? new WeakRef(val) : val
+			})
+			return true
+		}
+	})
+	return proxy_o
+}
+export { weak_r_ as weak_ctx_, }
+/**
+ * @param {weak_r_T}obj
+ * @param {string}prop
+ */
+export function strong__call(obj, prop) {
+	obj[add_strong_sym](prop)
+}
+export { strong__call as ref_strong }
+/**
+ * @param {weak_r_T}obj
+ * @param {string}prop
+ * @param {unknown}val
+ */
+export function strong__assign(obj, prop, val) {
+	strong__call(obj, prop)
+	if (val !== undefined) {
+		assign(obj, {
+			[prop]: val
+		})
+	}
+}
+export { strong__assign as set_strong }
+/**
+ * @param {weak_r_T}obj
+ * @param {string}prop
+ */
+export function weak__call(obj, prop) {
+	obj[delete_strong_sym](prop)
+}
+export { weak__call as ref_weak }
+/**
+ * @param {weak_r_T}obj
+ * @param {string}prop
+ */
+export function weak__unset(obj, prop) {
+	weak__call(obj, prop)
+	delete obj[prop]
+}
+export { weak__unset as unset_weak }

package/all/week/index.d.ts

@@ -0,0 +1 @@
+export declare const week:number

package/all/week/index.js

@@ -0,0 +1,2 @@
+import { day } from '../day/index.js'
+export const week = 7 * day

package/all/wrap_a/index.d.ts

@@ -0,0 +1,32 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+import type { wrap_aa_T } from '../wrap_aa/index.js'
+/**
+ * Returns `value` if array & `[value]` otherwise
+ */
+export declare function wrap_a_<
+	I extends unknown = unknown
+>(
+	value:a_nowrap_T<I>
+):wrap_a_T<I>
+export {
+	wrap_a_ as wrap_a1_,
+	wrap_a_ as wrap_a_fn,
+	wrap_a_ as wrap_a1_fn,
+	wrap_a_ as _wrap_a1,
+	wrap_a_ as _a1__wrap,
+}
+export declare type wrap_a_T<
+	I extends unknown = unknown
+> =
+	I extends readonly unknown[]
+		? I
+		: readonly I[]
+export declare type wrap_a1_T = wrap_a_T
+export declare type wrap_a1_type = wrap_a_T
+export declare type wrap_a_T2<
+	I extends unknown = unknown
+> =
+	readonly I[]
+	|readonly I[][]
+	|wrap_a_T<I>
+	|wrap_aa_T<I>

package/all/wrap_a/index.js

@@ -0,0 +1,19 @@
+const { isArray } = Array
+/**
+ * Returns `value` if array & `[value]` otherwise
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}value
+ * @returns {import('../_function_types/index.js').wrap_a_T}
+ * @private
+ */
+export function wrap_a_(value) {
+	return isArray(value) ? value : [
+		value
+	]
+}
+export {
+	wrap_a_ as wrap_a1_,
+	wrap_a_ as wrap_a_fn,
+	wrap_a_ as wrap_a1_fn,
+	wrap_a_ as _wrap_a1,
+	wrap_a_ as _a1__wrap,
+}

package/all/wrap_a_item/index.d.ts

@@ -0,0 +1,5 @@
+import type { wrap_a_T } from '../wrap_a/index.js'
+export declare type wrap_a_item_T<
+	I extends unknown = unknown
+> = wrap_a_T<I> extends readonly (infer O)[][] ? O : never
+export declare type wrap_a1_item_type = wrap_a_item_T

package/all/wrap_a_item/index.js

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

package/all/wrap_aa/index.d.ts

@@ -0,0 +1,23 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+/**
+ * Returns `wrap_aa_T` wrapped as a 2-dimensional array
+ */
+export declare function wrap_aa_<
+	I extends unknown = unknown
+>(
+	a_nowrap:a_nowrap_T<I>
+):wrap_aa_T<I>
+export {
+	wrap_aa_ as wrap_a2_,
+	wrap_aa_ as _wrap_a2,
+	wrap_aa_ as _a2__wrap,
+}
+export declare type wrap_aa_T<
+	I extends unknown = unknown
+> = (
+	I extends readonly unknown[][]
+		? I
+		: I extends readonly unknown[]
+			? readonly I[]
+			: readonly I[][])
+export declare type wrap_aa_type = wrap_aa_T

package/all/wrap_aa/index.js

@@ -0,0 +1,14 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+/**
+ * Returns `wrap_aa_T` wrapped as a 2-dimensional array
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
+ * @returns {import('../_function_types/index.js').wrap_aa_T}
+ */
+export function wrap_aa_(a_nowrap) {
+	return wrap_a_(a_nowrap).map(a_nowrap=>wrap_a_(a_nowrap))
+}
+export {
+	wrap_aa_ as wrap_a2_,
+	wrap_aa_ as _wrap_a2,
+	wrap_aa_ as _a2__wrap,
+}

package/all/wrap_aa_item/index.d.ts

@@ -0,0 +1,5 @@
+import type { wrap_aa_T } from '../wrap_aa/index.js'
+export declare type wrap_aa_item_T<
+	I extends unknown = unknown
+> = wrap_aa_T<I> extends readonly (infer O)[][] ? O : never
+export declare type wrapA2ItemT = wrap_aa_item_T

package/all/wrap_aa_item/index.js

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

package/all/wrap_concat/index.d.ts

@@ -0,0 +1,11 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+import type { wrap_a_T, wrap_a_T2 } from '../wrap_a/index.js'
+/**
+ * [wrap](#wrap) `a_unwrap` & [concat](#concat) `rest_a`
+ */
+export declare function wrap_concat<
+	I extends unknown = unknown
+>(
+	a_unwrap:a_nowrap_T<I>, ...rest_a:wrap_a_T2<I>
+):wrap_a_T<I>
+export { wrap_concat as concat__wrap }

package/all/wrap_concat/index.js

@@ -0,0 +1,13 @@
+import { concat } from '../concat/index.js'
+import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_aa_ } from '../wrap_aa/index.js'
+/**
+ * [wrap](#wrap) `a_unwrap` & [concat](#concat) `rest_a`
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_unwrap
+ * @param {import('../wrap_a/index.js').wrap_a_T2}rest_a
+ * @returns {import('../wrap_a/index.js').wrap_a_T}
+ */
+export function wrap_concat(a_unwrap, ...rest_a) {
+	return concat(wrap_a_(a_unwrap), ...wrap_aa_(rest_a))
+}
+export { wrap_concat as concat__wrap }

package/all/year_ms/index.d.ts

@@ -0,0 +1,5 @@
+export declare const year_ms:number
+export {
+	year_ms as year_milliseconds,
+	year_ms as milliseconds__year,
+}

package/all/year_ms/index.js

@@ -0,0 +1,6 @@
+import { year_seconds } from '../year_seconds/index.js'
+export const year_ms = year_seconds * 1000
+export {
+	year_ms as year_milliseconds,
+	year_ms as milliseconds__year,
+}

package/all/year_seconds/index.d.ts

@@ -0,0 +1,2 @@
+export declare const year_seconds = 31536000
+export { year_seconds as seconds__year }

package/all/year_seconds/index.js

@@ -0,0 +1,2 @@
+export const year_seconds = 31536000
+export { year_seconds as seconds__year }

package/all/yyyymmdd/index.d.ts

@@ -0,0 +1,2 @@
+export declare function yyyymmdd_(date?:Date):string
+export { yyyymmdd_ as _yyyymmdd, }

package/all/yyyymmdd/index.js

@@ -0,0 +1,10 @@
+import { pad2 } from '../pad2/index.js'
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function yyyymmdd_(date) {
+	date = date || new Date()
+	return date.getFullYear() + pad2(date.getMonth() + 1) + pad2(date.getDate())
+}
+export { yyyymmdd_ as _yyyymmdd, }

package/all/yyyymmddhhmmss/index.d.ts

@@ -0,0 +1,2 @@
+export declare function yyyymmddhhmmss_(date?:Date):string
+export { yyyymmddhhmmss_ as _yyyymmddhhmmss, }

package/all/yyyymmddhhmmss/index.js

@@ -0,0 +1,11 @@
+import { pad2 } from '../pad2/index.js'
+import { yyyymmdd_ } from '../yyyymmdd/index.js'
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function yyyymmddhhmmss_(date) {
+	date = date || new Date()
+	return yyyymmdd_(date) + pad2(date.getHours()) + pad2(date.getMinutes()) + pad2(date.getSeconds())
+}
+export { yyyymmddhhmmss_ as _yyyymmddhhmmss, }

package/all/zip/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns 2d Array of each item being the index value for each Array in `...a2`.
+ */
+export declare function zip<
+	I extends readonly unknown[][] = readonly unknown[][],
+	O extends readonly unknown[][] = readonly I[number][number][][]
+>(a2:I):O
+export declare function maybe_zip<
+	I extends unknown[][] = unknown[][],
+	O extends unknown[][] = I[number][number][][]
+>(a2:I|undefined):O|undefined

package/all/zip/index.js

@@ -0,0 +1,17 @@
+import { zip_with } from '../zip_with/index.js'
+/**
+ * Returns 2d Array of each item being the index value for each Array in `...a2`.
+ * @param {unknown[][]}a2
+ * @returns {unknown[][]}
+ */
+export function zip(a2) {
+	return zip_with(a2)
+}
+/**
+ * @param {unknown[][]|undefined}a2
+ * @returns {unknown[][]|undefined}
+ */
+export function maybe_zip(a2) {
+	if (!a2) return
+	return zip(a2)
+}

package/all/zip__tuple_a/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @see {@link https://stackoverflow.com/a/58939723/142571}
+ */
+export type zip__tuple_a_T<
+	T extends readonly any[],
+	U extends readonly any[]
+> = {
+	[K in keyof T]:[
+		T[K],
+		K extends keyof U ? U[K] : never
+	]
+}
+

package/all/zip__tuple_a/index.js

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

package/all/zip_o/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns obj with zipped val_o
+ */
+export declare function zip_o_<
+	Obj extends object = object
+>(
+	key_a:(keyof Obj)[],
+	val_a:Obj[keyof Obj][]
+):Obj
+export {
+	zip_o_ as zip_h_,
+	zip_o_ as zip_ctx_,
+	zip_o_ as _zip_ctx,
+	zip_o_ as _ctx__zip,
+}

package/all/zip_o/index.js

@@ -0,0 +1,22 @@
+/**
+ * Returns obj with zipped val_o
+ * @param {string[]}key_a
+ * @param {unknown[]}val_a
+ * @returns {object}
+ * @private
+ */
+export function zip_o_(key_a, val_a) {
+	const zip_o = {}
+	if (key_a) {
+		for (let i = 0; i < key_a.length; i++) {
+			zip_o[key_a[i]] = val_a[i]
+		}
+	}
+	return zip_o
+}
+export {
+	zip_o_ as zip_h_,
+	zip_o_ as zip_ctx_,
+	zip_o_ as _zip_ctx,
+	zip_o_ as _ctx__zip,
+}

package/all/zip_with/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Returns 2d Array where each item being the return value of `fn` given the index value for each Array in `wrap_aa_T`.
+ */
+export declare function zip_with<
+	I extends readonly unknown[][] = readonly unknown[][],
+	O extends readonly unknown[][] = readonly I[number][number][][]
+>(
+	aa:I,
+	fn?:zip_with_fn_T<I[number], O[number]>
+):O
+export declare function maybe_zip_with<
+	I extends readonly unknown[][] = readonly unknown[][],
+	O extends readonly unknown[][] = readonly I[number][number][][],
+	Or = unknown
+>(
+	a2:I,
+	fn?:zip_with_fn_T<I[number], O[number]>,
+	or?:Or
+):O|Or
+export declare function default_zip_with_2<
+	I extends readonly unknown[] = readonly unknown[],
+	O extends unknown[] = I[number][]
+>():zip_with_fn_T<I, O>
+export declare type zip_with_fn_T<
+	I extends readonly unknown[] = readonly unknown[],
+	O extends readonly unknown[] = readonly I[number][]
+> = (a:I, i:number)=>O
+export {
+	zip_with as zipWith,
+	maybe_zip_with as maybe_zipWith,
+}
+/**
+ * Returns a function that returns [zipWith](#zipWith) with `fn` argument.
+ */
+export declare function zip_with_<
+	I extends readonly unknown[][] = readonly unknown[][],
+	O extends readonly unknown[][] = readonly I[number][number][][]
+>(fn:zip_with_fn_T<I[number], O[number]>):(...a2:I)=>O|undefined
+export {
+	zip_with_ as _zip_with,
+	zip_with_ as _zipWith,
+	zip_with_ as _fn__zipWith,
+}