ctx-core 2.2.0 → 2.2.2

package/all/headers/index.d.ts

@@ -0,0 +1,2 @@
+export declare const Headers:Headers
+export declare function headers__new(init?:HeadersInit):HeadersInit|undefined

package/all/headers/index.js

@@ -0,0 +1,10 @@
+/** @typedef {import('../headers/index.d.ts').Headers} */
+export const { Headers } = globalThis
+/**
+ * @param {HeadersInit}[init]
+ * @returns {HeadersInit|undefined}
+ * @private
+ */
+export function headers__new(init) {
+	return new Headers(init)
+}

package/all/hex__digest/index.d.ts

@@ -0,0 +1,5 @@
+import type { digest__algorithm_T } from '../digest__algorithm/index.js'
+export declare function hex__digest(
+	algorithm:digest__algorithm_T,
+	message:string|BufferSource
+):Promise<string>

package/all/hex__digest/index.js

@@ -0,0 +1,24 @@
+import { crypto_ } from '../crypto/index.js'
+/**
+ * @param {import('../hex__digest/index.js').digest__algorithm_T}algorithm
+ * @param {string|BufferSource}message
+ * @returns {Promise<string>}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest}
+ */
+export async function hex__digest(
+	algorithm,
+	message,
+) {
+	if (typeof message === 'string') {
+		// encode as (utf-8) Uint8Array
+		message = new TextEncoder().encode(message)
+	}
+	const crypto = await crypto_()
+	const hash_buffer =
+		await crypto.subtle.digest(algorithm, message) // hash the message
+	const hash_array =
+		Array.from(new Uint8Array(hash_buffer)) // convert hash_buffer to byte array
+	return hash_array
+		.map((b)=>b.toString(16).padStart(2, '0'))
+		.join('') // convert bytes to hex string
+}

package/all/hex_int/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert hex to int
+ */
+export declare function hex_int_(hex:string):number
+export { hex_int_ as _hex_int, hex_int_ as _int__hex, }

package/all/hex_int/index.js

@@ -0,0 +1,7 @@
+/**
+ * Convert hex to int
+ */
+export function hex_int_(hex) {
+	return parseInt(hex, 16)
+}
+export { hex_int_ as _hex_int, hex_int_ as _int__hex, }

package/all/hmac/index.d.ts

@@ -0,0 +1,6 @@
+import type { digest__algorithm_T } from '../digest__algorithm/index.js'
+export declare function hmac_(
+	algorithm:digest__algorithm_T,
+	key:string|BufferSource|CryptoKey,
+	data:string|BufferSource
+):Promise<string>

package/all/hmac/index.js

@@ -0,0 +1,32 @@
+import { buffer__hex_ } from '../buffer__hex/index.js'
+import { crypto__sign } from '../crypto__sign/index.js'
+import { hmac_key_ } from '../hmac_key/index.js'
+/**
+ * @param {import('../hmac/index.js').digest__algorithm_T}algorithm
+ * @param {string|BufferSource|CryptoKey}key
+ * @param {string|BufferSource}data
+ * @returns {Promise<string>}
+ * @see https://lukasmurdock.com/web-hmac/
+ * @private
+ */
+export async function hmac_(
+	algorithm,
+	key,
+	data
+) {
+	if (!key.algorithm) {
+		key = await hmac_key_(algorithm, key)
+	}
+	if (typeof data === 'string') {
+		const encoder = new TextEncoder()
+		data = encoder.encode(data)
+	}
+	/**
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/sign#hmac_2
+	 */
+	const signature = await crypto__sign(
+		'HMAC',
+		key,
+		data)
+	return buffer__hex_(signature)
+}

package/all/hmac_key/index.d.ts

@@ -0,0 +1,5 @@
+import type { digest__algorithm_T } from '../digest__algorithm/index.js'
+export declare function hmac_key_(
+	algorithm:digest__algorithm_T,
+	key:string|BufferSource
+):Promise<CryptoKey>

package/all/hmac_key/index.js

@@ -0,0 +1,30 @@
+import { crypto_ } from '../crypto/index.js'
+/**
+ * @param {import('../hmac_key/index.js').digest__algorithm_T}algorithm
+ * @param {string|BufferSource}key
+ * @returns {Promise<CryptoKey>}
+ * @see https://lukasmurdock.com/web-hmac/
+ * @private
+ */
+export async function hmac_key_(
+	algorithm,
+	key
+) {
+	if (typeof key === 'string') {
+		const encoder = new TextEncoder()
+		key = encoder.encode(key)
+	}
+	const crypto = await crypto_()
+	/**
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
+	 */
+	return crypto.subtle.importKey(
+		'raw',
+		key,
+		{
+			name: 'HMAC',
+			hash: algorithm
+		},
+		true,
+		['sign', 'verify'])
+}

package/all/hostname/index.d.ts

@@ -0,0 +1,2 @@
+export declare function hostname_():string
+export { hostname_ as _hostname, }

package/all/hostname/index.js

@@ -0,0 +1,9 @@
+/**
+ * @returns {string}
+ * @private
+ */
+export function hostname_() {
+	const hostname = typeof window === 'object' && window.location.hostname || ''
+	return hostname
+}
+export { hostname_ as _hostname, }

package/all/hour/index.d.ts

@@ -0,0 +1,7 @@
+export declare const hour_ms:number
+export declare const hour_sec:number
+export {
+	hour_ms as hour,
+	hour_ms as hour_milliseconds,
+	hour_ms as milliseconds__hour,
+}

package/all/hour/index.js

@@ -0,0 +1,8 @@
+import { minute_ms, minute_sec } from '../minute/index.js'
+export const hour_ms = 60 * minute_ms
+export const hour_sec = 60 * minute_sec
+export {
+	hour_ms as hour,
+	hour_ms as hour_milliseconds,
+	hour_ms as milliseconds__hour,
+}

package/all/hour_seconds/index.d.ts

@@ -0,0 +1,2 @@
+export declare const hour_seconds = 3600
+export { hour_seconds as seconds__hour }

package/all/hour_seconds/index.js

@@ -0,0 +1,2 @@
+export const hour_seconds = 3600
+export { hour_seconds as seconds__hour }

package/all/http_error/index.d.ts

@@ -0,0 +1,20 @@
+import type { argument__error_o_T, error_o_error_T } from '../error_o/index.js'
+export declare function http_error_(
+	message?:string,
+	error_o?:argument__error_o_T
+):HttpError
+/**
+ * HttpError
+ * @example
+ * http_error__throw('Error fetching document') // Unauthorized
+ */
+export declare function http_error__throw(
+	message?:string,
+	error_o?:argument__error_o_T
+):void
+export declare class HttpError extends Error implements error_o_error_T {
+	data?:any
+	http__message?:string
+	http__status?:number
+	url?:string
+}

package/all/http_error/index.js

@@ -0,0 +1,35 @@
+import { assign } from '../assign/index.js'
+/** @typedef {import('../error_o/index.d.ts').argument__error_o_T} */
+/** @typedef {import('../http_error/index.d.ts').HttpError}HttpError */
+/**
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @returns {HttpError}
+ */
+export function http_error_(message, error_o) {
+	return assign(
+		new /** @type {any} */HttpError(message),
+		error_o)
+}
+/**
+ * HttpError
+ * @param {string}[message]
+ * @param {argument__error_o_T}error_o
+ * @example
+ * http_error__throw(ctx) // Unauthorized
+ */
+export function http_error__throw(message, error_o) {
+	throw http_error_(message, error_o)
+}
+/** @type {import('./index.d.ts')} */
+export class HttpError extends Error {
+	/**
+	 * @param {string}[message]
+	 */
+	constructor(message) {
+		super(message)
+		this.name = 'HttpError'
+		this.http__message = message
+		this.http__status = 500
+	}
+}

package/all/idx/index.d.ts

@@ -0,0 +1,11 @@
+import type { is_match__T } from '../array_types/index.js'
+/**
+ * Returns idx of first match in `a` with `compare`.
+ */
+export declare function idx_<
+	Val extends unknown = unknown
+>(
+	in_a:readonly Val[]|undefined,
+	compare:is_match__T<Val>
+):number
+export { idx_ as _idx, }

package/all/idx/index.js

@@ -0,0 +1,17 @@
+/**
+ * Returns idx of first match in `a` with `compare`.
+ * @param {unknown[]|undefined}in_a
+ * @param {import('../array_types/index.js').is_match__T}compare
+ * @returns {number}
+ */
+export function idx_(in_a, compare) {
+	if (in_a) {
+		const a = in_a
+		for (let idx = 0; idx < a.length; idx++) {
+			const value = a[idx]
+			if (value === compare || typeof compare === 'function' && compare(value, idx)) return idx
+		}
+	}
+	return -1
+}
+export { idx_ as _idx, }

package/all/idx_a/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns an Array of incrementing index (`idx`) values with `start=0`.
+ */
+export declare function idx_a_(count:number, start?:number):number[]
+export {
+	idx_a_ as idx_a1_fn,
+	idx_a_ as _idx_a1,
+	idx_a_ as _a1__idx,
+}

package/all/idx_a/index.js

@@ -0,0 +1,20 @@
+/**
+ * Returns an Array of incrementing index (`idx`) values with `start=0`.
+ */
+/**
+ * @param count{number}
+ * @param start{number}
+ * @returns {number[]}
+ */
+export function idx_a_(count, start = 0) {
+	const idx_a = []
+	for (let i = 0; i < count; i++) {
+		idx_a.push(start + i)
+	}
+	return idx_a
+}
+export {
+	idx_a_ as idx_a1_fn,
+	idx_a_ as _idx_a1,
+	idx_a_ as _a1__idx,
+}

package/all/idx_a/index.test.ts

@@ -0,0 +1,9 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { idx_a_ } from '../idx_a/index.js'
+test('idx_a_', ()=>{
+	equal(idx_a_(5), [0, 1, 2, 3, 4])
+	equal(idx_a_(5, 0), [0, 1, 2, 3, 4])
+	equal(idx_a_(5, 3), [3, 4, 5, 6, 7])
+})
+test.run()

package/all/idx_filter/index.d.ts

@@ -0,0 +1,32 @@
+import type { a_item_T } from '../a_item/index.js'
+import type { is_match__T } from '../array_types/index.js'
+/**
+ * Returns Array of `idx` indices filtered by `fn`.
+ */
+export declare function idx_filter<I extends readonly unknown[]>(
+	in_a:I,
+	is_match_?:is_match__T<a_item_T<I>>
+):number[]
+export declare function maybe_idx_filter<
+	I extends readonly number[], Or = null
+>(
+	maybe_a:I|undefined,
+	is_match_?:is_match__T<a_item_T<I>>,
+	or?:Or
+):number[]|Or
+/**
+ * Returns function that returns value from [idx_filter](#idx_filter) with `fn` argument.
+ */
+export declare function idx_filter_(
+	is_match_?:is_match__T<number>
+):(a:number[])=>number[]
+export declare function maybe_idx_filter_(
+	is_match_?:is_match__T<number>
+):(a:number[]|undefined)=>number[]|undefined
+export {
+	idx_filter as filter__idx,
+	idx_filter_ as _idx_filter,
+	maybe_idx_filter_ as _maybe_idx_filter,
+	idx_filter_ as _filter__idx,
+	idx_filter_ as _fn__filter__idx,
+}

package/all/idx_filter/index.js

@@ -0,0 +1,57 @@
+import { I__ } from '../combinators/index.js'
+/** @typedef {import('../a_item/index.d.ts').a_item_T}a_item_T */
+/** @typedef {import('../array_types/index.d.ts').is_match__T}is_match__T */
+/**
+ * Returns Array of `idx` indices filtered by `fn`.
+ * @param {unknown[]}in_a
+ * @param {is_match__T<a_item_T<unknown>>}is_match_
+ * @returns {number[]}
+ */
+export function idx_filter(in_a, is_match_ = I__) {
+	const a = in_a
+	const idx_a = []
+	for (let idx = 0; idx < a.length; idx++) {
+		const value = a[idx]
+		if (is_match_(value, idx)) {
+			idx_a.push(idx)
+		}
+	}
+	return idx_a
+}
+/**
+ * @param maybe_a{number[]|undefined}
+ * @param is_match_{is_match__T<a_item_T<unknown>>}
+ * @param or{number[]|null|undefined}
+ * @returns {number[]|null|undefined}
+ */
+export function maybe_idx_filter(
+	maybe_a,
+	is_match_ = I__,
+	or = null
+) {
+	if (!maybe_a) return or
+	return idx_filter(maybe_a, is_match_)
+}
+/**
+ * Returns function that returns value from [idx_filter](#idx_filter) with `fn` argument.
+ * @param is_match_{is_match__T<number>}
+ * @returns {(a:number[])=>number[]}
+ */
+export function idx_filter_(is_match_ = I__) {
+	return (a)=>idx_filter(a, is_match_)
+}
+/**
+ * @param is_match_{is_match__T<number>}
+ * @returns {(a:number[]|undefined)=>number[]|undefined}
+ * @private
+ */
+export function maybe_idx_filter_(is_match_ = I__) {
+	return (a)=>maybe_idx_filter(a, is_match_)
+}
+export {
+	idx_filter as filter__idx,
+	idx_filter_ as _idx_filter,
+	maybe_idx_filter_ as _maybe_idx_filter,
+	idx_filter_ as _filter__idx,
+	idx_filter_ as _fn__filter__idx,
+}

package/all/idx_key_r/index.d.ts

@@ -0,0 +1,49 @@
+import type { item_key_idx_val_fn_T } from '../array_types/index.js'
+/**
+ * Returns a Hash where each key is `a[idx][key]` & value is `idx`.
+ */
+export declare function idx_key_r_<
+	Obj extends Record<string, string> = Record<string, string>
+>(
+	a:readonly Obj[],
+	key:string|number,
+	item_key_idx_val_?:item_key_idx_val_fn_T<string, Obj>
+):idx_key_r_T
+export declare type idx_key_r_T = Record<string, number>
+export declare function maybe_idx_key_r_<
+	Obj extends Record<string, string> = Record<string, string>, Or = null
+>(
+	maybe_a:readonly Obj[]|undefined,
+	key:string|number,
+	item_key_idx_val_?:item_key_idx_val_fn_T<string, Obj>,
+	or?:Or
+):idx_key_r_T|Or
+export {
+	idx_key_r_ as idx_key_h_,
+	idx_key_r_ as _idx_key_hash,
+	idx_key_r_ as _hash__key__idx,
+	maybe_idx_key_r_ as maybe_idx_key_h_,
+	maybe_idx_key_r_ as _maybe_idx_key_hash,
+}
+/**
+ * Returns function that returns from [_idx_key_hash](#_idx_key_hash) with `item_key_idx_val_` function argument.
+ */
+export declare function idx_key_r__<
+	Obj extends Record<string, string> = Record<string, string>
+>(
+	item_key_idx_val_?:item_key_idx_val_fn_T<string, Obj>
+):(a:readonly Obj[], key:string|number)=>idx_key_r_T
+export declare function maybe_idx_key_r__<
+	Obj extends Record<string, string> = Record<string, string>,
+	Or = null
+>(
+	item_key_idx_val_?:item_key_idx_val_fn_T<string, Obj>,
+	or?:Or
+):(maybe_a:Obj[]|undefined, key:string)=>idx_key_r_T|Or
+export {
+	idx_key_r__ as idx_key_h_2,
+	idx_key_r__ as _idx_key_hash_fn,
+	idx_key_r__ as _fn__idx_key_hash,
+	maybe_idx_key_r__ as _maybe_idx_key_hash_fn,
+	maybe_idx_key_r__ as maybe_idx_key_h_2,
+}

package/all/idx_key_r/index.js

@@ -0,0 +1,78 @@
+import { I__ } from '../combinators/index.js'
+/** @typedef {import('../array_types/index.d.ts').item_key_idx_val_fn_T}item_key_idx_val_fn_T */
+/** @typedef {import('../idx_key_r/index.d.ts').idx_key_r_T}idx_key_r_T */
+/**
+ * Returns a Hash where each key is `a[idx][key]` & value is `idx`.
+ * @param {unknown[]}a
+ * @param {string|number}key
+ * @param {item_key_idx_val_fn_T<string, Record<string, string>>}item_key_idx_val_
+ * @returns {idx_key_r_T}
+ */
+export function idx_key_r_(a, key, item_key_idx_val_ = I__) {
+	let idx_key_r = {}
+	if (a) {
+		for (let idx = 0; idx < a.length; idx++) {
+			const obj = a[idx]
+			const val =
+				item_key_idx_val_
+					? item_key_idx_val_(obj && obj[key], obj, key, idx)
+					: obj && obj[key]
+			if (!val) continue
+			idx_key_r[val] = idx
+		}
+	}
+	return idx_key_r
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {string|number}key
+ * @param {item_key_idx_val_fn_T<string, Record<string, string>>}item_key_idx_val_
+ * @param {idx_key_r_T|null|undefined}or
+ * @returns {idx_key_r_T|null|undefined}
+ */
+export function maybe_idx_key_r_(
+	maybe_a,
+	key,
+	item_key_idx_val_ = I__,
+	or = null
+) {
+	return maybe_a ? idx_key_r_(maybe_a, key, item_key_idx_val_) : or
+}
+export {
+	idx_key_r_ as idx_key_h_,
+	idx_key_r_ as _idx_key_hash,
+	idx_key_r_ as _hash__key__idx,
+	maybe_idx_key_r_ as maybe_idx_key_h_,
+	maybe_idx_key_r_ as _maybe_idx_key_hash,
+}
+/** @typedef {import('./index.d.ts').idx_key_r_T}idx_key_r_T */
+/** @typedef {import('../array_types/index.d.ts').item_key_idx_val_fn_T}item_key_idx_val_f	n_T */
+/**
+ * Returns function that returns from [_idx_key_hash](#_idx_key_hash) with `item_key_idx_val_` function argument.
+ * @param {item_key_idx_val_fn_T<string, Record<string, string>>}item_key_idx_val_
+ * @returns {(a:Record<string, string>[], key:string|number)=>idx_key_r_T}
+ */
+export function idx_key_r__(
+	item_key_idx_val_ = I__
+) {
+	return (a, key)=>idx_key_r_(a, key, item_key_idx_val_)
+}
+/**
+ * @param {item_key_idx_val_fn_T<string, Record<string, string>>}item_key_idx_val_
+ * @param {idx_key_r_T|null|unknown}or
+ * @returns {(maybe_a:Record<string, string>[]|undefined, key:string)=>idx_key_r_T|null|unknown}
+ */
+export function maybe_idx_key_r__(
+	item_key_idx_val_ = I__,
+	or = null
+) {
+	return (maybe_a, key)=>
+		maybe_idx_key_r_(maybe_a, key, item_key_idx_val_, or)
+}
+export {
+	idx_key_r__ as idx_key_h_2,
+	idx_key_r__ as _idx_key_hash_fn,
+	idx_key_r__ as _fn__idx_key_hash,
+	maybe_idx_key_r__ as _maybe_idx_key_hash_fn,
+	maybe_idx_key_r__ as maybe_idx_key_h_2,
+}

package/all/idx_reject/index.d.ts

@@ -0,0 +1,30 @@
+import type { is_match__T } from '../array_types/index.js'
+/**
+ * Returns Array of indices `idx` not rejected by `is_match_`.
+ */
+export declare function idx_reject<
+	Val extends unknown = unknown
+>(
+	a:readonly Val[], is_match_:is_match__T<Val>
+):number[]
+export declare function maybe_idx_reject<
+	Val extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly Val[]|undefined,
+	is_match_:is_match__T<Val>,
+	or?:Or
+):number[]|Or
+export { idx_reject as reject__idx, }
+/**
+ * Returns function that returns value from [idx_reject](#idx_reject) with `is_match_` argument.
+ */
+export declare function idx_reject_<
+	Val extends unknown = unknown
+>(
+	is_match_:is_match__T<Val>
+):(a:readonly Val[])=>number[]
+export {
+	idx_reject_ as _idx_reject,
+	idx_reject_ as _reject__idx,
+	idx_reject_ as _fn__reject__idx,
+}

package/all/idx_reject/index.js

@@ -0,0 +1,45 @@
+/** @typedef {import('../array_types/index.d.ts').is_match__T} */
+/**
+ * Returns Array of indices `idx` not rejected by `is_match_`.
+ * @param {unknown[]}a
+ * @param {is_match__T}is_match_
+ * @returns {number[]}
+ */
+export function idx_reject(a, is_match_) {
+	const out_a = []
+	for (let idx = 0; idx < a.length; idx++) {
+		const value = a[idx]
+		if (is_match_(value, idx)) {
+			out_a.push(idx)
+		}
+	}
+	return out_a
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {is_match__T}is_match_
+ * @param {number[]|null|undefined}or
+ * @returns {number[]|null|undefined}
+ */
+export function maybe_idx_reject(
+	maybe_a,
+	is_match_,
+	or = null
+) {
+	if (!maybe_a) return or
+	return idx_reject(maybe_a, is_match_)
+}
+export { idx_reject as reject__idx, }
+/**
+ * Returns function that returns the value from [idx_reject](#idx_reject) with `is_match_` argument.
+ * @param {is_match__T}is_match_
+ * @returns {(a:unknown[])=>number[]}
+ */
+export function idx_reject_(is_match_) {
+	return a=>idx_reject(a, is_match_)
+}
+export {
+	idx_reject_ as _idx_reject,
+	idx_reject_ as _reject__idx,
+	idx_reject_ as _fn__reject__idx,
+}

package/all/idx_sort_a/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sort `val_a` by an array of indices in `in_sort_idx_a`.
+ */
+export declare function idx_sort_a_<
+	I extends unknown = unknown
+>(
+	val_a:readonly I[],
+	in_sort_idx_a:readonly number[]|undefined
+):I[]
+export declare function maybe_idx_sort_a_<
+	I = unknown, Or = null
+>(
+	in_val_a:readonly I[]|undefined,
+	in_sort_idx_a:readonly number[]|undefined,
+	or?:Or
+):I[]|Or
+export {
+	idx_sort_a_ as idx_sort_a1_fn,
+	idx_sort_a_ as _idx_sort_a1,
+	idx_sort_a_ as _a1__sort__idx,
+	maybe_idx_sort_a_ as maybe_idx_sort_a1_fn,
+	maybe_idx_sort_a_ as _maybe_idx_sort_a1,
+}

package/all/idx_sort_a/index.js

@@ -0,0 +1,39 @@
+/**
+ * Sort `val_a` by an array of indices in `in_sort_idx_a`.
+ * @param {unknown[]}val_a
+ * @param {number[]|undefined}in_sort_idx_a
+ * @returns {unknown[]}
+ */
+export function idx_sort_a_(val_a, in_sort_idx_a) {
+	const sort_idx_a = in_sort_idx_a
+	const idx_sort_a = []
+	for (let i = 0; i < sort_idx_a.length; i++) {
+		const idx = sort_idx_a[i]
+		idx_sort_a.push(val_a[idx])
+	}
+	return idx_sort_a
+}
+export {
+	idx_sort_a_ as idx_sort_a1_fn,
+	idx_sort_a_ as _idx_sort_a1,
+	idx_sort_a_ as _a1__sort__idx,
+}
+/**
+ * @param {unknown[]|undefined}in_val_a
+ * @param {number[]|undefined}in_sort_idx_a
+ * @param {unknown[]|null|undefined}or
+ * @returns {unknown[]|null|undefined}
+ * @private
+ */
+export function maybe_idx_sort_a_(
+	in_val_a,
+	in_sort_idx_a,
+	or = null
+) {
+	if (!in_sort_idx_a || !in_val_a) return or
+	return idx_sort_a_(in_val_a, in_sort_idx_a)
+}
+export {
+	maybe_idx_sort_a_ as maybe_idx_sort_a1_fn,
+	maybe_idx_sort_a_ as _maybe_idx_sort_a1,
+}