ctx-core 2.2.0 → 2.2.2

package/all/invalid_state/index.d.ts

@@ -0,0 +1,32 @@
+import type { argument__error_o_T, error_o_error_T, error_o_T } from '../error_o/index.js'
+import type { HttpError } from '../http_error/index.js'
+export declare const invalid_state__default__message:string
+export declare function invalid_state_error_(
+	message?:string,
+	invalid_state_error_o?:argument__invalid_state_error_o_T
+):InvalidStateError
+/**
+ * Throws an invalid_state error (HTTP 500)
+ * @example
+ * invalid_state__throw('foobar: invalid type')
+ */
+export declare function invalid_state__throw(
+	message?:string,
+	invalid_state_error_o?:argument__invalid_state_error_o_T
+):void
+export declare class InvalidStateError
+	extends HttpError
+	implements invalid_state_error_o_error_T {
+	key?:string
+	reason?:string
+}
+export interface invalid_state_error_o_T extends error_o_T {
+	key?:string
+	reason?:string
+}
+export interface argument__invalid_state_error_o_T
+	extends invalid_state_error_o_T, argument__error_o_T {
+}
+export interface invalid_state_error_o_error_T
+	extends invalid_state_error_o_T, error_o_error_T {
+}

package/all/invalid_state/index.js

@@ -0,0 +1,44 @@
+import { assign } from '../assign/index.js'
+import { HttpError } from '../http_error/index.js'
+/** @typedef {import('../invalid_state/index.d.ts').argument__invalid_state_error_o_T}argument__invalid_state_error_o_T */
+/** @typedef {import('./index.d.ts').InvalidStateError} */
+export const invalid_state__default__message = 'Error'
+/**
+ * @param {string}[message]
+ * @param {argument__invalid_state_error_o_T}[invalid_state_error_o]
+ * @return {InvalidStateError}
+ * @private
+ */
+export function invalid_state_error_(
+	message,
+	invalid_state_error_o
+) {
+	return assign(
+		new InvalidStateError(message ?? invalid_state__default__message),
+		invalid_state_error_o)
+}
+/**
+ * Throws an invalid_state error (HTTP 500)
+ * @param {string}[message]
+ * @param {argument__invalid_state_error_o_T}[invalid_state_error_o]
+ * @example
+ * invalid_state__throw('foobar: invalid type')
+ */
+export function invalid_state__throw(
+	message,
+	invalid_state_error_o
+) {
+	throw invalid_state_error_(message, invalid_state_error_o)
+}
+export class InvalidStateError extends HttpError {
+	/**
+	 * @param {string}[message]
+	 */
+	constructor(message) {
+		super(message)
+		this.name = 'InvalidStateError'
+		this.http__status = 500
+		this.http__message = invalid_state__default__message
+		if (!this.message) this.message = this.http__message
+	}
+}

package/all/invert/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns `!val`
+ */
+export declare function invert(val:unknown):boolean

package/all/invert/index.js

@@ -0,0 +1,8 @@
+/**
+ * Returns `!val`
+ * @param {unknown}val
+ * @returns {boolean}
+ */
+export function invert(val) {
+	return !val
+}

package/all/invert_idx_a/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns an Array of indices inverted from `idx_a`.
+ * @example `invert_idx_a_fn([2, 1, 3, 0]) -> [3, 1, 0, 2]`
+ */
+export declare function invert_idx_a_(
+	in_idx_a:readonly number[]|undefined
+):number[]|undefined
+export {
+	invert_idx_a_ as invert_idx_a1_fn,
+	invert_idx_a_ as _invert_idx_a1,
+	invert_idx_a_ as _a1__idx__invert,
+}

package/all/invert_idx_a/index.js

@@ -0,0 +1,20 @@
+/**
+ * Returns an Array of sorted indices inverted from `idx_a`.
+ * @param in_idx_a{number[]|unknown}
+ * @returns {number[]|unknown}
+ * @example `invert_idx_a_([2, 1, 3, 0]) -> [3, 1, 0, 2]`
+ */
+export function invert_idx_a_(in_idx_a) {
+	if (!in_idx_a) return
+	const idx_a = in_idx_a
+	const invert_idx_a = []
+	for (let i = 0; i < idx_a.length; i++) {
+		invert_idx_a[idx_a[i]] = i
+	}
+	return invert_idx_a
+}
+export {
+	invert_idx_a_ as invert_idx_a1_fn,
+	invert_idx_a_ as _invert_idx_a1,
+	invert_idx_a_ as _a1__idx__invert,
+}

package/all/invert_idx_a/index.test.ts

@@ -0,0 +1,7 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { invert_idx_a_ } from '../invert_idx_a/index.js'
+test('invert_idx_a_', ()=>{
+	equal(invert_idx_a_([2, 1, 3, 0]), [3, 1, 0, 2])
+})
+test.run()

package/all/isArray/index.d.ts

@@ -0,0 +1,5 @@
+export declare const native_isArray:(arg:any)=>arg is any[]
+/**
+ * Is the argument an Array?
+ */
+export declare function isArray<I extends unknown = unknown>(obj:I):boolean

package/all/isArray/index.js

@@ -0,0 +1,9 @@
+export const native_isArray = Array.isArray
+/**
+ * Is the argument an Array?
+ * @param {unknown}obj
+ * @returns {boolean}
+ */
+export function isArray(obj) {
+	return native_isArray ? native_isArray(obj) : toString.call(obj) === '[object Array]'
+}

package/all/isFloat/index.d.ts

@@ -0,0 +1 @@
+export declare function isFloat(number:any):boolean

package/all/isFloat/index.js

@@ -0,0 +1,4 @@
+import { float_isNaN_ } from '../float_isNaN/index.js'
+export function isFloat(number) {
+	return !float_isNaN_(number)
+}

package/all/isFloat_andor/index.d.ts

@@ -0,0 +1,3 @@
+export declare function isFloat_andor_<And_Val, Or_Val>(
+	val:any, and_val_?:(val:any)=>And_Val, or_val_?:(val:any)=>Or_Val
+):And_Val|Or_Val

package/all/isFloat_andor/index.js

@@ -0,0 +1,9 @@
+import { isFloat } from '../isFloat/index.js'
+import { null_ } from '../null/index.js'
+export function isFloat_andor_(val, and_val_ = $=>$, or_val_ = null_) {
+	return (
+		isFloat(val)
+			? and_val_(val)
+			: or_val_(val)
+	)
+}

package/all/isFloat_or/index.d.ts

@@ -0,0 +1 @@
+export declare function isFloat_or_<Or_Val>(val:any, or_val_?:(val:any)=>Or_Val):any

package/all/isFloat_or/index.js

@@ -0,0 +1,5 @@
+import { isFloat } from '../isFloat/index.js'
+import { null_ } from '../null/index.js'
+export function isFloat_or_(val, or_val_ = null_) {
+	return isFloat(val) ? val : or_val_(val)
+}

package/all/isLowerCase/index.d.ts

@@ -0,0 +1 @@
+export declare function isLowerCase(word:string):boolean

package/all/isLowerCase/index.js

@@ -0,0 +1,7 @@
+/**
+ * @param {string}word
+ * @returns {boolean}
+ */
+export function isLowerCase(word) {
+	return word === word.toLowerCase()
+}

package/all/isNumber/index.d.ts

@@ -0,0 +1,5 @@
+import { isFloat } from '../isFloat/index.js'
+export {
+	isFloat as isNumber,
+	isFloat as isNumber_,
+}

package/all/isNumber/index.js

@@ -0,0 +1,5 @@
+import { isFloat } from '../isFloat/index.js'
+export {
+	isFloat as isNumber,
+	isFloat as isNumber_,
+}

package/all/isNumber_andor/index.d.ts

@@ -0,0 +1,3 @@
+export declare function isNumber_andor_<And_Val, Or_Val>(
+	val:any, and_val_?:(val:any)=>And_Val, or_val_?:(val:any)=>Or_Val
+):And_Val|Or_Val

package/all/isNumber_andor/index.js

@@ -0,0 +1,8 @@
+import { isNumber_ } from '../isNumber/index.js'
+export function isNumber_andor_(val, and_val_ = $=>$, or_val_ = null_) {
+	return (
+		isNumber_(val)
+			? and_val_(val)
+			: or_val_(val)
+	)
+}

package/all/isNumber_or/index.d.ts

@@ -0,0 +1 @@
+export declare function isNumber_or_<Or_Val>(val:any, or_val_?:(val:any)=>Or_Val):any

package/all/isNumber_or/index.js

@@ -0,0 +1,5 @@
+import { isNumber_ } from '../isNumber/index.js'
+import { null_ } from '../null/index.js'
+export function isNumber_or_(val, or_val_ = null_) {
+	return isNumber_(val) ? val : or_val_(val)
+}

package/all/isObject/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns boolean of `val` is an object
+ */
+export declare function isObject(val:unknown):boolean
+export {
+	isObject as _is_Object,
+	isObject as _is__Object,
+}

package/all/isObject/index.js

@@ -0,0 +1,12 @@
+/**
+ * Returns boolean of `val` is an object
+ * @param {unknown}val
+ * @returns {boolean}
+ */
+export function isObject(val) {
+	return !!(val && new String(val) === '[object Object]')
+}
+export {
+	isObject as _is_Object,
+	isObject as _is__Object,
+}

package/all/isPromise/index.d.ts

@@ -0,0 +1 @@
+export declare function isPromise(obj:any):boolean

package/all/isPromise/index.js

@@ -0,0 +1,7 @@
+/**
+ * @param {unknown}val
+ * @returns {boolean}
+ */
+export function isPromise(val) {
+	return val ? typeof val.then === 'function' : false
+}

package/all/isString/index.d.ts

@@ -0,0 +1 @@
+export declare function isString(obj:any):boolean

package/all/isString/index.js

@@ -0,0 +1,7 @@
+/**
+ * @param {any}obj
+ * @returns {boolean}
+ */
+export function isString(obj) {
+	return !!(obj === '' || obj && obj.charCodeAt && obj.substr)
+}

package/all/isUpperCase/index.d.ts

@@ -0,0 +1 @@
+export declare function isUpperCase(word:string):boolean

package/all/isUpperCase/index.js

@@ -0,0 +1,7 @@
+/**
+ * @param {string}word
+ * @returns {boolean}
+ */
+export function isUpperCase(word) {
+	return word === word.toUpperCase()
+}

package/all/item_r_idx/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Returns an Object where each key is `_item(a[idx], idx)` and value is `idx`.
+ */
+export declare const item_r_idx_:idx_item_r_fn_T
+export {
+	item_r_idx_ as idx_item_r_,
+	item_r_idx_ as idx_item_h_,
+	item_r_idx_ as idx_item_hash_,
+	item_r_idx_ as _idx_item_hash,
+	item_r_idx_ as _hash__item__idx,
+}
+/**
+ * Returns a function that returns value of `_idx_item_hash` with `item_` argument.
+ */
+export declare function item_r_idx__(
+	item_:(in_value:string, idx:number)=>string
+):idx_item_r_fn_T
+export type idx_item_r_T = Record<string, number>
+export declare type idx_item_r_fn_T = (a:string[]|undefined)=>idx_item_r_T
+export {
+	item_r_idx__ as item_r_idx_2,
+	item_r_idx__ as idx_item_r_2,
+	item_r_idx__ as idx_item_h_2,
+	item_r_idx__ as idx_item_hash_2,
+	item_r_idx__ as _idx_item_hash_fn,
+	item_r_idx__ as _fn__idx_item_hash,
+}

package/all/item_r_idx/index.js

@@ -0,0 +1,38 @@
+import { I__ } from '../combinators/index.js'
+/**
+ * Returns an Object where each key is `_item(a[idx], idx)` and value is `idx`.
+ * @type {import('../item_r_idx/index.js').idx_item_r_fn_T}
+ */
+export const item_r_idx_ = item_r_idx__(I__)
+export {
+	item_r_idx_ as idx_item_r_,
+	item_r_idx_ as idx_item_h_,
+	item_r_idx_ as idx_item_hash_,
+	item_r_idx_ as _idx_item_hash,
+	item_r_idx_ as _hash__item__idx,
+}
+/**
+ * Returns a function that returns value of `_idx_item_hash` with `item_` argument.
+ * @param {(in_value:string, idx:number)=>string}item_
+ * @returns {import('./index.d.ts').idx_item_r_fn_T}
+ */
+export function item_r_idx__(item_) {
+	return (in_a)=>{
+		let idx_item_r = {}
+		if (in_a) {
+			const a = in_a
+			for (let idx = 0; idx < a.length; idx++) {
+				const item = item_ ? item_(a[idx], idx) : a[idx]
+				idx_item_r[item] = idx
+			}
+		}
+		return idx_item_r
+	}
+}
+export {
+	item_r_idx__ as idx_item_r_2,
+	item_r_idx__ as idx_item_h_2,
+	item_r_idx__ as idx_item_hash_2,
+	item_r_idx__ as _idx_item_hash_fn,
+	item_r_idx__ as _fn__idx_item_hash,
+}

package/all/json/index.d.ts

@@ -0,0 +1,2 @@
+declare const json_sym:unique symbol
+export type json_T = string&{ [json_sym]:any }

package/all/json/index.js

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

package/all/key_compare/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Return a compare function to sort on key values.
+ */
+export declare function key_compare_<
+	Obj extends object|readonly unknown[] = object
+>(
+	key:keyof Obj, asc?:boolean
+):(a:Obj, b:Obj)=>number
+export {
+	key_compare_ as _key_compare,
+	key_compare_ as _compare__key,
+	key_compare_ as _sort__key,
+	key_compare_ as _sort__key__a1,
+}

package/all/key_compare/index.js

@@ -0,0 +1,19 @@
+/**
+ * Return a compare function to sort on key values.
+ * @param {Object|unknown[]}key
+ * @param {boolean}asc
+ * @returns {(a:Object|unknown[], b:Object|unknown[])=>number}
+ */
+export function key_compare_(key, asc = true) {
+	return (a, b)=>{
+		if (a[key] < b[key]) return asc ? -1 : 1
+		if (a[key] > b[key]) return asc ? 1 : -1
+		return 0
+	}
+}
+export {
+	key_compare_ as _key_compare,
+	key_compare_ as _compare__key,
+	key_compare_ as _sort__key,
+	key_compare_ as _sort__key__a1,
+}

package/all/key_r/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Returns an `Object.<key,value>` of the given `key_hash[a[][key]] = a[]`.
+ */
+export declare function key_r_<
+	Key extends string,
+	Obj extends { [k in Key]:string }
+>(
+	a:readonly Obj[], key:Key
+):Record<string, Obj>
+export declare function maybe_key_r_<
+	Key extends string,
+	Obj extends { [k in Key]:string },
+	Or = null
+>(
+	maybe_a:readonly Obj[]|undefined,
+	key:Key,
+	or?:Or
+):Record<string, Obj>|Or
+export {
+	key_r_ as key_h_,
+	key_r_ as _key_hash,
+	key_r_ as _hash__key,
+	maybe_key_r_ as maybe_key_h_,
+	maybe_key_r_ as _maybe_key_hash,
+}
+/**
+ * Returns a Function using argument `key` that returns value from [_key_hash](#_hash__key).
+ */
+export declare function key_r__<
+	Key extends string,
+	Obj extends { [k in Key]:string }
+>(
+	key:Key
+):(a:readonly Obj[])=>Record<string, Obj>
+export declare function maybe_key_r__<
+	Key extends string,
+	Obj extends { [k in Key]:string },
+	Or = null
+>(
+	key:Key, or?:Or
+):(maybe_a:readonly Obj[]|undefined)=>Record<string, Obj>|Or
+export {
+	key_r__ as key_h_2,
+	key_r__ as _key_hash_fn,
+	key_r__ as _fn__hash__key,
+	maybe_key_r__ as maybe_key_h_2,
+	maybe_key_r__ as _maybe_key_hash_fn,
+}

package/all/key_r/index.js

@@ -0,0 +1,63 @@
+/**
+ * Returns an `Object.<key,value>` of the given `key_hash[a[][key]] = a[]`.
+ * @param {Record<string, string>[]}a
+ * @param {string}key
+ * @returns {Record<string, Record<string, string>>}}
+ */
+export function key_r_(a, key) {
+	const key_r = {}
+	if (a) {
+		for (let i = 0; i < a.length; i++) {
+			const val = a[i]
+			if (!val) continue
+			key_r[val[key]] = val
+		}
+	}
+	return key_r
+}
+/**
+ * @param maybe_a{Record<string, string>[]|undefined}
+ * @param key{string}
+ * @param or{Record<string, string>[]|null|undefined}
+ * @returns {Record<string, Record<string, string>>|null|unknown}
+ */
+export function maybe_key_r_(
+	maybe_a,
+	key,
+	or = null
+) {
+	return maybe_a ? key_r_(maybe_a, key) : or
+}
+export {
+	key_r_ as key_h_,
+	key_r_ as _key_hash,
+	key_r_ as _hash__key,
+	maybe_key_r_ as maybe_key_h_,
+	maybe_key_r_ as _maybe_key_hash,
+}
+/**
+ * Returns a Function using argument `key` that returns value from [_key_hash](#_hash__key).
+ * @param {string}key
+ * @returns {(a:Record<string, string>[])=>Record<string, Record<string, string>>}
+ */
+export function key_r__(key) {
+	return a=>key_r_(a, key)
+}
+export {
+	key_r__ as key_r_2,
+	key_r__ as key_h_2,
+	key_r__ as _key_hash_fn,
+	key_r__ as _fn__hash__key,
+}
+/**
+ * @param {string}key
+ * @param {Record<string, Record<string, string>>|null|undefined}or
+ * @returns {(maybe_a:Record<string, string>[]|undefined)=>(Record<string, Record<string, string>>|null|undefined)}
+ */
+export function maybe_key_r__(key, or = null) {
+	return (maybe_a)=>maybe_key_r_(maybe_a, key, or)
+}
+export {
+	maybe_key_r__ as maybe_key_h_2,
+	maybe_key_r__ as _maybe_key_hash_fn,
+}

package/all/key_r_a/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns a hash of arrays grouped by each key in each `ctx` in `ctx_a`.
+ */
+export declare function key_r_a_<
+	Val extends object = object
+>(
+	ctx_a_nowrap:(Record<string, Val>|readonly Record<string, Val>[])
+):Record<string, Val[]>
+export {
+	key_r_a_ as key_h_a_,
+	key_r_a_ as key_h_a1_fn,
+	key_r_a_ as _key_h_a1,
+	key_r_a_ as _a1_key_hash,
+	key_r_a_ as _hash__key__a1,
+}

package/all/key_r_a/index.js

@@ -0,0 +1,26 @@
+import { concat } from '../concat/index.js'
+import { wrap_a_ } from '../wrap_a/index.js'
+/**
+ * Returns a hash of arrays grouped by each key in each `ctx` in `ctx_a`.
+ * @param ctx_a_nowrap{Record<string, object>|Record<string, object>[]}
+ * @returns {Record<string, object[]>}
+ */
+export function key_r_a_(ctx_a_nowrap) {
+	const ctx_a = wrap_a_(ctx_a_nowrap)
+	const a_key_r_a = {}
+	for (let i = 0; i < ctx_a.length; i++) {
+		const ctx = ctx_a[i]
+		for (let key in ctx) {
+			const value = ctx[key]
+			a_key_r_a[key] = concat(a_key_r_a[key] || [], value)
+		}
+	}
+	return a_key_r_a
+}
+export {
+	key_r_a_ as key_h_a_,
+	key_r_a_ as key_h_a1_fn,
+	key_r_a_ as _key_h_a1,
+	key_r_a_ as _a1_key_hash,
+	key_r_a_ as _hash__key__a1,
+}

package/all/keyof/index.d.ts

@@ -0,0 +1 @@
+export declare type keyof_T = string|symbol|number

package/all/keyof/index.js

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

package/all/keys/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Object keys
+ */
+export declare const keys:typeof Object.keys

package/all/keys/index.js

@@ -0,0 +1,5 @@
+/**
+ * Object keys
+ * @type {typeof (val:object)=>string[]}
+ */
+export const keys = Object.keys.bind(Object)

package/all/lPad/index.d.ts

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

package/all/lPad/index.js

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

package/all/last/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns the _last item in the in_a
+ */
+export declare function last_<
+	I extends unknown = unknown
+>(a:readonly I[]):I|undefined
+export declare function maybe_last_<
+	I extends unknown = unknown,
+	Or = null
+>(
+	maybe_a:readonly I[]|undefined,
+	or?:Or
+):I|Or
+export {
+	last_ as _last,
+	last_ as _last__a1,
+	maybe_last_ as _maybe_last,
+}

package/all/last/index.js

@@ -0,0 +1,22 @@
+/**
+ * Returns the _last item in the in_a
+ * @param {unknown[]}a
+ * @returns {unknown|undefined}
+ */
+export function last_(a) {
+	return a[a.length - 1]
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {unknown[]|null|undefined}or
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_last_(maybe_a, or = null) {
+	if (!maybe_a) return or
+	return last_(maybe_a)
+}
+export {
+	last_ as _last,
+	last_ as _last__a1,
+	maybe_last_ as _maybe_last,
+}

package/all/left_and/index.d.ts

@@ -0,0 +1,12 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+import type { falsy } from '../falsy/index.js'
+/**
+ * Returns function that returns the first falsy in `a_unwrap` or `value`.
+ */
+export declare function left_and_<
+	Val extends unknown = unknown
+>(a_unwrap:a_nowrap_T<Val>):(val:Val)=>Val|falsy
+export {
+	left_and_ as _left_and,
+	left_and_ as _and__left,
+}