ctx-core 2.2.0 → 2.2.2

package/all/splice/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Calls splice on a
+ */
+export declare function splice<
+	I extends unknown = unknown, O extends unknown = readonly I[]
+>(
+	a:readonly I[],
+	start:number,
+	delete_count?:number,
+	...arg_a:readonly I[]
+):O
+export declare function maybe_splice<
+	I extends unknown = unknown, O extends unknown = readonly I[]
+>(
+	maybe_a:readonly I[]|undefined,
+	start:number,
+	delete_count?:number,
+	...arg_a:readonly I[]
+):O|undefined

package/all/splice/index.js

@@ -0,0 +1,23 @@
+/**
+ * Calls splice on a
+ * @param {unknown[]}a
+ * @param {number}start
+ * @param {number}[delete_count]
+ * @param {unknown}arg_a
+ * @returns {unknown[]}
+ */
+export function splice(a, start, delete_count, ...arg_a) {
+	return a.splice(start, delete_count, ...arg_a)
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {number}start
+ * @param {number}[delete_count]
+ * @param {unknown}arg_a
+ * @returns {unknown[]|undefined}
+ */
+export function maybe_splice(
+	maybe_a, start, delete_count, ...arg_a
+) {
+	return maybe_a ? splice(maybe_a, start, delete_count, ...arg_a) : undefined
+}

package/all/splice_str/index.d.ts

@@ -0,0 +1,8 @@
+export declare function splice_str(
+	str:string, idx?:number, rem?:number, add?:string
+):string
+export {
+	splice_str as splice_string,
+	splice_str as splice__str,
+	splice_str as splice__string,
+}

package/all/splice_str/index.js

@@ -0,0 +1,20 @@
+/**
+ * @param {string}str
+ * @param {number}idx
+ * @param {number}rem
+ * @param {string}add
+ * @returns {string}
+ */
+export function splice_str(
+	str,
+	idx = str.length,
+	rem = 0,
+	add
+) {
+	return str.slice(0, idx) + (add || '') + str.slice(idx + Math.abs(rem))
+}
+export {
+	splice_str as splice_string,
+	splice_str as splice__str,
+	splice_str as splice__string,
+}

package/all/spread/index.d.ts

@@ -0,0 +1,22 @@
+import type { wrap_a_T } from '../wrap_a/index.js'
+/**
+ * Apply the spread operator on `a_unwrap` into `fn` `fn(...a_unwrap)`
+ */
+export declare function spread<
+	Val extends unknown = unknown, Out extends unknown = unknown
+>(
+	fn:(...a:wrap_a_T<Val>)=>Out,
+	a_unwrap:Val
+):Out
+/**
+ * Returns a function taking an array calling [spread](#spread)
+ */
+export declare function spread_<
+	Val extends unknown = unknown, Out extends unknown = unknown
+>(
+	fn:(...a:wrap_a_T<Val>)=>Out
+):(a_unwrap:Val)=>Out
+export {
+	spread_ as spread_fn,
+	spread_ as _spread,
+}

package/all/spread/index.js

@@ -0,0 +1,24 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+/** @typedef {import('../wrap_a/index.d.ts').wrap_a_T} */
+/**
+ * Apply the spread operator on `a_unwrap` into `fn`; `fn(...a_unwrap)`
+ * @param {(...a:wrap_a_T)=>unknown}fn
+ * @param {unknown}a_unwrap
+ * @returns {unknown}
+ */
+export function spread(fn, a_unwrap) {
+	const wrap_a = wrap_a_(a_unwrap)
+	return fn(...wrap_a)
+}
+/**
+ * Returns a function taking an array calling [spread](#spread)
+ * @param {(...a:wrap_a_T)=>unknown}fn
+ * @returns {(a_unwrap:unknown)=>unknown}
+ */
+export function spread_(fn) {
+	return a_unwrap=>spread(fn, a_unwrap)
+}
+export {
+	spread_ as spread_fn,
+	spread_ as _spread,
+}

package/all/spread_slice/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns a function that slices the spread argument array with `arg_a`
+ */
+export declare function spread_slice_(...arg_a:any):spread_slice__arg_T
+export {
+	spread_slice_ as _spread_slice,
+	spread_slice_ as _slice__spread,
+	spread_slice_ as _fn__slice__spread,
+}
+export declare type spread_slice__arg_T = (...arg_a:any)=>undefined|unknown[]

package/all/spread_slice/index.js

@@ -0,0 +1,14 @@
+import { slice } from '../slice/index.js'
+/**
+ * Returns a function that slices the spread argument array with `arg_a`
+ * @param {unknown}arg_a
+ * @returns {import('../spread_slice/index.js').spread_slice__arg_T}
+ */
+export function spread_slice_(...arg_a) {
+	return (...a)=>slice(a, ...arg_a)
+}
+export {
+	spread_slice_ as _spread_slice,
+	spread_slice_ as _slice__spread,
+	spread_slice_ as _fn__slice__spread,
+}

package/all/stacktrace/index.d.ts

@@ -0,0 +1,5 @@
+export declare function stacktrace_():string[]
+export declare function stacktrace_filename_():string
+export declare function stacktrace_line_():number
+export declare function stacktrace_line_pos_():string
+export declare function stacktrace_filename_line_(stack_line?:string):string

package/all/stacktrace/index.js

@@ -0,0 +1,42 @@
+/**
+ * @returns {string[]}
+ */
+export function stacktrace_() {
+	const err = new Error
+	return err.stack.split('\n')
+}
+/**
+ * @returns {string}
+ */
+export function stacktrace_filename_() {
+	const stacktrace_filename_line = stacktrace_filename_line_()
+	return stacktrace_filename_line.slice(0 + 1, stacktrace_filename_line.indexOf(':'))
+}
+/**
+ * @returns {number}
+ */
+export function stacktrace_line_() {
+	const stacktrace_filename_line = stacktrace_filename_line_()
+	return parseInt(
+		stacktrace_filename_line.slice(stacktrace_filename_line.indexOf(':') + 1,
+			stacktrace_filename_line.lastIndexOf(':')))
+}
+/**
+ * @returns {string}
+ */
+export function stacktrace_line_pos_() {
+	const stacktrace_filename_line = stacktrace_filename_line_()
+	return stacktrace_filename_line.slice(
+		stacktrace_filename_line.lastIndexOf(':') + 1)
+}
+/**
+ * @param {string}[stack_line]
+ * @returns {string}
+ */
+export function stacktrace_filename_line_(stack_line = stacktrace_()[3]) {
+	return (
+		stack_line.slice(
+			stack_line.lastIndexOf('/'), stack_line.lastIndexOf(')'))
+		|| stack_line.slice(stack_line.lastIndexOf('('), stack_line.lastIndexOf(')'))
+	)
+}

package/all/std/index.d.ts

@@ -0,0 +1,2 @@
+export declare function std_(a:readonly number[]):number
+export { std_ as std, }

package/all/std/index.js

@@ -0,0 +1,13 @@
+import { sum_ } from '../add/index.js'
+import { mean_ } from '../mean/index.js'
+/**
+ * sample standard deviation
+ */
+export function std_(a) {
+	if (a.length <= 1) return 0
+	const mean = mean_(a)
+	const diff_a = a.map((a)=>(a - mean) ** 2
+	)
+	return Math.sqrt(sum_(diff_a) / (a.length - 1))
+}
+export { std_ as std, }

package/all/sub/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Subtracts rest of values from first value
+ */
+export declare function sub(values:readonly number[]):number

package/all/sub/index.js

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

package/all/table_txt/index.d.ts

@@ -0,0 +1,2 @@
+export declare function table_txt_(aa:string[][]):string
+export declare function table_txt__str_aa_num_a_pair_(aa:string[][]):[string[][], number[]]

package/all/table_txt/index.js

@@ -0,0 +1,29 @@
+import { isNumber_ } from '../isNumber/index.js'
+import { rPad } from '../rPad/index.js'
+/**
+ * @param {string[][]}aa
+ * @returns {string}
+ */
+export function table_txt_(aa) {
+	const str_aa_num_a_pair = table_txt__str_aa_num_a_pair_(aa)
+	return str_aa_num_a_pair[0].map(a=>
+		a.reduce((s, $i, i)=>
+			s += i === a.length - 1
+				? $i
+				: rPad($i, ' ', str_aa_num_a_pair[1][i] + 2), '')
+	).join('\n')
+}
+/**
+ * @param {string[][]}aa
+ * @returns {[string[][], number[]]}
+ */
+export function table_txt__str_aa_num_a_pair_(aa) {
+	return aa.reduce((str_aa_num_a_pair, a)=>{
+		str_aa_num_a_pair[0].push(a)
+		for (let i = 0; i < a.length; i++) {
+			if (!isNumber_(str_aa_num_a_pair[1][i])) str_aa_num_a_pair[1][i] = 0
+			str_aa_num_a_pair[1][i] = Math.max(str_aa_num_a_pair[1][i], a[i].length)
+		}
+		return str_aa_num_a_pair
+	}, [[], []])
+}

package/all/table_txt/index.test.ts

@@ -0,0 +1,17 @@
+import { test } from 'uvu'
+import { is } from 'uvu/assert'
+import { table_txt_ } from '../table_txt/index.js'
+test('table_txt_', ()=>{
+	is(table_txt_([
+		['-c, --code', 'Factset dataset code <ent,own,ref,sym>'],
+		['-v, --version', 'Factset version'],
+		['-s, --sequence', 'Sequence'],
+		['-h, --help', 'This help message'],
+	]), `
+-c, --code      Factset dataset code <ent,own,ref,sym>
+-v, --version   Factset version
+-s, --sequence  Sequence
+-h, --help      This help message
+	`.trim())
+})
+test.run()

package/all/tap/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Invokes interceptor with the obj, and then returns the object.
+ * The primary purpose of this method is to "tap into" a method chain,
+ * to perform operations on intermediate results within the chain.
+ * @see {@link https://underscorejs.org/#tap}
+ */
+export declare function tap<
+	Obj extends unknown = unknown
+>(
+	obj:Obj, interceptor:tap__interceptor_T<Obj>
+):Obj
+export declare type tap__interceptor_T<T = unknown> = (obj:T)=>void
+export declare type tap_interceptor_T<T = unknown> = tap__interceptor_T<T>
+/**
+ * Returns function that calls tap with obj.
+ */
+export declare function tap_<
+	Val = unknown
+>(
+	fn:tap__interceptor_T<Val>
+):(val:Val)=>Val
+export { tap_ as _tap, }

package/all/tap/index.js

@@ -0,0 +1,26 @@
+/** @typedef {import('../tap/index.d.ts').tap__interceptor_T} */
+/**
+ * Invokes interceptor with the obj, and then returns the object.
+ * The primary purpose of this method is to "tap into" a method chain,
+ * to perform operations on intermediate results within the chain.
+ * @param {unknown}obj
+ * @param {tap__interceptor_T}interceptor
+ * @returns {unknown}
+ * @see {@link https://underscorejs.org/#tap}
+ */
+export function tap(obj, interceptor) {
+	interceptor(obj)
+	return obj
+}
+/**
+ * Returns function that calls tap with obj.
+ * @param {tap__interceptor_T}fn
+ * @returns {(val:unknown)=>unknown}
+ */
+export function tap_(fn) {
+	return val=>{
+		fn(val)
+		return val
+	}
+}
+export { tap_ as _tap, }

package/all/tf/index.d.ts

@@ -0,0 +1,2 @@
+export declare const t = true
+export declare const f = false

package/all/tf/index.js

@@ -0,0 +1,2 @@
+export const t = true
+export const f = false

package/all/throttle/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @see {@link https://remysharp.com/2010/07/21/throttling-function-calls}
+ */
+export declare function throttle<
+	F extends Function,
+	This extends unknown
+>(
+	fn:F, threshold?:number, scope?:unknown
+):(this:This)=>void

package/all/throttle/index.js

@@ -0,0 +1,26 @@
+/**
+ * @param {Function}fn
+ * @param {number}[threshold]
+ * @param {number}[scope]
+ * @returns {(this:unknown)=>void}
+ * @see {@link https://remysharp.com/2010/07/21/throttling-function-calls}
+ */
+export function throttle(fn, threshold = 250, scope) {
+	threshold || (threshold = 250)
+	let last, deferTimer
+	return function() {
+		const context = scope || this
+		const now = +new Date, args = arguments
+		if (last && now < last + threshold) {
+			// hold on to it
+			clearTimeout(deferTimer)
+			deferTimer = setTimeout(()=>{
+				last = now
+				fn.apply(context, args)
+			}, threshold)
+		} else {
+			last = now
+			fn.apply(context, args)
+		}
+	}
+}

package/all/tick/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calls setTimeout
+ */
+export declare function tick<
+	Out extends unknown = unknown
+>(
+	fn?:()=>Out, timeout?:number
+):Promise<Out|undefined>

package/all/tick/index.js

@@ -0,0 +1,23 @@
+import { run } from '../run/index.js'
+/**
+ * Calls setTimeout
+ * @param {()=>unknown}[fn]
+ * @param {number}[timeout]
+ * @returns {Promise<unknown>}
+ */
+export function tick(fn, timeout = 0) {
+	return new Promise((res, rej)=>{
+		if (!timeout) {
+			queueMicrotask(()=>
+				res(run(fn)))
+		} else {
+			setTimeout(()=>{
+				try {
+					res(run(fn))
+				} catch (e) {
+					rej(e)
+				}
+			}, timeout)
+		}
+	})
+}

package/all/timedout/index.d.ts

@@ -0,0 +1,2 @@
+export declare function timedout_(start:Date, timout_ms:number):boolean
+export { timedout_ as _timedout, }

package/all/timedout/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {Date}start
+ * @param {number}timout_ms
+ * @returns {boolean}
+ */
+export function timedout_(start, timout_ms) {
+	return new Date().getTime() >= start.getTime() + timout_ms
+}
+export { timedout_ as _timedout, }

package/all/timeout_promise/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @see {@link https://italonascimento.github.io/applying-a-timeout-to-your-promises/}
+ * @see {@link http://disq.us/p/1k8w63m}
+ */
+export declare function timeout_promise<
+	O extends unknown = unknown
+>(
+	ms:number, promise:Promise<O>
+):Promise<O>
+export { timeout_promise as _timeout_promise }

package/all/timeout_promise/index.js

@@ -0,0 +1,12 @@
+import { promise_timeout } from '../promise_timeout/index.js'
+/**
+ * @param {number}ms
+ * @param {Promise<unknown>}promise
+ * @returns {Promise<unknown>}
+ * @see {@link https://italonascimento.github.io/applying-a-timeout-to-your-promises/}
+ * @see {@link http://disq.us/p/1k8w63m}
+ */
+export async function timeout_promise(ms, promise) {
+	return await promise_timeout(promise, ms)
+}
+export { timeout_promise as _timeout_promise }

package/all/times/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns array with the index as each item.
+ */
+export declare function times<
+	I extends unknown = unknown
+>(
+	num:number, fn:(idx:number)=>I
+):I[]

package/all/times/index.js

@@ -0,0 +1,13 @@
+/**
+ * Returns array with the index as each item.
+ * @param {number}num
+ * @param {(idx:number)=>unknown}fn
+ * @returns {unknown[]}
+ */
+export function times(num, fn) {
+	const a = []
+	for (let idx = 0; idx < num; idx++) {
+		a.push(fn(idx))
+	}
+	return a
+}

package/all/timestamp_ms/index.d.ts

@@ -0,0 +1,6 @@
+export declare function timestamp_ms_():number
+export {
+	timestamp_ms_ as _timestamp_ms,
+	timestamp_ms_ as _timestamp_milliseconds,
+	timestamp_ms_ as _milliseconds__timestamp,
+}

package/all/timestamp_ms/index.js

@@ -0,0 +1,8 @@
+export function timestamp_ms_() {
+	return new Date().getTime()
+}
+export {
+	timestamp_ms_ as _timestamp_ms,
+	timestamp_ms_ as _timestamp_milliseconds,
+	timestamp_ms_ as _milliseconds__timestamp,
+}

package/all/title_case_/index.d.ts

@@ -0,0 +1,7 @@
+export declare function title_case_(str:string):string
+export {
+	title_case_ as _title_case,
+	title_case_ as titleCase,
+	title_case_ as toTitleCase,
+	title_case_ as titleCase__string,
+}

package/all/title_case_/index.js

@@ -0,0 +1,24 @@
+/**
+ * @param {string}str
+ * @returns {string}
+ * @private
+ */
+export function title_case_(str) {
+	const title_case =
+		str == null
+			? ''
+			: str
+				.toString()
+				.replace(
+					/\w\S*/g,
+					txt=>
+						txt.charAt(0).toUpperCase()
+						+ txt.slice(1).toLowerCase())
+	return title_case
+}
+export {
+	title_case_ as _title_case,
+	title_case_ as titleCase,
+	title_case_ as toTitleCase,
+	title_case_ as titleCase__string,
+}

package/all/toLocalDateString/index.d.ts

@@ -0,0 +1 @@
+export declare function toLocalDateString(date?:Date):string

package/all/toLocalDateString/index.js

@@ -0,0 +1,7 @@
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function toLocalDateString(date = new Date()) {
+	return date.toLocaleDateString()
+}

package/all/toString/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns string representation of an object. Alias to `Object.prototype.string`
+ * @type {function(): string}
+ */
+export declare const toString:()=>string

package/all/toString/index.js

@@ -0,0 +1,5 @@
+/**
+ * Returns string representation of an object. Alias to `Object.prototype.string`
+ * @type {()=>string}
+ */
+export const toString = Object.prototype.toString

package/all/tup/index.d.ts

@@ -0,0 +1,13 @@
+export declare function tup<
+	Args extends readonly any[]
+>(...data:Args):Args
+export declare type tup_T<
+	Args extends readonly any[]
+> = (...data:Args)=>Args
+export {
+	tup as tuple,
+	tup as tuple_,
+	tup as _tuple,
+	tup as _tup,
+	tup as tup_fn,
+}

package/all/tup/index.js

@@ -0,0 +1,14 @@
+/**
+ * @param {unknown}data
+ * @returns {unknown[]}
+ */
+export function tup(...data) {
+	return data
+}
+export {
+	tup as tuple,
+	tup as tuple_,
+	tup as _tuple,
+	tup as _tup,
+	tup as tup_fn,
+}

package/all/tuple__o/index.d.ts

@@ -0,0 +1,7 @@
+export type tuple__o_T<
+	T extends readonly any[],
+	Key extends keyof T[number],
+	Val extends keyof T[number]
+> = {
+	[P in Exclude<keyof T, keyof readonly any[]> as T[P][Key]&string]:T[P][Val]
+}

package/all/tuple__o/index.js

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

package/all/tuple__union/index.d.ts

@@ -0,0 +1 @@
+export type tuple__union_T<T extends any[]> = T[number]

package/all/tuple__union/index.js

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

package/all/tuple_a_o/index.d.ts

@@ -0,0 +1,10 @@
+import type { zip__tuple_a_T } from '../zip__tuple_a/index.js'
+/**
+ * @see {@link https://stackoverflow.com/a/58939723/142571}
+ */
+export type tuple_a_o_T<
+	K extends readonly PropertyKey[],
+	V extends readonly any[]
+> = {
+	[T in zip__tuple_a_T<K, V>[number] as T[0]]:T[1]
+}

package/all/tuple_a_o/index.js

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

package/all/unauthorized/index.d.ts

@@ -0,0 +1,20 @@
+import type { error_o_error_T, error_o_T } from '../error_o/index.js'
+import type { HttpError } from '../http_error/index.js'
+export declare const unauthorized__default__message:string
+export declare function unauthorized_error_(
+	message?:string,
+	error_o?:error_o_T
+):UnauthorizedError
+/**
+ * Throws an unauthorized error (HTTP 401)
+ * @example
+ * throw__unauthorized(ctx) // Unauthorized
+ */
+export declare function unauthorized__throw(
+	message?:string,
+	error_o?:error_o_T
+):void
+export declare class UnauthorizedError
+	extends HttpError
+	implements error_o_error_T {
+}