ctx-core 2.2.0 → 2.2.2

package/all/left_and/index.js

@@ -0,0 +1,14 @@
+import { and } from '../and/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns function that returns the first falsy in `a_unwrap` or `value`.
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_unwrap
+ * @returns {(val:unknown)=>unknown}
+ */
+export function left_and_(a_unwrap) {
+	return val=>and(wrap_concat(a_unwrap, val))
+}
+export {
+	left_and_ as _left_and,
+	left_and_ as _and__left,
+}

package/all/left_or/index.d.ts

@@ -0,0 +1,11 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+/**
+ * Returns function that returns first truthy item in `a_unwrap` or value.
+ */
+export declare function left_or_<
+	Val extends unknown = unknown
+>(a_unwrap:a_nowrap_T<Val>):(val:Val)=>(Val|undefined)
+export {
+	left_or_ as _left_or,
+	left_or_ as _or__left,
+}

package/all/left_or/index.js

@@ -0,0 +1,14 @@
+import { or } from '../or/index.js'
+import { wrap_concat } from '../wrap_concat/index.js'
+/**
+ * Returns function that returns first truthy item in `a_unwrap` or value.
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_unwrap
+ * @returns {(val:unknown)=>unknown}
+ */
+export function left_or_(a_unwrap) {
+	return val=>or(wrap_concat(a_unwrap, val))
+}
+export {
+	left_or_ as _left_or,
+	left_or_ as _or__left,
+}

package/all/line__parse/index.d.ts

@@ -0,0 +1,18 @@
+import type { readable_stream_OR_reader_T } from '../readable_stream_OR_reader/index.js'
+export declare function line__parse(
+	readable_stream_or_reader:readable_stream_OR_reader_T,
+	params?:line__parse__params_T
+):AsyncIterable<string>
+export declare function line__parse(
+	on_line:line_iterator__on_line_T,
+	readable_stream_or_reader:readable_stream_OR_reader_T,
+	params?:line__parse__params_T
+):void
+export {
+	line__parse as line_iterator_,
+}
+export interface line__parse__params_T {
+	include_line_separator?:boolean
+	text_decoder?:TextDecoder
+}
+export type line_iterator__on_line_T = (line:string)=>any

package/all/line__parse/index.js

@@ -0,0 +1,97 @@
+/** @typedef {import('../readable_stream_OR_reader/index.d.ts').readable_stream_OR_reader_T} */
+/** @typedef {import('../line__parse/index.d.ts').line_iterator__on_line_T} */
+/** @typedef {import('../line__parse/index.d.ts').line__parse__params_T} */
+/**
+ * @param {line_iterator__on_line_T|readable_stream_OR_reader_T}on_line_or_readable_stream_or_reader
+ * @param {readable_stream_OR_reader_T|line__parse__params_T}[readable_stream_or_reader_or_params]
+ * @param {line__parse__params_T}[params]
+ * @returns {void|AsyncIterable<string>}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader/read#example_2_-_handling_text_line_by_line}
+ * @private
+ */
+export function line__parse(
+	on_line_or_readable_stream_or_reader,
+	readable_stream_or_reader_or_params,
+	params
+) {
+	const on_line =
+		typeof on_line_or_readable_stream_or_reader === 'function'
+			? on_line_or_readable_stream_or_reader
+			: null
+	/** @type {readable_stream_OR_reader_T} */
+	const readable_stream_or_reader =
+		on_line
+			? readable_stream_or_reader_or_params
+			: on_line_or_readable_stream_or_reader
+	if (!on_line) params = readable_stream_or_reader_or_params
+	const text_decoder =
+		params?.text_decoder
+		?? new TextDecoder('utf-8')
+	const include_line_separator =
+		params?.include_line_separator
+		?? false
+	return (
+		on_line
+			? line__parse__iterator_().next().then($=>$.value)
+			: line__parse__iterator_())
+	async function* line__parse__iterator_() {
+		/** @type {ReadableStreamDefaultReader|ReadableStreamBYOBReader} */
+		const reader =
+			(/** @type {ReadableStream} */readable_stream_or_reader).getReader
+				? (/** @type {ReadableStream} */readable_stream_or_reader).getReader()
+				: readable_stream_or_reader
+		let {
+			value: chunk,
+			done: readerDone
+		} = await reader.read()
+		chunk =
+			chunk
+				? chunk.byteLength
+					? text_decoder.decode(chunk, { stream: true })
+					: chunk
+				: ''
+		const re = /\r\n|\n|\r/gm
+		let startIndex = 0
+		for (; ;) {
+			let result = re.exec(chunk)
+			if (!result) {
+				if (readerDone) {
+					break
+				}
+				let remainder = chunk.substring(startIndex);
+				({ value: chunk, done: readerDone } = await reader.read())
+				chunk =
+					remainder
+					+ (
+						chunk
+							? chunk.byteLength
+								? text_decoder.decode(chunk, { stream: true })
+								: chunk
+							: '')
+				startIndex = re.lastIndex = 0
+				continue
+			}
+			const line = chunk.substring(
+				startIndex,
+				result.index + (include_line_separator ? result[0].length : 0))
+			if (on_line) {
+				on_line(line)
+			} else {
+				yield line
+			}
+			startIndex = re.lastIndex
+		}
+		if (startIndex < chunk.length) {
+			// last line didn't end in a newline char
+			let line = chunk.slice(startIndex)
+			if (on_line) {
+				on_line(line)
+			} else {
+				yield line
+			}
+		}
+	}
+}
+export {
+	line__parse as line_iterator_,
+}

package/all/line__parse/index.test.ts

@@ -0,0 +1,96 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { line__parse } from '..//line__parse/index.js'
+test('line__parse|!include_line_separator|callback', async ()=>{
+	const text_encoder = new TextEncoder()
+	const readable_stream = new ReadableStream({
+		start(controller) {
+			controller.enqueue(text_encoder.encode('foo\n'))
+			controller.enqueue('bar\nbaz\n')
+			controller.enqueue(text_encoder.encode('\n'))
+		},
+		pull(controller) {
+			controller.close()
+		}
+	})
+	const line_a:string[] = []
+	await line__parse(
+		line=>line_a.push(line),
+		readable_stream)
+	equal(line_a, [
+		'foo',
+		'bar',
+		'baz',
+		'',
+	])
+})
+test('line__parse|include_line_separator|callback', async ()=>{
+	const readable_stream = new ReadableStream({
+		start(controller) {
+			controller.enqueue('foo\n')
+			controller.enqueue('bar baz\r\n')
+			controller.enqueue('quux\r')
+		},
+		pull(controller) {
+			controller.close()
+		}
+	})
+	const line_a:string[] = []
+	await line__parse(
+		line=>line_a.push(line),
+		readable_stream,
+		{ include_line_separator: true })
+	equal(line_a, [
+		'foo\n',
+		'bar baz\r\n',
+		'quux\r',
+	])
+})
+test('line__parse|!include_line_separator|iterator', async ()=>{
+	const readable_stream = new ReadableStream({
+		start(controller) {
+			controller.enqueue('foo\n')
+			controller.enqueue('bar baz\n')
+			controller.enqueue('\n')
+			controller.enqueue(null)
+		},
+		pull(controller) {
+			controller.close()
+		}
+	})
+	const line_a:string[] = []
+	for await (const line of line__parse(readable_stream)) {
+		line_a.push(line)
+	}
+	equal(line_a, [
+		'foo',
+		'bar baz',
+		'',
+	])
+})
+test('line__parse|!include_line_separator|iterator', async ()=>{
+	const readable_stream = new ReadableStream({
+		start(controller) {
+			controller.enqueue('foo\n')
+			controller.enqueue('bar baz\n')
+			controller.enqueue('\n')
+			controller.enqueue(null)
+		},
+		pull(controller) {
+			controller.close()
+		}
+	})
+	const line_a:string[] = []
+	for await (const line of line__parse(
+		readable_stream,
+		{ include_line_separator: true }
+	)) {
+		line_a.push(line)
+	}
+	equal(line_a, [
+		'foo\n',
+		'bar baz\n',
+		'\n',
+	])
+})
+test.run()

package/all/line__transform_stream/index.d.ts

@@ -0,0 +1,8 @@
+export declare function line__transform_stream_(
+	params?:line__transform_stream___params_T,
+	writable_strategy?:QueuingStrategy<string>,
+	readable_strategy?:QueuingStrategy<string>
+):TransformStream<string, string>
+export interface line__transform_stream___params_T {
+	include_line_separator?:boolean
+}

package/all/line__transform_stream/index.js

@@ -0,0 +1,53 @@
+/** @typedef {import('../line__transform_stream/index.d.ts').line__transform_stream___params_T} */
+/**
+ * @param {line__transform_stream___params_T}[params]
+ * @param {QueuingStrategy<string>}[writable_strategy]
+ * @param {QueuingStrategy<string>}[readable_strategy]
+ * @returns {TransformStream<string, string>}
+ * @private
+ */
+export function line__transform_stream_(
+	params = {},
+	writable_strategy,
+	readable_strategy,
+) {
+	/** @type {string} */
+	let chunk = ''
+	const re = /\r\n|\n|\r/gm
+	return new TransformStream(
+		{
+			transform(
+				arg__chunk,
+				controller
+			) {
+				chunk += arg__chunk
+				let startIndex = 0
+				for (; ;) {
+					const result = re.exec(chunk)
+					if (!result) {
+						if (startIndex) {
+							chunk = chunk.substring(startIndex)
+						}
+						re.lastIndex = 0
+						return
+					}
+					const line =
+						chunk.substring(
+							startIndex,
+							result.index
+							+ (params.include_line_separator ? result[0].length : 0))
+					controller.enqueue(line)
+					startIndex = re.lastIndex
+				}
+			},
+			flush(controller) {
+				if (chunk.length) {
+					controller.enqueue(chunk)
+					chunk = ''
+				}
+				controller.terminate()
+			}
+		},
+		writable_strategy,
+		readable_strategy)
+}

package/all/line__transform_stream/index.test.ts

@@ -0,0 +1,47 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { line__transform_stream_ } from '../line__transform_stream/index.js'
+test('line__transform_stream_|!include_line_separator|callback', async ()=>{
+	const readable_stream = new ReadableStream({
+		start(controller) {
+			controller.enqueue('foo\n')
+			controller.enqueue('bar\nbaz\n')
+			controller.enqueue('\n')
+		},
+		pull(controller) {
+			controller.enqueue('last line')
+			controller.close()
+		}
+	})
+	const line__transform_stream = line__transform_stream_()
+	const reader = readable_stream.pipeThrough(line__transform_stream).getReader()
+	equal(await reader.read(), { value: 'foo', done: false })
+	equal(await reader.read(), { value: 'bar', done: false })
+	equal(await reader.read(), { value: 'baz', done: false })
+	equal(await reader.read(), { value: '', done: false })
+	equal(await reader.read(), { value: 'last line', done: false })
+	equal(await reader.read(), { value: undefined, done: true })
+})
+test('line__transform_stream_|include_line_separator|callback', async ()=>{
+	const readable_stream = new ReadableStream({
+		start(controller) {
+			controller.enqueue('foo\n')
+			controller.enqueue('bar baz\r\n')
+			controller.enqueue('quux\r')
+		},
+		pull(controller) {
+			controller.enqueue('last line')
+			controller.close()
+		}
+	})
+	const line__transform_stream = line__transform_stream_({
+		include_line_separator: true
+	})
+	const reader = readable_stream.pipeThrough(line__transform_stream).getReader()
+	equal(await reader.read(), { value: 'foo\n', done: false })
+	equal(await reader.read(), { value: 'bar baz\r\n', done: false })
+	equal(await reader.read(), { value: 'quux\r', done: false })
+	equal(await reader.read(), { value: 'last line', done: false })
+	equal(await reader.read(), { value: undefined, done: true })
+})
+test.run()

package/all/lte_0_a/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns Array of values `<= 0` in `val_a`.
+ */
+export declare function lte_0_a_<
+	T extends number = number
+>(val_a:readonly T[]):T[]
+export {
+	lte_0_a_ as lte_0_a1_fn,
+	lte_0_a_ as _lte_0_a1,
+	lte_0_a_ as _a1__lte__0,
+}

package/all/lte_0_a/index.js

@@ -0,0 +1,20 @@
+/**
+ * Returns Array of values `<= 0` in `val_a`.
+ * @param {number[]}val_a
+ * @returns {number[]}
+ */
+export function lte_0_a_(val_a) {
+	const lte_0_a = []
+	for (let i = 0; i < val_a.length; i++) {
+		const val = val_a[i]
+		if (val <= 0) {
+			lte_0_a.push(val)
+		}
+	}
+	return lte_0_a
+}
+export {
+	lte_0_a_ as lte_0_a1_fn,
+	lte_0_a_ as _lte_0_a1,
+	lte_0_a_ as _a1__lte__0,
+}

package/all/m_m_yyyy/index.d.ts

@@ -0,0 +1,8 @@
+export declare function MM_yyyy_(date?:Date):string
+export {
+	MM_yyyy_ as _MM_yyyy,
+}
+export declare function mm_yyyy_(date?:Date):string
+export {
+	mm_yyyy_ as _mm_yyyy,
+}

package/all/m_m_yyyy/index.js

@@ -0,0 +1,24 @@
+import { month_a } from '../month_a/index.js'
+import { pad2 } from '../pad2/index.js'
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function MM_yyyy_(date) {
+	date = date || new Date()
+	return `${month_a[date.getMonth()]} ${date.getFullYear()}`
+}
+export {
+	MM_yyyy_ as _MM_yyyy,
+}
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function mm_yyyy_(date) {
+	date = date || new Date()
+	return `${pad2(date.getMonth() + 1)}/${date.getFullYear()}`
+}
+export {
+	mm_yyyy_ as _mm_yyyy,
+}

package/all/m_yy/index.d.ts

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

package/all/m_yy/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function m_yy_(date) {
+	date = date || new Date()
+	return `${date.getMonth() + 1}/${date.getFullYear().toString().slice(2)}`
+}
+export { m_yy_ as _m_yy, }

package/all/m_yyyy/index.d.ts

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

package/all/m_yyyy/index.js

@@ -0,0 +1,10 @@
+import { abbrev_month_a } from '../abbrev_month_a/index.js'
+/**
+ * @param {Date}[date]
+ * @returns {string}
+ */
+export function M_yyyy_(date) {
+	date = date || new Date()
+	return `${abbrev_month_a[date.getMonth()]} ${date.getFullYear()}`
+}
+export { M_yyyy_ as _M_yyyy, }

package/all/many_andand/index.d.ts

@@ -0,0 +1,11 @@
+import type { andand_key__T } from '../andand/index.js'
+export declare function many_andand_<
+	Val extends unknown = unknown
+>(...name_a:(keyof Val|andand_key__T<Val>)[]):many_andand_T<Val>
+export {
+	many_andand_ as _many_andand,
+	many_andand_ as _andand__many,
+}
+export declare type many_andand_T<
+	Val extends unknown = unknown
+> = (obj:Val, ...arg_a:(keyof Val|andand_key__T<Val>)[])=>Val|null

package/all/many_andand/index.js

@@ -0,0 +1,12 @@
+import { andand } from '../andand/index.js'
+/**
+ * @param {string|import('../andand/index.js').andand_key_T}name_a
+ * @returns {import('#alll/many_andand/index.js').many_andand_T}
+ */
+export function many_andand_(...name_a) {
+	return (obj, ...arg_a)=>andand(obj, ...arg_a, ...name_a)
+}
+export {
+	many_andand_ as _many_andand,
+	many_andand_ as _andand__many,
+}

package/all/many_andand_or/index.d.ts

@@ -0,0 +1,17 @@
+import type { andand_key_T } from '../andand/index.js'
+import type { andand_or_T } from '../andand_or/index.js'
+export declare function many_andand_or_<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+>(
+	name_a:andand_key_T<Val>[], or_:andand_or_T<Val, Out>
+):many_andand_or_T<Val, Out>
+export declare type many_andand_or_T<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+> = (obj:Val, ...arg_a:andand_key_T<Val>[])=>Out
+export {
+	many_andand_or_ as _many_andand_or,
+	many_andand_or_ as _andand_or__many,
+	many_andand_or_ as _andand__or__many,
+}

package/all/many_andand_or/index.js

@@ -0,0 +1,14 @@
+import { andand_or } from '../andand_or/index.js'
+/**
+ * @param {import('../andand/index.js').andand_key_T}name_a
+ * @param {import('../andand_or/index.js').andand_or_T}or_
+ * @returns {import('../many_andand_or/index.d.ts').many_andand_or_T}
+ */
+export function many_andand_or_(name_a, or_) {
+	return (obj, ...arg_a)=>andand_or(obj, arg_a.concat(name_a), or_)
+}
+export {
+	many_andand_or_ as _many_andand_or,
+	many_andand_or_ as _andand_or__many,
+	many_andand_or_ as _andand__or__many,
+}

package/all/map/index.d.ts

@@ -0,0 +1,42 @@
+import { map_fn_T } from '../map_fn/index.js'
+/**
+ * Map return value of `fn(a[], i)` into an Array.
+ */
+export declare function map<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+>(
+	a:readonly Val[],
+	fn:map_fn_T<Val, Out>
+):Out[]
+export declare function maybe_map<
+	Val extends unknown,
+	Out extends unknown,
+	Or = null
+>(
+	maybe_a:readonly Val[]|undefined,
+	fn:map_fn_T<Val, Out>,
+	or?:Or
+):Out[]|Or
+/**
+ * Returns Function returning [map](#map) with `fn`.
+ */
+export declare function map_<
+	I extends unknown = unknown,
+	O extends unknown = unknown
+>(
+	fn:(val:I, idx:number)=>O
+):(a:readonly I[])=>O[]
+export declare function maybe_map_<
+	I extends unknown = unknown,
+	O extends unknown = unknown,
+	Or = null
+>(
+	fn:(val:I, idx:number)=>O,
+	or?:Or
+):(a:readonly I[]|undefined)=>O[]|Or
+export {
+	map_ as _map,
+	map_ as _fn__map,
+	maybe_map_ as _maybe_map,
+}

package/all/map/index.js

@@ -0,0 +1,45 @@
+/** @typedef {import('../index.d.ts').map_fn_T}map_fn_T */
+/**
+ * Map return value of `fn(a[], i)` into an Array.
+ * @param {unknown[]}a
+ * @param {map_fn_T}fn
+ * @returns {unknown[]}
+ */
+export function map(a, fn) {
+	const out_a = []
+	for (let i = 0; i < a.length; i++) {
+		out_a.push(fn(a[i], i))
+	}
+	return out_a
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {fnmap_fn_T}fn
+ * @param {unknown[]|null|undefined}or
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_map(maybe_a, fn, or = null) {
+	if (!maybe_a) return or
+	return maybe_a?.map(fn)
+}
+/**
+ * Returns Function returning [map](#map) with `fn`.
+ * @param {(val:unknown, idx:number)=>unknown}fn
+ * @returns {(a:unknown[])=>unknown[]}
+ */
+export function map_(fn) {
+	return a=>a.map(fn)
+}
+/**
+ * @param {(val:unknown, idx:number)=>unknown}fn
+ * @param {unknown[]|null|undefined}or
+ * @returns {(a:unknown[]|undefined)=>unknown[]|null|undefined}
+ */
+export function maybe_map_(fn, or = null) {
+	return a=>a ? a.map(fn) : or
+}
+export {
+	map_ as _map,
+	map_ as _fn__map,
+	maybe_map_ as _maybe_map,
+}

package/all/map_andand/index.d.ts

@@ -0,0 +1,30 @@
+import type { andand_key_T } from '../andand/index.js'
+/**
+ * Returns Array of mapped `a` with `_andand(...name_a)`.
+ */
+export declare function map_andand<
+	In extends unknown = unknown, Out extends unknown = unknown
+>(
+	a:readonly In[],
+	...name_a:readonly andand_key_T<In>[]
+):Out[]
+export declare function maybe_map_andand<
+	Val extends unknown, Out extends unknown
+>(
+	a:readonly Val[]|undefined,
+	...name_a:readonly andand_key_T<Val>[]
+):Out[]|undefined
+export { map_andand as map__andand, }
+/**
+ * Returns function that returns value from [map_andand](#map_andand) with `...attr_a`.
+ */
+export declare function map_andand_<
+	In extends unknown, Out extends unknown
+>(
+	...attr_a:readonly andand_key_T<In>[]
+):(a:readonly In[])=>Out[]
+export {
+	map_andand_ as _map_andand,
+	map_andand_ as _map__andand,
+	map_andand_ as _fn__map__andand,
+}

package/all/map_andand/index.js

@@ -0,0 +1,34 @@
+import { andand } from '../andand/index.js'
+import { andand_ } from '../one_andand/index.js'
+/** @typedef {import('../andand/index.d.ts').andand_key_T} */
+/**
+ * Returns Array of mapped `a` with `andand_(...name_a)`.
+ * @param {unknown[]}a
+ * @param {andand_key_T}name_a
+ * @returns {unknown[]}
+ */
+export function map_andand(a, ...name_a) {
+	return a.map(item=>andand(item, ...name_a))
+}
+/**
+ * @param {unknown[]|undefined}a
+ * @param {andand_key_T}name_a
+ * @returns {unknown[]|undefined}
+ */
+export function maybe_map_andand(a, ...name_a) {
+	return a?.map(andand_(...name_a))
+}
+export { map_andand as map__andand, }
+/**
+ * Returns function that returns value from [map_andand](#map_andand) with `...attr_a`.
+ * @param {andand_key_T}attr_a
+ * @returns {(a:unknown[])=>unknown[]}
+ */
+export function map_andand_(...attr_a) {
+	return a=>map_andand(a, ...attr_a)
+}
+export {
+	map_andand_ as _map_andand,
+	map_andand_ as _map__andand,
+	map_andand_ as _fn__map__andand,
+}