ctx-core 2.1.0 → 2.2.1

package/all/be_/index.test.ts

@@ -0,0 +1,251 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import {
+	be_,
+	be__delete,
+	be__has_,
+	be__has__ctx_,
+	be__set,
+	be__val_,
+	type Ctx,
+	ctx__delete,
+	ctx__set,
+	type MapCtx
+} from '../be_/index.js'
+import { ctx__new } from '../ctx/index.js'
+test('be_|Map', ()=>{
+	const ctx = ctx__new()
+	let incrementer_num = 0
+	const incrementer = ()=>++incrementer_num
+	const root_ = be_('root_', ()=>incrementer())
+	const child_ = be_('child_', ctx=>root_(ctx) + incrementer())
+	const child1_ = be_('child1_', ctx=>root_(ctx) + child_(ctx))
+	equal(root_(ctx), 1)
+	equal(ctx.get('root_'), 1)
+	equal(child_(ctx), 3)
+	equal(ctx.get('child_'), 3)
+	equal(child1_(ctx), 4)
+	equal(ctx.get('child1_'), 4)
+})
+test('be_|simple array', ()=>{
+	const ctx0 = ctx__new()
+	const ctx1 = ctx__new()
+	const ctx = [ctx0, ctx1]
+	const root_ = be_('root_', ()=>1)
+	equal(root_(ctx1), 1)
+	equal(root_(ctx), 1)
+	equal(ctx0.has(root_), false)
+	equal(ctx1.has(root_), true)
+	const child_ = be_('child_', ctx=>root_(ctx) + 1)
+	equal(child_(ctx), 2)
+	equal(ctx0.has(child_), true)
+	equal(ctx1.has(child_), false)
+})
+test('be_|nested array', ()=>{
+	const ctx0 = ctx__new()
+	const ctx1 = ctx__new()
+	const ctx2 = ctx__new()
+	const ctx3 = ctx__new()
+	const ctx = [[[ctx0], ctx1], [ctx2, ctx3]]
+	const root_ = be_('root_', ()=>1)
+	equal(root_(ctx3), 1)
+	equal(root_(ctx), 1)
+	equal(ctx0.has(root_), false)
+	equal(ctx1.has(root_), false)
+	equal(ctx2.has(root_), false)
+	equal(ctx3.has(root_), true)
+	const child_ = be_('child_', ctx=>root_(ctx) + 1)
+	equal(child_(ctx), 2)
+	equal(ctx0.has(child_), true)
+	equal(ctx1.has(child_), false)
+	equal(ctx2.has(child_), false)
+	equal(ctx3.has(child_), false)
+})
+test('be_|is_source_', ()=>{
+	const ctx0 = ctx__new()
+	const ctx1 = ctx__new()
+	ctx1.set('matching', true)
+	const ctx = [ctx0, ctx1]
+	const be__ctx_a:Ctx[] = []
+	const root_ = be_('root_', ctx=>{
+		be__ctx_a.push(ctx)
+		return 1
+	}, {
+		is_source_(map_ctx) {
+			return !!map_ctx.get('matching')
+		}
+	})
+	equal(root_(ctx), 1)
+	equal(be__ctx_a, [[ctx0, ctx1]])
+	equal(ctx0.has(root_), false)
+	equal(ctx1.has(root_), true)
+})
+test('be_|Ctx generic type', ()=>{
+	const valid_ctx = ctx__new() as test_ctx_T
+	const val_ = be_<boolean, test_ctx_T>('val_', ()=>true)
+	val_(valid_ctx)
+	// val_(ctx_()) // type error
+})
+test('be_|Ctx|NestedMapCtx', ()=>{
+	const ctx0 = ctx__new()
+	const ctx1 = ctx__new()
+	ctx1.set('matching', true)
+	const ctx = [ctx0, ctx1]
+	const nested__ctx_ = be_<Ctx>('nested__ctx_', ctx=>[ctx])
+	equal(nested__ctx_(ctx), [[ctx0, ctx1]])
+})
+test('be__set', ()=>{
+	const ctx0 = ctx__new()
+	const val_ = be_<number|undefined>('val_', ()=>undefined, {
+		is_source_: map_ctx=>map_ctx === ctx0
+	})
+	be__set(val_, ctx0, 1)
+	equal(val_(ctx0), 1)
+	const ctx1 = ctx__new()
+	const ctx_a = [ctx1, ctx0]
+	be__set(val_, ctx_a, 2)
+	equal(val_(ctx0), 2)
+	equal(val_(ctx_a), 2)
+	equal(ctx1.has(val_), false)
+})
+test('ctx__set', ()=>{
+	const ctx0 = ctx__new()
+	ctx__set(ctx0, 'key', 1)
+	equal(ctx0.get('key'), 1)
+	const ctx1 = ctx__new()
+	const ctx_a = [ctx1, ctx0]
+	ctx__set(ctx_a, 'key', 2,
+		(map_ctx:MapCtx)=>map_ctx.get('key') != null)
+	equal(ctx0.get('key'), 2)
+	equal(ctx1.has('key'), false)
+})
+test('be__delete', ()=>{
+	const ctx0 = ctx__new()
+	const val_ = be_<boolean>('val_', ()=>true)
+	be__delete(val_, ctx0)
+	equal(ctx0.has(val_), false)
+	equal(ctx0.has('val_'), false)
+	equal(val_(ctx0), true)
+	equal(ctx0.get(val_), true)
+	equal(ctx0.get('val_'), true)
+	be__delete(val_, ctx0)
+	equal(ctx0.has(val_), false)
+	equal(ctx0.has('val_'), false)
+	const ctx1 = ctx__new()
+	const nested__ctx = [ctx0, ctx1]
+	equal(val_(ctx0), true)
+	equal(val_(ctx1), true)
+	equal(val_(nested__ctx), true)
+	equal(ctx0.get('val_'), true)
+	equal(ctx1.get('val_'), true)
+	be__delete(val_, nested__ctx)
+	equal(ctx0.has(val_), false)
+	equal(ctx0.has('val_'), false)
+	equal(ctx1.has(val_), false)
+	equal(ctx1.has('val_'), false)
+})
+test('ctx__delete|id', ()=>{
+	const ctx0 = ctx__new()
+	ctx__delete(ctx0, 'key')
+	equal(ctx0.has('key'), false)
+	ctx0.set('key', true)
+	equal(ctx0.get('key'), true)
+	ctx__delete(ctx0, 'key')
+	equal(ctx0.has('key'), false)
+	const ctx1 = ctx__new()
+	const nested__ctx = [ctx0, ctx1]
+	ctx0.set('key', true)
+	ctx1.set('key', true)
+	equal(ctx0.get('key'), true)
+	equal(ctx1.get('key'), true)
+	ctx__delete(nested__ctx, 'key')
+	equal(ctx0.has('key'), false)
+	equal(ctx1.has('key'), false)
+})
+test('ctx__delete|be', ()=>{
+	const ctx0 = ctx__new()
+	const num_ = be_(()=>1)
+	ctx__delete(ctx0, num_)
+	equal(ctx0.has(num_), false)
+	num_(ctx0)
+	equal(ctx0.has(num_), true)
+	ctx__delete(ctx0, num_)
+	equal(ctx0.has(num_), false)
+	num_(ctx0)
+	equal(ctx0.has(num_), true)
+	ctx__delete(ctx0, num_)
+	equal(ctx0.has(num_), false)
+	const ctx1 = ctx__new()
+	ctx1.set('ctx1', true)
+	const nested__ctx = [ctx0, ctx1]
+	num_(ctx0)
+	num_(ctx1)
+	equal(ctx0.has(num_), true)
+	equal(ctx1.has(num_), true)
+	ctx__delete(nested__ctx, num_)
+	equal(ctx0.has(num_), false)
+	equal(ctx1.has(num_), false)
+	num_(ctx0)
+	num_(ctx1)
+	equal(ctx0.has(num_), true)
+	equal(ctx1.has(num_), true)
+	ctx__delete(nested__ctx, num_)
+	equal(ctx0.has(num_), false)
+	equal(ctx1.has(num_), false)
+	const is_source__num_ =
+		be_(()=>1,
+			{ is_source_: ctx=>!!ctx.get('ctx1') })
+	is_source__num_(nested__ctx)
+	equal(ctx0.has(is_source__num_), false)
+	equal(ctx1.has(is_source__num_), true)
+	ctx__delete(nested__ctx, is_source__num_)
+	equal(ctx0.has(is_source__num_), false)
+	equal(ctx1.has(is_source__num_), false)
+	is_source__num_(nested__ctx)
+	equal(ctx0.has(is_source__num_), false)
+	equal(ctx1.has(is_source__num_), true)
+	ctx__delete(nested__ctx, is_source__num_)
+	equal(ctx0.has(is_source__num_), false)
+	equal(ctx1.has(is_source__num_), false)
+})
+test('be__has_', ()=>{
+	const ctx0 = ctx__new()
+	ctx__delete(ctx0, 'key')
+	equal(be__has_('key', ctx0), false)
+	ctx0.set('key', true)
+	equal(be__has_('key', ctx0), true)
+	ctx__delete(ctx0, 'key')
+	equal(be__has_('key', ctx0), false)
+	const ctx1 = ctx__new()
+	const nested__ctx = [ctx0, ctx1]
+	ctx1.set('key', true)
+	equal(be__has_('key', nested__ctx), true)
+})
+test('be__has__ctx_', ()=>{
+	const ctx0 = ctx__new()
+	ctx__delete(ctx0, 'key')
+	equal(be__has__ctx_('key', ctx0), null)
+	ctx0.set('key', true)
+	equal(be__has__ctx_('key', ctx0), ctx0)
+	ctx__delete(ctx0, 'key')
+	equal(be__has__ctx_('key', ctx0), null)
+	const ctx1 = ctx__new()
+	const nested__ctx = [ctx0, ctx1]
+	ctx1.set('key', true)
+	equal(be__has__ctx_('key', nested__ctx), ctx1)
+})
+test('be__val_', ()=>{
+	const ctx = ctx__new()
+	const val_ = be_<boolean>('val_', ()=>true)
+	equal(val_(ctx), true)
+	equal(ctx.get(val_), true)
+	equal(be__val_(val_, ctx), true)
+	be__set(val_, ctx, false)
+	equal(val_(ctx), false)
+	equal(be__val_(val_, ctx), false)
+})
+test.run()
+declare const test_ctx_sym:unique symbol
+type test_ctx_T = Ctx&{
+	[test_ctx_sym]:any
+}

package/all/be_arg_triple/index.d.ts

@@ -0,0 +1,21 @@
+import type { be__params_T, Ctx } from '../be_/index.js'
+export declare function be_arg_triple__new<
+	val_T,
+	ctx_T extends Ctx = Ctx,
+>(...arg_a:be_arg_triple__new__arg_a_T<val_T, ctx_T>):be_arg_triple_T<val_T, ctx_T>
+export type be_arg_triple_T<
+	val_T,
+	ctx_T extends Ctx = Ctx
+> = [
+	id:string|null,
+	val__new:(ctx:ctx_T)=>val_T,
+	be__params:be__params_T
+]
+export type be_arg_triple__new__arg_a_T<
+	val_T,
+	ctx_T extends Ctx = Ctx,
+> =
+	|[be__params?:be__params_T]
+	|[id:string|null|undefined, be__params?:be__params_T]
+	|[val__new:(ctx:ctx_T)=>val_T, be__params?:be__params_T]
+	|[id?:string|null|undefined, val__new?:((ctx:ctx_T)=>val_T), be__params?:be__params_T]

package/all/be_arg_triple/index.js

@@ -0,0 +1,41 @@
+/** @typedef {import('../be_/index.d.ts').Ctx}Ctx */
+/** @typedef {import('../be_/index.d.ts').be__params_T}be__params_T */
+/** @typedef {import('../be_arg_triple/index.d.ts').be_arg_triple_T}be_arg_triple_T */
+/** @typedef {import('../be_arg_triple/index.d.ts').be_arg_triple__new__arg_a_T}be_arg_triple__new__arg_a_T */
+/**
+ * @param {be_arg_triple__new__arg_a_T}arg_a
+ * @returns {be_arg_triple_T}
+ * @private
+ */
+export function be_arg_triple__new(...arg_a) {
+	/** @type {string|null|undefined} */
+	let id
+	/** @type {((ctx:Ctx)=>V)|undefined} */
+	let val__new
+	/** @type {be__params_T|undefined} */
+	let be__params
+	if (arg_a.length === 3) {
+		[id, val__new, be__params] = arg_a
+	} else if (arg_a.length === 2) {
+		if (typeof arg_a[0] === 'function') {
+			val__new = arg_a[0]
+			be__params = arg_a[1]
+		} else {
+			id = arg_a[0]
+			if (typeof arg_a[1] === 'function') {
+				val__new = arg_a[1]
+			} else {
+				be__params = arg_a[1]
+			}
+		}
+	} else if (arg_a.length === 1) {
+		if (typeof arg_a[0] === 'function') {
+			val__new = arg_a[0]
+		} else if (typeof arg_a[0] === 'object') {
+			be__params = arg_a[0]
+		} else {
+			id = arg_a[0]
+		}
+	}
+	return [id, val__new, be__params]
+}

package/all/be_prop_pair/index.d.ts

@@ -0,0 +1,36 @@
+import type { be__params_T, Ctx } from '../be_/index.js'
+export declare function be_prop_pair_<
+	Val extends NonNullable<unknown>,
+	ctx_T extends Ctx = Ctx
+>(
+	be__params?:be__params_T
+):be_prop_pair_T<Val, ctx_T>
+export declare function be_prop_pair_<
+	Val extends NonNullable<unknown>,
+	ctx_T extends Ctx = Ctx
+>(
+	id:string|null|undefined,
+	be__params?:be__params_T
+):be_prop_pair_T<Val, ctx_T>
+export declare function be_prop_pair_<
+	Val extends NonNullable<unknown>,
+	ctx_T extends Ctx = Ctx
+>(
+	val__new:(ctx:ctx_T)=>Val,
+	be__params?:be__params_T
+):be_prop_pair_T<Val, ctx_T>
+export declare function be_prop_pair_<
+	Val extends NonNullable<unknown>,
+	ctx_T extends Ctx = Ctx
+>(
+	id?:string|null|undefined,
+	val__new?:((ctx:ctx_T)=>Val),
+	be__params?:be__params_T
+):be_prop_pair_T<Val, ctx_T>
+export type be_prop_pair_T<
+	Val extends NonNullable<unknown>,
+	ctx_T extends Ctx = Ctx
+> = [
+	(ctx:ctx_T)=>Val,
+	(ctx:ctx_T, val:Val)=>void
+]

package/all/be_prop_pair/index.js

@@ -0,0 +1,54 @@
+import { be_, ctx__set } from '../be_/index.js'
+/** @typedef {import('../be_/index.d.ts').be__params_T}be__params_T */
+/** @typedef {import('../be_/index.d.ts').Ctx}Ctx */
+/** @typedef {import('../be_prop_pair/index.d.ts').be_prop_pair_T}be_prop_pair_T */
+/**
+ * @param {string|null|undefined|((ctx:Ctx)=>unknown)|be__params_T}[id_OR_val__new_OR_be__params]
+ * @param {((ctx:Ctx)=>unknown)|be__params_T}val__new_OR_be__params
+ * @param {be__params_T}[be__params]
+ * @returns {be_prop_pair_T}
+ * @private
+ */
+export function be_prop_pair_(
+	id_OR_val__new_OR_be__params,
+	val__new_OR_be__params,
+	be__params
+) {
+	/** @type {string} */
+	let id
+	/** @type {(ctx:Ctx)=>unknown} */
+	let val__new
+	if (typeof id_OR_val__new_OR_be__params === 'function') {
+		val__new_OR_be__params = id_OR_val__new_OR_be__params
+	} else if (typeof id_OR_val__new_OR_be__params === 'object') {
+		be__params = id_OR_val__new_OR_be__params
+	} else {
+		id = id_OR_val__new_OR_be__params
+	}
+	if (typeof val__new_OR_be__params === 'function') {
+		val__new = val__new_OR_be__params
+	} else if (!be__params) {
+		be__params = val__new_OR_be__params
+	}
+	if (!val__new) {
+		val__new = ()=>null
+	}
+	const _be_ =
+		(be__params && be__params.be_)
+		?? be_
+	const val_ =
+		id
+			? _be_(id, val__new, be__params)
+			: _be_(val__new, be__params)
+	function val__set(ctx, val) {
+		ctx__set(
+			ctx,
+			val_,
+			val,
+			be__params && be__params.is_source_)
+	}
+	return [
+		val_,
+		val__set
+	]
+}

package/all/be_prop_pair/index.test.ts

@@ -0,0 +1,137 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { be_, type MapCtx } from '../be_/index.js'
+import { be_prop_pair_ } from '../be_prop_pair/index.js'
+import { ctx__new } from '../ctx/index.js'
+test('be_prop_pair_|+base_name|+atom__new|+be__params', ()=>{
+	const ctx = ctx__new()
+	const is_source_ = (map_ctx:MapCtx)=>map_ctx === ctx
+	let custom__be__called = false
+	const custom__be_ = ((...argv:Parameters<typeof be_>)=>{
+		custom__be__called = true
+		return be_(...argv)
+	}) as typeof be_
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_(
+		'foobar',
+		()=>1,
+		{
+			is_source_,
+			be_: custom__be_,
+		}
+	)
+	equal(custom__be__called, true)
+	equal(foobar_([ctx__new(), ctx]), 1)
+	foobar__set([ctx__new(), ctx], 2)
+	equal(foobar_([ctx__new(), ctx]), 2)
+})
+test('be_prop_pair_|+base_name|+atom__new|-be__params', ()=>{
+	const ctx = ctx__new()
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_(
+		'foobar',
+		()=>1,
+	)
+	equal(foobar_(ctx), 1)
+	foobar__set(ctx, 2)
+	equal(foobar_(ctx), 2)
+})
+test('be_prop_pair_|+base_name|-atom__new|+be__params', ()=>{
+	const ctx = ctx__new()
+	const is_source_ = (map_ctx:MapCtx)=>map_ctx === ctx
+	let custom__be__called = false
+	const custom__be_ = ((...argv:Parameters<typeof be_>)=>{
+		custom__be__called = true
+		return be_(...argv)
+	}) as typeof be_
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_('foobar', {
+		is_source_,
+		be_: custom__be_,
+	})
+	equal(custom__be__called, true)
+	equal(foobar_([ctx__new(), ctx]), null)
+	foobar__set([ctx__new(), ctx], 2)
+	equal(foobar_([ctx__new(), ctx]), 2)
+})
+test('be_prop_pair_|+base_name|-atom__new|-be__params', ()=>{
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_('foobar')
+	const ctx = ctx__new()
+	equal(foobar_(ctx), null)
+	foobar__set(ctx, 2)
+	equal(foobar_(ctx), 2)
+})
+test('be_prop_pair_|-base_name|+atom__new|+be__params', ()=>{
+	const ctx = ctx__new()
+	const is_source_ = (map_ctx:MapCtx)=>map_ctx === ctx
+	let custom__be__called = false
+	const custom__be_ = ((...argv:Parameters<typeof be_>)=>{
+		custom__be__called = true
+		return be_(...argv)
+	}) as typeof be_
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_(
+		undefined,
+		()=>1,
+		{
+			is_source_,
+			be_: custom__be_,
+		})
+	equal(custom__be__called, true)
+	equal(foobar_([ctx__new(), ctx]), 1)
+	foobar__set([ctx__new(), ctx], 2)
+	equal(foobar_([ctx__new(), ctx]), 2)
+})
+test('be_prop_pair_|-base_name|+atom__new|-be__params', ()=>{
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_(undefined, ()=>
+		1)
+	const ctx = ctx__new()
+	equal(foobar_(ctx), 1)
+	foobar__set(ctx, 2)
+	equal(foobar_(ctx), 2)
+})
+test('be_prop_pair_|-base_name|-atom__new|+be__params', ()=>{
+	const ctx = ctx__new()
+	const is_source_ = (map_ctx:MapCtx)=>map_ctx === ctx
+	let custom__be__called = false
+	const custom__be_ = ((...argv:Parameters<typeof be_>)=>{
+		custom__be__called = true
+		return be_(...argv)
+	}) as typeof be_
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_({
+		is_source_,
+		be_: custom__be_,
+	})
+	equal(custom__be__called, true)
+	equal(foobar_([ctx__new(), ctx]), null)
+	foobar__set([ctx__new(), ctx], 2)
+	equal(foobar_([ctx__new(), ctx]), 2)
+})
+test('be_prop_pair_|-base_name|-atom__new|-be__params', ()=>{
+	const [
+		foobar_,
+		foobar__set,
+	] = be_prop_pair_()
+	const ctx = ctx__new()
+	equal(foobar_(ctx), null)
+	foobar__set(ctx, 2)
+	equal(foobar_(ctx), 2)
+})
+test.run()

package/all/binary_sort_rank/index.d.ts

@@ -0,0 +1,12 @@
+import type { compare_1_T } from '../array_types/index.js'
+/**
+ * Returns the rank of the item where the compare function === 0, using binarySort
+ */
+export declare function binary_sort_rank(
+	a:readonly unknown[], compare_1:compare_1_T
+):number
+export {
+	binary_sort_rank as binarySort_rank,
+	binary_sort_rank as rank__binarySort,
+	binary_sort_rank as rank__binarySort__a1,
+}

package/all/binary_sort_rank/index.js

@@ -0,0 +1,30 @@
+/**
+ * Returns the rank of the item where the compare function === 0, using binarySort
+ * @param {unknown[]}a
+ * @param {import('../array_types/index.js').compare_1_T}compare_1
+ * @returns {number}
+ */
+export function binary_sort_rank(a, compare_1) {
+	let min_index = 0
+	let max_index = a.length - 1
+	let current_index
+	let current_element
+	while (min_index <= max_index) {
+		current_index = (min_index + max_index) / 2 | 0
+		current_element = a[current_index]
+		const sort_compare = compare_1(current_element, current_index)
+		if (sort_compare > 0) {
+			min_index = current_index + 1
+		} else if (sort_compare < 0) {
+			max_index = current_index - 1
+		} else {
+			return current_index
+		}
+	}
+	return -1
+}
+export {
+	binary_sort_rank as binarySort_rank,
+	binary_sort_rank as rank__binarySort,
+	binary_sort_rank as rank__binarySort__a1,
+}

package/all/bind_apply/index.d.ts

@@ -0,0 +1,17 @@
+import type { call_fn_T } from '../call/index.js'
+/**
+ * Returns function bound to self that applies arg_a with ...arg_a_
+ */
+export declare function bind_apply_<
+	Self extends unknown = unknown,
+	A_outer extends unknown = unknown,
+	A_inner extends unknown[] = unknown[],
+	Out extends unknown = unknown
+>(
+	fn:call_fn_T<A_inner, Out>, self:Self, in_arg_a?:A_outer
+):ReturnType<call_fn_T<A_inner, Out>>
+export {
+	bind_apply_ as _bind_apply,
+	bind_apply_ as _apply__bind,
+}
+

package/all/bind_apply/index.js

@@ -0,0 +1,18 @@
+/** @typedef {import('../call/index.d.ts').call_fn_T} */
+/**
+ * Returns function bound to self that applies arg_a with ...arg_a_
+ * @param {call_fn_T}fn
+ * @param {unknown}self
+ * @param {unknown}[in_arg_a]
+ * @returns {(fn:call_fn_T, unknown, in_arg_a?:unknown[])=>ReturnType<call_fn_T>}
+ */
+export function bind_apply_(fn, self, in_arg_a) {
+	return (find, self, in_arg_a)=>fn.apply(self, [
+		...in_arg_a,
+		...fn_arg_a
+	])
+}
+export {
+	bind_apply_ as _bind_apply,
+	bind_apply_ as _apply__bind,
+}

package/all/bind_call/index.d.ts

@@ -0,0 +1,21 @@
+import type { call_fn_T } from '../call/index.js'
+/**
+ * Returns function bound to self that calls ...in_arg_a concat with ...fn_arg_a passed to function
+ */
+export declare function bind_call_<
+	A1 extends unknown[] = unknown[],
+	A2 extends unknown[] = unknown[],
+	O2 extends unknown = unknown,
+	S2 extends unknown = unknown
+>(
+	fn:call_fn_T<A2, O2>, self:S2, ...in_arg_a:A2[]
+):ReturnType<call_fn_T<A2, O2>>
+export {
+	bind_call_ as _bind_call,
+	bind_call_ as _call__bind,
+}
+export declare type bind_call_T<
+	A extends readonly unknown[] = readonly unknown[],
+	O extends unknown = unknown
+> = (...fn_arg_a:A)=>O
+export declare type bind_call_type = bind_call_T

package/all/bind_call/index.js

@@ -0,0 +1,18 @@
+/** @typedef {import('../call_fn/index.js')} */
+/**
+ * Returns function bound to self that calls ...in_arg_a concat with ...fn_arg_a passed to function
+ * @param {call_fn_T}fn
+ * @param {unknown}self
+ * @param {unknown}in_arg_a
+ * @returns {(fn:call_fn_T, self:unknown, ...in_arg_a:unknown[])=>ReturnType<call_fn_T>}
+ */
+export function bind_call_(fn, self, ...in_arg_a) {
+	return (...fn_arg_a)=>fn.call(self, ...[
+		...in_arg_a,
+		...fn_arg_a
+	])
+}
+export {
+	bind_call_ as _bind_call,
+	bind_call_ as _call__bind,
+}

package/all/bind_map_apply/index.d.ts

@@ -0,0 +1,17 @@
+import type { call_fn_T } from '../call/index.js'
+/**
+ * Returns function returning map of calls to fn_a bound to self that applies arg_a with ...arg_a_
+ */
+export declare function bind_map_apply_<
+	A1 extends unknown[] = unknown[],
+	O1 extends unknown = unknown,
+	S1 extends unknown = unknown,
+	A2 extends unknown[] = unknown[]
+>(
+	fn_a:call_fn_T<A1, O1>[], self:S1, in_arg_a:A2
+):(...fn_arg_a:A1)=>O1[]
+export {
+	bind_map_apply_ as _bind_map_apply,
+	bind_map_apply_ as bind_map_fn_apply_fn,
+	bind_map_apply_ as _apply__map__bind
+}