ctx-core 2.2.2 → 2.4.0

package/all/debounce/index.js

@@ -1,4 +1,4 @@
-import { isPromise } from '../isPromise/index.js'
+import { isPromiseLike } from '../isPromiseLike/index.js'
 /**
  * Returns an async function, that, as long as it continues to be invoked, will not
  * be triggered. The function will be called after it stops being called for
@@ -35,7 +35,7 @@ export function debounce(func, wait, immediate) {
 		async function invoke() {
 			try {
 				const in_rv = func.apply(apply_this, arg_a)
-				resolve(isPromise(in_rv) ? await in_rv : in_rv)
+				resolve(isPromiseLike(in_rv) ? await in_rv : in_rv)
 			} catch (e) {
 				reject(e)
 			}

package/all/index.d.ts

@@ -5,6 +5,7 @@ export * from './Map__object/index.js'
 export * from './NumericRange/index.js'
 export * from './NumericUnit/index.js'
 export * from './PHI/index.js'
+export * from './primitive/index.js'
 export * from './Request/index.js'
 export * from './Response/index.js'
 export * from './Timeout/index.js'
@@ -188,7 +189,8 @@ export * from './isNumber/index.js'
 export * from './isNumber_andor/index.js'
 export * from './isNumber_or/index.js'
 export * from './isObject/index.js'
-export * from './isPromise/index.js'
+export * from './isPrimitive/index.js'
+export * from './isPromiseLike/index.js'
 export * from './item_r_idx/index.js'
 export * from './key_compare/index.js'
 export * from './key_r/index.js'
@@ -222,6 +224,7 @@ export * from './matrix__validate_length/index.js'
 export * from './maybe/index.js'
 export * from './mean/index.js'
 export * from './median/index.js'
+export * from './memo/index.js'
 export * from './merge/index.js'
 export * from './minute/index.js'
 export * from './minute/index.js'
@@ -291,6 +294,7 @@ export * from './prev_idx/index.js'
 export * from './promise/index.js'
 export * from './promise_o/index.js'
 export * from './promise_timeout/index.js'
+export * from './prototype/index.js'
 export * from './prototype_mixin/index.js'
 export * from './push/index.js'
 export * from './quantile/index.js'

package/all/index.js

@@ -5,6 +5,7 @@ export * from './Map__object/index.js'
 export * from './NumericRange/index.js'
 export * from './NumericUnit/index.js'
 export * from './PHI/index.js'
+export * from './primitive/index.js'
 export * from './Request/index.js'
 export * from './Response/index.js'
 export * from './Timeout/index.js'
@@ -188,7 +189,8 @@ export * from './isNumber/index.js'
 export * from './isNumber_andor/index.js'
 export * from './isNumber_or/index.js'
 export * from './isObject/index.js'
-export * from './isPromise/index.js'
+export * from './isPrimitive/index.js'
+export * from './isPromiseLike/index.js'
 export * from './item_r_idx/index.js'
 export * from './key_compare/index.js'
 export * from './key_r/index.js'
@@ -222,6 +224,7 @@ export * from './matrix__validate_length/index.js'
 export * from './maybe/index.js'
 export * from './mean/index.js'
 export * from './median/index.js'
+export * from './memo/index.js'
 export * from './merge/index.js'
 export * from './minute/index.js'
 export * from './minute/index.js'
@@ -291,6 +294,7 @@ export * from './prev_idx/index.js'
 export * from './promise/index.js'
 export * from './promise_o/index.js'
 export * from './promise_timeout/index.js'
+export * from './prototype/index.js'
 export * from './prototype_mixin/index.js'
 export * from './push/index.js'
 export * from './quantile/index.js'

package/all/intersection_set/index.js

@@ -13,7 +13,7 @@ export function intersection_set_(member_a_nowrap_a_nowrap) {
 		const rest_a_nowrap = rest_a_nowrap_a[i]
 		const rest_a = wrap_a_(rest_a_nowrap)
 		const current_set = new Set(rest_a)
-		member_set.forEach((member)=>{
+		member_set.forEach(member=>{
 			if (!current_set.has(member)) member_set.delete(member)
 		})
 	}

package/all/isPrimitive/index.d.ts

@@ -0,0 +1 @@
+export declare function isPrimitive(v:unknown):boolean

package/all/isPrimitive/index.js

@@ -0,0 +1,6 @@
+export function isPrimitive(val) {
+	return (
+		val === null
+		|| (typeof val !== 'object' && typeof val !== 'function')
+	)
+}

package/all/isPrimitive/index.test.ts

@@ -0,0 +1,17 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { isPrimitive } from './index.js'
+test('isPrimitive', ()=>{
+	equal(isPrimitive(1), true)
+	equal(isPrimitive('foo'), true)
+	equal(isPrimitive(null), true)
+	equal(isPrimitive(undefined), true)
+	equal(isPrimitive(true), true)
+	equal(isPrimitive(false), true)
+	equal(isPrimitive(Symbol('foo')), true)
+	equal(isPrimitive({}), false)
+	equal(isPrimitive([]), false)
+	equal(isPrimitive(()=>1), false)
+	equal(isPrimitive(new Date), false)
+})
+test.run()

package/all/isPromiseLike/index.d.ts

@@ -0,0 +1,4 @@
+export declare function isPromiseLike(val:any):boolean
+export {
+	isPromiseLike as isPromise,
+}

package/all/{isPromise → isPromiseLike}/index.js

@@ -2,6 +2,9 @@
  * @param {unknown}val
  * @returns {boolean}
  */
-export function isPromise(val) {
+export function isPromiseLike(val) {
 	return val ? typeof val.then === 'function' : false
 }
+export {
+	isPromiseLike as isPromise,
+}

package/all/memo/index.d.ts

@@ -0,0 +1,6 @@
+export declare function memo_<
+	ret_T,
+	arg_a_T extends Array<unknown>,
+>(fn:(...arg_a:arg_a_T)=>ret_T):((...arg_a:arg_a_T)=>ret_T)&{
+	clear():void
+}

package/all/memo/index.js

@@ -0,0 +1,61 @@
+import { isPrimitive } from '../isPrimitive/index.js'
+import { prototype_ } from '../prototype/index.js'
+let empty_sym, WeakRef_proto
+/**
+ * @param {(...arg_a:any[])=>any}fn
+ * @returns A memo caching arguments & return values. Arguments that are Objects are cached with a WeakRef.
+ * @private
+ */
+export function memo_(fn) {
+	let m = new Map
+	let wm = new WeakMap
+	if (!empty_sym) {
+		empty_sym = Symbol('E')
+		WeakRef_proto = WeakRef.prototype
+	}
+	let memo = (...arg_a)=>{
+		if (!arg_a.length) {
+			if (!m.has(empty_sym)) {
+				m.set(empty_sym, fn())
+			}
+			return m.get(empty_sym)
+		}
+		let arg0 = arg_a[0]
+		let map = isPrimitive(arg0) ? m : wm
+		/** @type {[unknown[], unknown][]} */
+		let cache__arg_a_T_ret__a = map.get(arg0)
+		if (!cache__arg_a_T_ret__a) {
+			cache__arg_a_T_ret__a = []
+			map.set(arg0, cache__arg_a_T_ret__a)
+		}
+		cache__arg_a_T_ret__a:for (let cache__arg_a_T_ret__a__i = cache__arg_a_T_ret__a.length; cache__arg_a_T_ret__a__i--;) {
+			let cache__arg_a_T_ret = cache__arg_a_T_ret__a[cache__arg_a_T_ret__a__i]
+			let cache__arg_a = cache__arg_a_T_ret[0]
+			let { length } = arg_a
+			if (cache__arg_a.length !== length) continue
+			for (let arg_a__i = length; arg_a__i--;) {
+				let cache__arg_val = cache__arg_a[arg_a__i]
+				if (prototype_(cache__arg_val) === WeakRef_proto) {
+					cache__arg_val = cache__arg_val.deref()
+					if (!cache__arg_val) { // cleanup cache__arg_a when arg is GC
+						cache__arg_a_T_ret__a.splice(cache__arg_a_T_ret__a__i, 1)
+						continue cache__arg_a_T_ret__a
+					}
+				}
+				let arg_val = arg_a[arg_a__i]
+				if (arg_val !== cache__arg_val) break
+				if (!arg_a__i) { // arguments match
+					return cache__arg_a_T_ret[1]
+				}
+			}
+		}
+		let ret = fn(...arg_a)
+		cache__arg_a_T_ret__a.push([arg_a.map(arg=>isPrimitive(arg) ? arg : new WeakRef(arg)), ret])
+		return ret
+	}
+	memo.clear = ()=>{
+		m.clear()
+		wm = new WeakMap
+	}
+	return memo
+}

package/all/memo/index.test.ts

@@ -0,0 +1,75 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { memo_ } from './index.js'
+test('memo_|empty', ()=>{
+	let call_count = 0
+	let fn = ()=>{
+		call_count++
+		return 'memo-return'
+	}
+	let memo = memo_(fn)
+	equal(call_count, 0)
+	equal(memo(), 'memo-return')
+	equal(call_count, 1)
+	equal(memo(), 'memo-return')
+	equal(call_count, 1)
+})
+test('memo_|primitive arguments', ()=>{
+	let call_count = 0
+	let fn = (arg0:number, arg1:number)=>{
+		call_count++
+		return arg0 + arg1
+	}
+	let memo = memo_(fn)
+	equal(call_count, 0)
+	equal(memo(1, 2), 3)
+	equal(call_count, 1)
+	equal(memo(1, 2), 3)
+	equal(call_count, 1)
+	equal(memo(1, 3), 4)
+	equal(call_count, 2)
+	memo.clear()
+	equal(memo(1, 2), 3)
+	equal(call_count, 3)
+})
+test('memo_|primitive|with objects', ()=>{
+	let call_count = 0
+	let fn = (arg0:number, arg1:object)=>{
+		call_count++
+		return { ...arg1, arg0 }
+	}
+	let memo = memo_(fn)
+	let arg1 = { arg1: true }
+	let arg1_2 = { arg1_2: true }
+	equal(call_count, 0)
+	equal(memo(1, arg1), { arg1: true, arg0: 1 })
+	equal(call_count, 1)
+	equal(memo(1, arg1), { arg1: true, arg0: 1 })
+	equal(call_count, 1)
+	equal(memo(1, arg1_2), { arg1_2: true, arg0: 1 })
+	equal(call_count, 2)
+	memo.clear()
+	equal(memo(1, arg1), { arg1: true, arg0: 1 })
+	equal(call_count, 3)
+})
+test('memo_|objects|with primitives', ()=>{
+	let call_count = 0
+	let fn = (arg0:object, arg1:number)=>{
+		call_count++
+		return { ...arg0, arg1 }
+	}
+	let memo = memo_(fn)
+	let arg0 = { arg0: true }
+	let arg0_2 = { arg0_2: true }
+	equal(call_count, 0)
+	equal(memo(arg0, 1), { arg0: true, arg1: 1 })
+	equal(call_count, 1)
+	equal(memo(arg0, 1), { arg0: true, arg1: 1 })
+	equal(call_count, 1)
+	equal(memo(arg0_2, 1), { arg0_2: true, arg1: 1 })
+	equal(call_count, 2)
+	memo.clear()
+	equal(memo(arg0, 1), { arg0: true, arg1: 1 })
+	equal(call_count, 3)
+})
+test.run()

package/all/noop/index.js

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

package/all/primitive/index.d.ts

@@ -0,0 +1,2 @@
+import type { nullish } from '../nullish/index.js'
+export type primitive_T = boolean|number|string|nullish

package/all/primitive/index.js

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

package/all/prototype/index.d.ts

@@ -0,0 +1,5 @@
+import type { nullish } from '../nullish/index.js'
+import type { primitive_T } from '../primitive/index.js'
+export declare function prototype_(val:Exclude<any, nullish>):Object
+export declare function prototype__set(obj:Exclude<any, primitive_T>, val:Object):Object
+export declare const fn__proto:Object

package/all/prototype/index.js

@@ -0,0 +1,6 @@
+export const { getPrototypeOf, setPrototypeOf, defineProperty, defineProperties } = Object
+export {
+	getPrototypeOf as prototype_,
+	setPrototypeOf as prototype__set,
+}
+export const fn__proto = getPrototypeOf(getPrototypeOf)

package/all/prototype/index.test.ts

@@ -0,0 +1,14 @@
+import { test } from 'uvu'
+import { is, not } from 'uvu/assert'
+import { prototype_ } from './index.js'
+test('prototype_', ()=>{
+	is(prototype_({}), Object.prototype)
+	is(prototype_(new WeakRef({})), WeakRef.prototype)
+	is(prototype_(1), Number.prototype)
+	is(prototype_(true), Boolean.prototype)
+	is(prototype_(false), Boolean.prototype)
+	not.equal(prototype_(new Date), Boolean.prototype)
+	not.equal(prototype_({}), Boolean.prototype)
+	not.equal(prototype_(1), Boolean.prototype)
+})
+test.run()

package/all/rememo/index.d.ts

@@ -0,0 +1,20 @@
+export declare function rememo_<val_T>(
+	def:(rememo:rememo__T<val_T>)=>val_T,
+	...subscriber_a:rememo_subscriber_T<val_T>[]
+):rememo_T<val_T>
+export declare function signal_<val_T>(
+	init_val:val_T,
+	...subscriber_a:rememo_subscriber_T<val_T>[]
+):rememo_T<val_T>
+export type rememo__T<val_T> =
+	(def:rememo_def_T<val_T>, ...subscriber_a:rememo_subscriber_T<val_T>[])=>val_T
+export type rememo_T<val_T> = ((val?:val_T)=>val_T)&rememo_o_T<val_T>
+export type rememo_def_T<val_T> = (rememo:rememo__T<val>)=>val_T
+export type rememo_subscriber_T<val_T> = (rememo:rememo_T<val_T>)=>unknown
+export type rememo_o_T<val_T> = {
+	_:val_T
+	readonly val:val_T
+	init():unknown
+	onset(val:val_T):unknown
+	refresh():val_T
+}

package/all/rememo/index.js

@@ -0,0 +1,82 @@
+/** @typedef {import('./index.d.ts').rememo_T} */
+/** @typedef {import('./index.d.ts').rememo_subscriber_T} */
+/** @type {(()=>unknown)[]} */
+let queue = []
+/** @type {WeakRef<rememo_T>} */
+let cur_ref
+/**
+ * @param {(rememo:rememo_T<unknown>)=>unknown}_f
+ * @param {rememo_subscriber_T<unknown>[]}subscriber_a
+ * @returns {rememo_T}
+ * @private
+ */
+export function rememo_(_f, ...subscriber_a) {
+	let _a = []
+	let _rS = new Set
+	let rememo$ = (...arg_a)=>arg_a.length ? rememo$._ = arg_a[0] : rememo$._
+	rememo$._a = _a
+	rememo$._f = _f
+	rememo$._rS = _rS
+	rememo$._r = new WeakRef(()=>rememo$.refresh(_f(rememo$)))
+	rememo$.onset = ()=>0
+	rememo$._r.l = 0
+	rememo$.init = ()=>(rememo$(), rememo$)
+	Object.defineProperty(rememo$, '_', {
+		get() {
+			// allow self-referencing
+			if (!_a.length) {
+				let prev_ref = cur_ref
+				cur_ref = rememo$._r
+				try {
+					_a[0] = _f(rememo$)
+				} finally {
+					cur_ref = prev_ref
+				}
+			}
+			if (cur_ref && cur_ref !== rememo$._r) {
+				cur_ref.l = Math.max(rememo$._r.l + 1, cur_ref.l)
+				_rS.add(cur_ref)
+			}
+			return _a[0]
+		},
+		set(val) {
+			if (!_a.length || val !== _a[0]) {
+				rememo$.refresh(val)
+			}
+			return val
+		}
+	})
+	rememo$.refresh = val=>{
+		let { length } = _a
+		_a[0] = val
+		rememo$.onset(val)
+		if (length) {
+			let run_queue = !queue[0]
+			for (let ref of _rS) {
+				if (!~queue.indexOf(ref)) queue.push(ref)
+			}
+			if (run_queue) {
+				for (let ref; ref = queue.shift();) {
+					queue.some(_ref=>ref.l > _ref.l) ? queue.push(ref) : ref.deref()?.() ?? _rS.delete(ref)
+				}
+			}
+		}
+		return rememo$
+	}
+	rememo$._sa = subscriber_a.map(subscriber=>
+		rememo_(()=>subscriber(rememo$)).init())
+	return rememo$
+}
+/**
+ * @param {unknown}init_val
+ * @param {rememo_subscriber_T[]}subscriber_a
+ * @returns {rememo_T}
+ * @private
+ */
+export function signal_(init_val, ...subscriber_a) {
+	let signal$ =
+		rememo_(signal$=>signal$._v, ...subscriber_a)
+	signal$.onset = val=>signal$._v = val
+	signal$._v = init_val
+	return signal$
+}

package/all/rememo/index.test.ts

@@ -0,0 +1,241 @@
+import { deepStrictEqual } from 'node:assert'
+import { clock } from 'sinon'
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { sleep } from '../sleep/index.js'
+import { rememo_, signal_ } from './index.js'
+test('rememo_|static value', ()=>{
+	let count = 0
+	let rememo$ = rememo_(rememo=>{
+		count++
+		return 'rememo-value'
+	})
+	equal(count, 0)
+	equal(rememo$(), 'rememo-value')
+	equal(count, 1)
+	equal(rememo$(), 'rememo-value')
+	equal(count, 1)
+})
+test('signal_', ()=>{
+	let signal$ = signal_('val0')
+	equal(signal$(), 'val0')
+	signal$('val1')
+	equal(signal$(), 'val1')
+})
+test('rememo_|async subsubscriber', async ()=>{
+	let resolve:(user:{ id:string })=>void
+	let user0 = { id: 'id-0' }
+	let user1 = { id: 'id-1' }
+	let id$ = signal_('id-0')
+	let user$ = signal_<{ id:string }|null>(
+		null,
+		async (_user$)=>{
+			id$()
+			let user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
+			_user$(user)
+		})
+	equal(user$(), null)
+	resolve!(user0)
+	await sleep(0)
+	equal(user$(), user0)
+	id$('id-1')
+	equal(user$(), user0)
+	resolve!(user1)
+	await sleep(0)
+})
+test('rememo_+signal_|simple graph', ()=>{
+	let base$ = signal_('base0')
+	let dep0$ = rememo_(()=>base$() + '-dep0')
+	let dep1$ = rememo_(()=>dep0$() + '-dep1')
+	let dep2$ = rememo_(()=>dep1$() + '-dep2')
+	let dep3$ = rememo_(()=>dep2$() + '-dep3')
+	let dep4$ = rememo_(()=>dep3$() + '-dep4')
+	equal(dep4$(), 'base0-dep0-dep1-dep2-dep3-dep4')
+	equal(dep3$(), 'base0-dep0-dep1-dep2-dep3')
+	equal(dep2$(), 'base0-dep0-dep1-dep2')
+	equal(dep1$(), 'base0-dep0-dep1')
+	equal(dep0$(), 'base0-dep0')
+	equal(base$(), 'base0')
+	base$('base1')
+	equal(base$(), 'base1')
+	equal(dep0$(), 'base1-dep0')
+	equal(dep1$(), 'base1-dep0-dep1')
+	equal(dep2$(), 'base1-dep0-dep1-dep2')
+	equal(dep3$(), 'base1-dep0-dep1-dep2-dep3')
+	equal(dep4$(), 'base1-dep0-dep1-dep2-dep3-dep4')
+})
+test('prevents diamond dependency problem 1', ()=>{
+	let store$ = signal_(0)
+	let values:string[] = []
+	let a$ = rememo_(()=>`a${store$()}`)
+	let b$ = rememo_(()=>a$().replace('a', 'b'))
+	let c$ = rememo_(()=>a$().replace('a', 'c'))
+	let d$ = rememo_(()=>a$().replace('a', 'd'))
+	let combined$ = rememo_(()=>`${b$()}${c$()}${d$()}`,
+		combined$=>
+			values.push(combined$()))
+	deepStrictEqual(values, ['b0c0d0'])
+	store$(1)
+	store$(2)
+	deepStrictEqual(values, ['b0c0d0', 'b1c1d1', 'b2c2d2'])
+})
+test('prevents diamond dependency problem 2', ()=>{
+	let store$ = signal_(0)
+	let values:string[] = []
+	let a$ = rememo_(()=>`a${store$()}`)
+	let b$ = rememo_(()=>a$().replace('a', 'b'))
+	let c$ = rememo_(()=>b$().replace('b', 'c'))
+	let d$ = rememo_(()=>c$().replace('c', 'd'))
+	let e$ = rememo_(()=>d$().replace('d', 'e'))
+	let combined$ = rememo_<string>(
+		()=>[a$(), e$()].join(''),
+		combined$=>values.push(combined$()))
+	deepStrictEqual(values, ['a0e0'])
+	store$(1)
+	deepStrictEqual(values, ['a0e0', 'a1e1'])
+})
+test('prevents diamond dependency problem 3', ()=>{
+	let store$ = signal_(0)
+	let values:string[] = []
+	let a$ = rememo_(()=>`a${store$()}`)
+	let b$ = rememo_(()=>a$().replace('a', 'b'))
+	let c$ = rememo_(()=>b$().replace('b', 'c'))
+	let d$ = rememo_(()=>c$().replace('c', 'd'))
+	rememo_<string>(
+		()=>`${a$()}${b$()}${c$()}${d$()}`,
+		combined$=>values.push(combined$()))
+	deepStrictEqual(values, ['a0b0c0d0'])
+	store$(1)
+	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
+})
+test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
+	let store1$ = signal_(0)
+	let store2$ = signal_(0)
+	let values:string[] = []
+	let fn =
+		(name:string)=>
+			(...v:(number|string)[])=>
+				`${name}${v.join('')}`
+	let a$ = rememo_(()=>`a${store1$()}`)
+	let b$ = rememo_(()=>`b${store2$()}`)
+	let c$ = rememo_(()=>`c${a$()}${b$()}`)
+	let d$ = rememo_(()=>`d${a$()}`)
+	let e$ = rememo_(()=>`e${c$()}${d$()}`)
+	let f$ = rememo_(()=>`f${e$()}`)
+	let g$ = rememo_(()=>`g${f$()}`)
+	rememo_(
+		()=>e$(),
+		combined1$=>values.push(combined1$()))
+	rememo_(
+		()=>[e$(), g$()].join(''),
+		combined2$=>values.push(combined2$()))
+	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
+	store1$(1)
+	store2$(2)
+	deepStrictEqual(values, [
+		'eca0b0da0',
+		'eca0b0da0gfeca0b0da0',
+		'eca1b0da1',
+		'eca1b0da1gfeca1b0da1',
+		'eca1b2da1',
+		'eca1b2da1gfeca1b2da1'
+	])
+})
+test('prevents diamond dependency problem 5', ()=>{
+	let events = ''
+	let firstName$ = signal_('John')
+	let lastName$ = signal_('Doe')
+	let fullName$ = rememo_(()=>{
+		events += 'full '
+		return `${firstName$()} ${lastName$()}`
+	})
+	let isFirstShort$ = rememo_(()=>{
+		events += 'short '
+		return firstName$().length < 10
+	})
+	let displayName$ = rememo_(
+		()=>{
+			events += 'display '
+			return isFirstShort$() ? fullName$() : firstName$()
+		}
+	)
+	equal(events, '')
+	equal(displayName$(), 'John Doe')
+	equal(events, 'display short full ')
+	firstName$('Benedict')
+	equal(displayName$(), 'Benedict Doe')
+	equal(events, 'display short full short full display ')
+	firstName$('Montgomery')
+	equal(displayName$(), 'Montgomery')
+	equal(events, 'display short full short full display short full display ')
+})
+test('prevents diamond dependency problem 6', ()=>{
+	let store1$ = signal_(0)
+	let store2$ = signal_(0)
+	let values:string[] = []
+	let a$ = rememo_(()=>`a${store1$()}`)
+	let b$ = rememo_(()=>`b${store2$()}`)
+	let c$ = rememo_(()=>b$().replace('b', 'c'))
+	rememo_(
+		()=>`${a$()}${c$()}`,
+		combined$=>values.push(combined$()))
+	deepStrictEqual(values, ['a0c0'])
+	store1$(1)
+	deepStrictEqual(values, ['a0c0', 'a1c0'])
+})
+test('prevents dependency listeners from being out of order', ()=>{
+	let base$ = signal_(0)
+	let a$ = rememo_(()=>{
+		return `${base$()}a`
+	})
+	let values:string[] = []
+	let b$ = rememo_(()=>{
+		return `${a$()}b`
+	}, b$=>values.push(b$()))
+	equal(b$(), '0ab')
+	deepStrictEqual(values, ['0ab'])
+	equal(a$(), '0a')
+	base$(1)
+	deepStrictEqual(values, ['0ab', '1ab'])
+})
+test('computes initial value when argument is undefined', ()=>{
+	let one$ = signal_<string|undefined>(undefined)
+	let two$ = rememo_(()=>!!one$())
+	equal(one$(), undefined)
+	equal(two$(), false)
+})
+test('async computed using task', async ()=>{
+	let a$ = signal_(1)
+	let b$ = signal_(2)
+	let sleepCycles = 5
+	let taskArgumentsCalls:number[][] = []
+	let sum$ = signal_<null|number>(null,
+		async sum$=>{
+			taskArgumentsCalls.push([a$(), b$()])
+			for (let i = 0; i < sleepCycles; i++) {
+				await Promise.resolve()
+			}
+			sum$(a$() + b$())
+		})
+	equal(sum$(), null)
+	deepStrictEqual(taskArgumentsCalls, [[1, 2]])
+	// sleepCycles = 0
+	a$(10)
+	b$(20)
+	for (let i = 0; i < sleepCycles; i++) {
+		equal(sum$(), null)
+		await Promise.resolve()
+		deepStrictEqual(taskArgumentsCalls, [
+			[1, 2],
+			[10, 2],
+			[10, 20]
+		])
+	}
+	equal(sum$(), 30)
+	deepStrictEqual(taskArgumentsCalls, [
+		[1, 2],
+		[10, 2],
+		[10, 20]
+	])
+})
+test.run()

package/function/index.d.ts

@@ -36,7 +36,7 @@ export * from '../all/ifelse/index.js'
 export * from '../all/iife/index.js'
 export * from '../all/invert/index.js'
 export * from '../all/isArray/index.js'
-export * from '../all/isPromise/index.js'
+export * from '../all/isPromiseLike/index.js'
 export * from '../all/left_and/index.js'
 export * from '../all/left_or/index.js'
 export * from '../all/many_andand/index.js'
@@ -45,6 +45,7 @@ export * from '../all/map_apply/index.js'
 export * from '../all/map_call/index.js'
 export * from '../all/map_fn/index.js'
 export * from '../all/maybe/index.js'
+export * from '../all/memo/index.js'
 export * from '../all/neq/index.js'
 export * from '../all/neql/index.js'
 export * from '../all/nf/index.js'

package/function/index.js

@@ -36,7 +36,7 @@ export * from '../all/ifelse/index.js'
 export * from '../all/iife/index.js'
 export * from '../all/invert/index.js'
 export * from '../all/isArray/index.js'
-export * from '../all/isPromise/index.js'
+export * from '../all/isPromiseLike/index.js'
 export * from '../all/left_and/index.js'
 export * from '../all/left_or/index.js'
 export * from '../all/many_andand/index.js'
@@ -45,6 +45,7 @@ export * from '../all/map_apply/index.js'
 export * from '../all/map_call/index.js'
 export * from '../all/map_fn/index.js'
 export * from '../all/maybe/index.js'
+export * from '../all/memo/index.js'
 export * from '../all/neq/index.js'
 export * from '../all/neql/index.js'
 export * from '../all/nf/index.js'

package/object/index.d.ts

@@ -40,6 +40,7 @@ export * from '../all/or_null/index.js'
 export * from '../all/pick/index.js'
 export * from '../all/pick_keys/index.js'
 export * from '../all/pick_val_a/index.js'
+export * from '../all/prototype/index.js'
 export * from '../all/rc_be/index.js'
 export * from '../all/rc_be_/index.js'
 export * from '../all/toString/index.js'

package/object/index.js

@@ -39,6 +39,7 @@ export * from '../all/or_null/index.js'
 export * from '../all/pick/index.js'
 export * from '../all/pick_keys/index.js'
 export * from '../all/pick_val_a/index.js'
+export * from '../all/prototype/index.js'
 export * from '../all/rc_be/index.js'
 export * from '../all/rc_be_/index.js'
 export * from '../all/toString/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -53,6 +53,7 @@
     "queue",
     "random",
     "regex",
+    "rememo",
     "set",
     "sleep",
     "string",
@@ -93,6 +94,7 @@
     "./queue": "./queue/index.js",
     "./random": "./random/index.js",
     "./regex": "./regex/index.js",
+    "./rememo": "./rememo/index.js",
     "./set": "./set/index.js",
     "./sleep": "./sleep/index.js",
     "./string": "./string/index.js",
@@ -104,10 +106,13 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.13.1",
+    "@size-limit/preset-small-lib": "^11.0.0",
+    "@types/node": "^20.9.1",
     "@types/sinon": "^17.0.1",
     "c8": "^8.0.1",
     "check-dts": "^0.7.2",
     "sinon": "^17.0.1",
+    "size-limit": "^11.0.0",
     "ts-node": "^10.9.1",
     "tsx": "^4.1.2",
     "typescript": "next",
@@ -118,12 +123,37 @@
     "cache": "~/.npm"
   },
   "sideEffects": false,
+  "size-limit": [
+    {
+      "name": "be",
+      "import": {
+        "./be": "{ be_ }"
+      },
+      "limit": "600 B"
+    },
+    {
+      "name": "rememo",
+      "import": {
+        "./rememo": "{ rememo_ }"
+      },
+      "limit": "358 B"
+    },
+    {
+      "name": "rememo signal",
+      "import": {
+        "./rememo": "{ signal_ }"
+      },
+      "limit": "385 B"
+    }
+  ],
   "scripts": {
     "build": ":",
     "clean": ":",
     "exec": "$@",
-    "test": "pnpm test-unit && check-dts",
-    "test-unit": "tsx node_modules/uvu/bin.js . '\\.test\\.(ts|js)$'",
-    "test-unit-coverage": "c8 pnpm test-unit"
+    "test": "pnpm run /^test:/",
+    "test:size": "size-limit",
+    "test:type": "check-dts",
+    "test:unit": "tsx node_modules/uvu/bin.js . '\\.test\\.(ts|js)$'",
+    "disable:test:coverage": "c8 pnpm test-unit"
   }
 }

package/rememo/index.d.ts

@@ -0,0 +1 @@
+export * from '../all/rememo/index.js'

package/rememo/index.js

@@ -0,0 +1 @@
+export * from '../all/rememo/index.js'

package/tsconfig.json

@@ -5,7 +5,10 @@
 		"moduleResolution": "nodenext",
 		"target": "ESNext",
 		"strict": true,
-		"skipLibCheck": true
-	},
-	"exclude": ["node_modules"]
+		"skipLibCheck": true,
+		"lib": ["ESNext"],
+		"types": [
+			"node"
+		]
+	}
 }

package/all/isPromise/index.d.ts

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