ctx-core 2.2.0 → 2.2.2

package/all/missing_argument/index.js

@@ -0,0 +1,44 @@
+import { assign } from '../assign/index.js'
+import { HttpError } from '../http_error/index.js'
+/** @typedef {import('../missing_argument/index.d.ts').argument__missing_argument_error_o_T}argument__missing_argument_error_o_T */
+/** @typedef {import('../missing_argument/index.d.ts').MissingArgumentError} */
+export const missing_argument__default__message = 'Error'
+/**
+ * @param {string}[message]
+ * @param {argument__missing_argument_error_o_T}[missing_argument_error_o]
+ * @returns {MissingArgumentError}
+ * @private
+ */
+export function missing_argument_error_(
+	message,
+	missing_argument_error_o
+) {
+	return assign(
+		new MissingArgumentError(message ?? missing_argument__default__message),
+		missing_argument_error_o)
+}
+/**
+ * Throws a missing_argument error (HTTP 500)
+ * @param {string}[message]
+ * @param {argument__missing_argument_error_o_T}[missing_argument_error_o]
+ * @example
+ * missing_argument__throw('foobar: not defined', { key: 'foobar' })
+ */
+export function missing_argument__throw(
+	message,
+	missing_argument_error_o
+) {
+	throw missing_argument_error_(message, missing_argument_error_o)
+}
+export class MissingArgumentError extends HttpError {
+	/**
+	 * @param {string}[message]
+	 */
+	constructor(message) {
+		super(message)
+		this.name = 'MissingArgumentError'
+		this.http__message = missing_argument__default__message
+		this.http__status = 500
+		if (!this.message) this.message = this.http__message
+	}
+}

package/all/mixin/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Mixin properties from source_a into target
+ * @example
+ * mixin(obj, {
+ *        get foo() {
+ *            return 'bar.js'
+ *        }
+ *    })
+ */
+export declare function mixin<
+	I extends unknown = unknown,
+	O = I
+>(target:I, ...source_a:O[]):I

package/all/mixin/index.js

@@ -0,0 +1,34 @@
+import { assign } from '../assign/index.js'
+/**
+ * Mixin properties from source_a into target
+ * @param {unknown}target
+ * @param {unknown}source_a
+ * @returns {unknown}
+ * @example
+ * mixin(obj, {
+ *        get foo() {
+ *            return 'bar.js'
+ *        }
+ *    })
+ */
+export function mixin(target, ...source_a) {
+	source_a.forEach((source)=>{
+		let descriptors1 = Object.keys(source).reduce((descriptors, key)=>{
+			assign(descriptors, {
+				[key]: Object.getOwnPropertyDescriptor(source, key)
+			})
+			return descriptors
+		}, {})
+		// By default, Object.assign copies enumerable Symbols, too
+		Object.getOwnPropertySymbols(source).forEach((sym)=>{
+			let descriptor = Object.getOwnPropertyDescriptor(source, sym)
+			if (descriptor.enumerable) {
+				assign(descriptors1, {
+					[sym]: descriptor
+				})
+			}
+		})
+		Object.defineProperties(target, descriptors1)
+	})
+	return target
+}

package/all/money_str/index.d.ts

@@ -0,0 +1,13 @@
+import type { nullish } from '../nullish/index.js'
+export declare function money_str_(
+	amount:number,
+	params?:money_str__params_T
+):string|nullish
+export {
+	money_str_ as _money_str,
+	money_str_ as format__money,
+}
+export interface money_str__params_T {
+	digits?:number
+}
+export declare type money_str_params_I = money_str__params_T

package/all/money_str/index.js

@@ -0,0 +1,26 @@
+import { comma_number_str_ } from '../comma_number_str/index.js'
+import { isNumber_ } from '../isNumber/index.js'
+import { nullish__none_ } from '../nullish__none/index.js'
+/** @typedef {import('../money_str/index.d.ts').money_str__params_T} */
+/**
+ * Formats money value with commas (no currency type)
+ * @param {number}amount
+ * @param {money_str__params_T}params
+ * @returns {string|import('../nullish/index.js').nullish}
+ */
+export function money_str_(
+	amount,
+	params
+) {
+	return nullish__none_([amount], ()=>{
+		const digits =
+			isNumber_(params && params.digits)
+				? params && params.digits
+				: 2
+		return comma_number_str_(amount.toFixed(digits))
+	})
+}
+export {
+	money_str_ as _money_str,
+	money_str_ as format__money,
+}

package/all/month_a/index.d.ts

@@ -0,0 +1,5 @@
+export declare const month_a:string[]
+export {
+	month_a as month_a1,
+	month_a as a1__month,
+}

package/all/month_a/index.js

@@ -0,0 +1,18 @@
+export const month_a = [
+	'January',
+	'February',
+	'March',
+	'April',
+	'May',
+	'June',
+	'July',
+	'August',
+	'September',
+	'October',
+	'November',
+	'December'
+]
+export {
+	month_a as month_a1,
+	month_a as a1__month,
+}

package/all/month_ms/index.d.ts

@@ -0,0 +1,5 @@
+export declare const month_ms:number
+export {
+	month_ms as month_milliseconds,
+	month_ms as milliseconds__month,
+}

package/all/month_ms/index.js

@@ -0,0 +1,6 @@
+import { month_seconds } from '../month_seconds/index.js'
+export const month_ms = month_seconds * 1000
+export {
+	month_ms as month_milliseconds,
+	month_ms as milliseconds__month,
+}

package/all/month_seconds/index.d.ts

@@ -0,0 +1,2 @@
+export declare const month_seconds = 2592000
+export { month_seconds as seconds__month }

package/all/month_seconds/index.js

@@ -0,0 +1,2 @@
+export const month_seconds = 2592000
+export { month_seconds as seconds__month }

package/all/ms/index.d.ts

@@ -0,0 +1,5 @@
+export declare function ms_(date?:Date):number
+export {
+	ms_ as milliseconds_,
+	ms_ as _milliseconds,
+}

package/all/ms/index.js

@@ -0,0 +1,12 @@
+/**
+ * @param {Date}[date]
+ * @returns {number}
+ * @private
+ */
+export function ms_(date = new Date()) {
+	return date.getTime()
+}
+export {
+	ms_ as milliseconds_,
+	ms_ as _milliseconds,
+}

package/all/mul/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Multiplies the arguments
+ */
+export declare function mul(values:readonly number[]):number

package/all/mul/index.js

@@ -0,0 +1,12 @@
+/**
+ * Multiplies the arguments
+ * @param {number}values
+ * @return number
+ */
+export function mul(values) {
+	let val = values[0]
+	for (let i = 1; i < values.length; i++) {
+		val *= values[i]
+	}
+	return val
+}

package/all/name_sort/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns an array sorted by `item.name`
+ */
+export declare function name_sort<
+	Obj extends {
+		name:string
+	} = {
+		name:string
+	}
+>(a:readonly Obj[]):Obj[]
+export {
+	name_sort as sort__name,
+	name_sort as sort__name__a1,
+}

package/all/name_sort/index.js

@@ -0,0 +1,13 @@
+import { key_compare_ } from '../key_compare/index.js'
+/**
+ * Returns an array sorted by `item.name`
+ * @param {{name:string}}a
+ * @returns {{name:string}[]}
+ */
+export function name_sort(a) {
+	return (a.slice(0) || []).sort(key_compare_('name'))
+}
+export {
+	name_sort as sort__name,
+	name_sort as sort__name__a1,
+}

package/all/negative/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns the negative of the numeric argument
+ */
+export declare function negative(num:number):number

package/all/negative/index.js

@@ -0,0 +1,8 @@
+/**
+ * Returns the negative of the numeric argument
+ * @param {number}num
+ * @returns number
+ */
+export function negative(num) {
+	return -1 * num
+}

package/all/neq/index.d.ts

@@ -0,0 +1,14 @@
+import type { wrap_a_T } from '../wrap_a/index.js'
+/**
+ * Returns `!=` operator to all values in `in_value_a`.
+ */
+export declare function neq<
+	I extends unknown = unknown
+>(in_value_a:wrap_a_T<I>):boolean
+/**
+ * Return function that Returns `!=` operator to all values in `in_value_a`.
+ */
+export declare function neq_<
+	I extends unknown = unknown
+>(in_value_a:I|I[]):(val:I)=>boolean
+export { neq_ as _neq, }

package/all/neq/index.js

@@ -0,0 +1,25 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns `!=` operator to all values in `in_value_a`.
+ * @param {import('../_function_types/index.js').wrap_a_T}in_value_a
+ * @returns {boolean}
+ */
+export function neq(in_value_a) {
+	const value_a = wrap_a_(in_value_a)
+	let current_value = value_a[0]
+	for (let i = 1; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (current_value == value) return false
+	}
+	return true
+}
+/**
+ * Return function that Returns `!=` operator to all values in `in_value_a`.
+ * @param {unknown|unknown[]}in_value_a
+ * @returns {(val:unknown)=>boolean}
+ */
+export function neq_(in_value_a) {
+	return val=>neq(wrap_concat(in_value_a, val))
+}
+export { neq_ as _neq, }

package/all/neql/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns `!==` operator to all values in `a_unwrap`.
+ */
+export declare function neql<
+	I extends unknown = unknown
+>(a_unwrap:I):boolean
+/**
+ * Returns function that returns `!==` operator to all values in `in_value_a`.
+ * @param in_value_a
+ * @returns {function(*=): boolean}
+ */
+export declare function neql_<
+	Arg extends unknown = unknown
+>(in_value_a:Arg[]):(value:Arg)=>boolean
+export { neql_ as _neql, }

package/all/neql/index.js

@@ -0,0 +1,24 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+/**
+ * Returns `!==` operator to all values in `a_unwrap`.
+ * @param {unknown}a_unwrap
+ * @returns {boolean}
+ */
+export function neql(a_unwrap) {
+	const value_a = wrap_a_(a_unwrap)
+	let current_value = value_a[0]
+	for (let i = 1; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (current_value === value) return false
+	}
+	return true
+}
+/**
+ * Returns function that returns `!==` operator to all values in `in_value_a`.
+ * @param {unknown}in_value_a
+ * @returns {(value:unknown)=>boolean}
+ */
+export function neql_(in_value_a) {
+	return (value)=>neql(wrap_concat(in_value_a, value))
+}
+export { neql_ as _neql, }

package/all/next_idx/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns Index of the next item, circular wrapping to the beginning (`0`).
+ */
+export declare function next_idx_(length:number, index?:number):number
+export {
+	next_idx_ as _next_idx,
+	next_idx_ as _idx__next,
+}

package/all/next_idx/index.js

@@ -0,0 +1,14 @@
+import { circular_idx_ } from '../circular_idx/index.js'
+/**
+ * Returns Index of the next item, circular wrapping to the beginning (`0`).
+ * @param {number}length
+ * @param {number}index
+ * @returns {number}
+ */
+export function next_idx_(length, index = 0) {
+	return circular_idx_(length, index + 1)
+}
+export {
+	next_idx_ as _next_idx,
+	next_idx_ as _idx__next,
+}

package/all/nf/index.d.ts

@@ -0,0 +1 @@
+export declare type nf = null|false

package/all/nf/index.js

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

package/all/no_comma_str/index.d.ts

@@ -0,0 +1,2 @@
+export declare function no_comma_str_(string:string):string|null|undefined
+export { no_comma_str_ as _no_comma_str, no_comma_str_ as unformat__commas, }

package/all/no_comma_str/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {string}string
+ * @returns {string}
+ * @private
+ */
+export function no_comma_str_(string) {
+	return string == null ? string : string.toString().replace(/,/g, '')
+}
+export { no_comma_str_ as _no_comma_str, no_comma_str_ as unformat__commas, }

package/all/noinit/index.d.ts

@@ -0,0 +1,9 @@
+export declare function noinit_<
+	Arg extends unknown = unknown,
+	Ret extends unknown = unknown
+>(fn:(...args:Arg[])=>Ret, times?:number):noinit_T<Arg, Ret>
+export declare type noinit_T<
+	Arg extends unknown = unknown,
+	Ret extends unknown = unknown
+> = (...args:Arg[])=>Ret|undefined
+export { noinit_ as _noinit, }

package/all/noinit/index.js

@@ -0,0 +1,16 @@
+/**
+ * @param {(...args:unknown[])=>unknown}fn
+ * @param {number}[times]
+ * @returns {import('./index.d.ts').noinit_T}
+ */
+export function noinit_(fn, times = 1) {
+	let times_called = 0
+	return (...args)=>{
+		if (times_called < times) {
+			times_called += 1
+			return
+		}
+		return fn(...args)
+	}
+}
+export { noinit_ as _noinit, }

package/all/noop/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns function that does nothing
+ */
+export declare function noop(..._:unknown[]):void

package/all/noop/index.js

@@ -0,0 +1,6 @@
+/**
+ * Returns function that does nothing
+ * @param {unknown}_
+ */
+export function noop(..._) {
+}

package/all/normal_random/index.d.ts

@@ -0,0 +1,2 @@
+export declare function normal_random_():number
+export { normal_random_ as _random__normal }

package/all/normal_random/index.js

@@ -0,0 +1,19 @@
+/**
+ * @returns {number}
+ * @see {@link https://npmdoc.github.io/node-npmdoc-mathjs/build/apidoc.html}
+ */
+export function normal_random_() {
+	let u1, u2, picked = -1
+	// We reject values outside of the interval [0, 1]
+	// TODO: check if it is ok to do that?
+	while (picked < 0 || picked > 1) {
+		u1 = Math.random()
+		u2 = Math.random()
+		picked =
+			1 / 6
+			* Math.pow(-2 * Math.log(u1), 0.5)
+			* Math.cos(2 * Math.PI * u2) + 0.5
+	}
+	return picked
+}
+export { normal_random_ as _random__normal }

package/all/normal_random_float/index.d.ts

@@ -0,0 +1,2 @@
+export declare function normal_random_float_(min?:number, max?:number):number
+export { normal_random_float_ as _float__random__normal }

package/all/normal_random_float/index.js

@@ -0,0 +1,6 @@
+import { distribution_random_float_ } from '../distribution_random_float/index.js'
+import { normal_random_ } from '../normal_random/index.js'
+export function normal_random_float_(min = 0.0, max = 1.0) {
+	return distribution_random_float_(min, max, normal_random_)
+}
+export { normal_random_float_ as _float__random__normal }

package/all/normal_random_int/index.d.ts

@@ -0,0 +1,2 @@
+export declare function normal_random_int_(min?:number, max?:number):number
+export { normal_random_int_ as _int__random__normal }

package/all/normal_random_int/index.js

@@ -0,0 +1,6 @@
+import { distribution_random_int_ } from '../distribution_random_int/index.js'
+import { normal_random_ } from '../normal_random/index.js'
+export function normal_random_int_(min = 0, max = 1) {
+	return distribution_random_int_(min, max, normal_random_)
+}
+export { normal_random_int_ as _int__random__normal }

package/all/not/index.d.ts

@@ -0,0 +1,17 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+/**
+ * Returns not applied to the spread of `in_value_a`
+ */
+export declare function not<
+	I extends unknown = unknown
+>(in_value_a:a_nowrap_T<I>):boolean
+/**
+ * Returns function that calls [not](#not) with [wrap_concat](#wrap_concat)  of the arguments.
+ */
+export declare function not_<
+	I extends unknown = unknown
+>(a_unwrap:a_nowrap_T<I>):not_T<I>
+export declare type not_T<
+	I extends unknown = unknown
+> = (val_a:I[])=>boolean
+export { not_ as _not, }

package/all/not/index.js

@@ -0,0 +1,24 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns not applied to the spread of `in_value_a`
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}in_value_a
+ * @returns {boolean}
+ */
+export function not(in_value_a) {
+	const value_a = wrap_a_(in_value_a)
+	for (let i = 0; i < value_a.length; i++) {
+		const value = value_a[i]
+		if (value) return false
+	}
+	return true
+}
+/**
+ * Returns function that calls [not](#not) with [wrap_concat](#wrap_concat)  of the arguments.
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_unwrap
+ * @returns {import('../not/index.js').not_T}
+ */
+export function not_(a_unwrap) {
+	return (val_a)=>not(wrap_concat(a_unwrap, val_a))
+}
+export { not_ as _not, }

package/all/not_found/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 not_found__default__message:string
+export declare function not_found_error_(
+	message?:string,
+	error_o?:error_o_T
+):NotFoundError
+/**
+ * Throws a Not Found error (HTTP 401)
+ * @example
+ * not_found__throw(error_o) // Not Found
+ */
+export declare function not_found__throw(
+	message?:string,
+	error_o?:error_o_T
+):void
+export declare class NotFoundError
+	extends HttpError
+	implements error_o_error_T {
+}

package/all/not_found/index.js

@@ -0,0 +1,44 @@
+import { assign } from '../assign/index.js'
+import { HttpError } from '../http_error/index.js'
+/** @typedef {import('../error_o/index.d.ts').argument__error_o_T} */
+export const not_found__default__message = 'Not Found'
+/**
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @returns {NotFoundError}
+ * @private
+ */
+export function not_found_error_(
+	message,
+	error_o
+) {
+	return assign(
+		new NotFoundError(message ?? not_found__default__message),
+		error_o)
+}
+/**
+ * Throws a Not Found error (HTTP 401)
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @example
+ * not_found__throw(error_o) // Not Found
+ */
+export function not_found__throw(
+	message,
+	error_o
+) {
+	throw not_found_error_(message, error_o)
+}
+/** @type {import('./index.d.ts').NotFoundError} */
+export class NotFoundError extends HttpError {
+	/**
+	 * @param {string}[message]
+	 */
+	constructor(message) {
+		super(message)
+		this.name = 'NotFoundError'
+		this.http__status = 404
+		this.http__message = not_found__default__message
+		if (!this.message) this.message = this.http__message
+	}
+}

package/all/not_nullish__query_str/index.d.ts

@@ -0,0 +1,6 @@
+export declare function not_nullish__query_str_(query?:Record<string, any>):string
+export {
+	not_nullish__query_str_ as not_nullish_query_str_,
+	not_nullish__query_str_ as _not_null_query_str,
+	not_nullish__query_str_ as _str__query__not__null,
+}

package/all/not_nullish__query_str/index.js

@@ -0,0 +1,19 @@
+/**
+ * @param {Record<string, any>}query
+ * @returns {string}
+ */
+export function not_nullish__query_str_(query = {}) {
+	const query_str_a = []
+	for (let key in query) {
+		const value = query[key]
+		if (value != null) {
+			query_str_a.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+		}
+	}
+	return query_str_a.length ? `?${query_str_a.join('&')}` : ''
+}
+export {
+	not_nullish__query_str_ as not_nullish_query_str_,
+	not_nullish__query_str_ as _not_null_query_str,
+	not_nullish__query_str_ as _str__query__not__null,
+}

package/all/notnot/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns the truthiness of all values in `in_value_a`
+ */
+export declare function notnot<I>(in_value_a:I|I[]):boolean
+/**
+ * Returns function that calls [notnot](#notnot) with [wrap_concat](#wrap_concat) of the arguments.
+ */
+export declare function notnot_<
+	Val extends unknown = unknown
+>(in_value_a:Val|Val[]):(val:Val)=>boolean
+export declare type notnot_T<Val extends unknown = unknown> = (val:Val)=>boolean
+export { notnot_ as _notnot, }