ctx-core 2.4.0 → 3.1.0

package/all/be_/index.js

@@ -1,12 +1,5 @@
 import { globalThis__prop__ensure } from '../globalThis__prop__ensure/index.js'
-import { isArray } from '../isArray/index.js'
-let proto_ = Object.getPrototypeOf
-let string_proto = proto_('')
-let _null = null
-let pending_sym = Symbol.for('pending')
-let be_M_is_source_ = globalThis__prop__ensure(
-	Symbol.for('be_M_is_source_'),
-	()=>new WeakMap())
+let be_M_is_source_ = globalThis.be_M_is_source_ ||= new WeakMap()
 /** @typedef {import('./index.d.ts').Be}Be */
 /** @typedef {import('./index.d.ts').Ctx}Ctx */
 /** @typedef {import('./index.d.ts').MapCtx}MapCtx */
@@ -51,69 +44,60 @@ export function globalThis__be_(
 export function be_(
 	id_OR_val__new,
 	val__new_OR_be__params,
-	be__params = {}
+	be__params
 ) {
 	/** @type {string} */
-	let id =
-		proto_(id_OR_val__new) === string_proto
-			? id_OR_val__new
-			: _null
+	let id
 	/** @type {be__val__T} */
-	let val__new =
-		proto_(id_OR_val__new) === string_proto
-			? val__new_OR_be__params || (()=>null)
-			: id_OR_val__new
-	be__params =
-		proto_(id_OR_val__new) === string_proto
-			? be__params
-			: val__new_OR_be__params
-	let is_source_ =
-		be__params
-			? be__params.is_source_
-			: _null
-	let expired_ =
-		be__params
-			? be__params.expired_
-			: ()=>0
-	let be = (argv__ctx, params = {})=>{
+	let val__new
+	/** @type {is_source__T} */
+	let is_source_
+	/** @type {expired__T} */
+	let expired_
+	if (typeof id_OR_val__new === 'string') {
+		val__new = val__new_OR_be__params
+		id = id_OR_val__new
+	} else {
+		val__new = id_OR_val__new
+		be__params = val__new_OR_be__params
+	}
+	if (be__params) {
+		is_source_ = be__params.is_source_
+		expired_ = be__params.expired_
+	}
+	let be = (argv__ctx, params)=>{
 		if (!argv__ctx) {
-			throw new Error(`be must have a Ctx passed as an argument`)
+			throw new Error(`be: no Ctx`)
 		}
 		let saved__val = be__val_(be, argv__ctx)
 		if (
-			be__has_(be, argv__ctx)
-			&& !params.force
-			&& (!expired_ || !expired_(argv__ctx))
+			!params?.force
+			&& be__has_(be, argv__ctx)
+			&& !expired_?.(argv__ctx)
 		) {
 			return saved__val
 		}
 		let ctx = source__map_ctx_(argv__ctx, is_source_)
 		if (!ctx) {
 			throw new Error(
-				`be: ${
-					String(id)
-				}: is_source_ must be true for at least one Ctx`)
+				`be: ${String(id)}: no is_source_ returns true`)
 		}
-		let pending = ctx.get(pending_sym)
+		let pending = ctx.get(Symbol.for('pending'))
 		if (!pending) {
-			pending = new Map()
-			ctx.set(pending_sym, pending)
+			pending = new Map
+			ctx.set(Symbol.for('pending'), pending)
 		}
 		if (pending.get(be)) {
-			let pending_value_a = []
-			for (let value of pending.values()) {
-				pending_value_a.push(value)
-			}
 			throw new Error(
 				`be_: ${
 					String(id)
-				}: circular dependency:\n${pending_value_a.map(pending_value=>
-					typeof pending_value === 'function'
-						? 'Function'
-						: pending_value).join('\n')}`)
+				}: circular:\n${pending.values().map(pending_value=>
+					typeof pending_value === 'string'
+						? pending_value
+						: 'Function').join('\n')}`)
 		}
 		pending.set(be, id || be)
-		let val = val__new(argv__ctx, be, params)
+		let val = val__new ? val__new(argv__ctx, be, params) : null
 		ctx.set(be, val)
 		if (id) {
 			ctx.set(id, val)
@@ -162,7 +146,6 @@ export function ctx__set(
 	val,
 	is_source_
 ) {
-	if (!is_source_) is_source_ = ()=>true
 	let source__map_ctx = source__map_ctx_(ctx, is_source_)
 	if (source__map_ctx) {
 		source__map_ctx.set(be_OR_id, val)
@@ -189,25 +172,18 @@ export function ctx__delete(
 	ctx,
 	be_OR_id,
 ) {
-	const is_source_ =
-		be__is_source__(be_OR_id)
-		|| (()=>true)
-	if (isArray(ctx)) {
-		for (let i = 0; i < ctx.length; i++) {
-			if (is_source_(ctx[i], ctx)) {
-				ctx__delete(ctx[i], be_OR_id)
-			}
+	if (Array.isArray(ctx)) {
+		for (let _ctx of ctx) {
+			ctx__delete(_ctx, be_OR_id)
 		}
 	} else {
 		/** @type {MapCtx} */
 		let map_ctx = /** @type {any} */ctx
-		if (is_source_(map_ctx, ctx)) {
-			let { id } = be_OR_id
-			if (id) {
-				map_ctx.delete(id)
-			}
-			map_ctx.delete(be_OR_id)
+		let { id } = be_OR_id
+		if (id) {
+			map_ctx.delete(id)
 		}
+		map_ctx.delete(be_OR_id)
 	}
 }
 /**
@@ -217,7 +193,7 @@ export function ctx__delete(
  * @private
  */
 export function be__has_(be_or_id, argv__ctx) {
-	return !!be__has__ctx_(be_or_id, argv__ctx)
+	return Boolean(be__has__ctx_(be_or_id, argv__ctx))
 }
 /**
  * @param {Be|string}be_or_id
@@ -226,7 +202,7 @@ export function be__has_(be_or_id, argv__ctx) {
  * @private
  */
 export function be__has__ctx_(be_or_id, argv__ctx) {
-	if (isArray(argv__ctx)) {
+	if (Array.isArray(argv__ctx)) {
 		for (let i = 0; i < argv__ctx.length; i++) {
 			const be__has__ctx = be__has__ctx_(be_or_id, argv__ctx[i])
 			if (be__has__ctx) return be__has__ctx
@@ -243,7 +219,7 @@ export function be__has__ctx_(be_or_id, argv__ctx) {
  * @private
  */
 export function be__val_(be_or_id, argv__ctx) {
-	if (isArray(argv__ctx)) {
+	if (Array.isArray(argv__ctx)) {
 		for (let i = 0; i < argv__ctx.length; i++) {
 			let ctx = argv__ctx[i]
 			const be__has__ctx = be__has__ctx_(be_or_id, ctx)
@@ -260,7 +236,7 @@ export function be__val_(be_or_id, argv__ctx) {
  * @private
  */
 export function source__map_ctx_(ctx, is_source_) {
-	if (isArray(ctx)) {
+	if (Array.isArray(ctx)) {
 		for (let i = 0; i < ctx.length; i++) {
 			let i_ctx = ctx[i]
 			let source__map_ctx = source__map_ctx_(i_ctx, is_source_)

package/all/rmemo/index.d.ts

@@ -0,0 +1,18 @@
+export declare function rmemo_<val_T>(
+	def:rmemo_def_T<val_T>,
+	...subscriber_a:rmemo_subscriber_T<val_T>[]
+):rmemo_T<val_T>
+export declare function rsig_<val_T>(
+	init_val:val_T,
+	...subscriber_a:rmemo_subscriber_T<val_T>[]
+):rmemo_T<val_T>
+export type rmemo_T<val_T> = ((val?:val_T)=>val_T)&rmemo_o_T<val_T>
+export type rmemo_def_T<val_T> = (rmemo:rmemo_T<val_T>)=>val_T
+export type rmemo_subscriber_T<val_T> = (rmemo:rmemo_T<val_T>)=>unknown
+export type rmemo_o_T<val_T> = {
+	_:val_T
+	readonly val:val_T
+	go():unknown
+	onset(val:val_T):unknown
+	refresh():val_T
+}

package/all/rmemo/index.js

@@ -0,0 +1,88 @@
+/** @typedef {import('./index.d.ts').rmemo_T} */
+/** @typedef {import('./index.d.ts').rmemo_subscriber_T} */
+/** @type {(()=>unknown)[]} */
+let queue = []
+/** @type {WeakRef<rmemo_T>} */
+let cur_ref
+/**
+ * @param {(rmemo:rmemo_T<unknown>)=>unknown}_f
+ * @param {rmemo_subscriber_T<unknown>[]}subscriber_a
+ * @returns {rmemo_T}
+ * @private
+ */
+export function rmemo_(_f, ...subscriber_a) {
+	let rmemo$ = (...arg_a)=>arg_a.length ? rmemo$._ = arg_a[0] : rmemo$._
+	let _a = []
+	let _r = new WeakRef(()=>rmemo$.refresh(_f(rmemo$)))
+	_r.l = 0
+	rmemo$._a = _a
+	rmemo$._f = _f
+	rmemo$._r = _r
+	rmemo$._rS = new Set
+	rmemo$.go = ()=>(rmemo$(), rmemo$)
+	rmemo$.onset = ()=>0
+	Object.defineProperty(rmemo$, '_', {
+		get() {
+			if (!_a.length) {
+				let prev_ref = cur_ref
+				cur_ref = _r
+				try {
+					_a[0] = _f(rmemo$)
+				} finally {
+					cur_ref = prev_ref
+				}
+			}
+			// allow self-referencing
+			if (cur_ref && cur_ref !== _r) {
+				// Math.max: bitwise is much faster on chrome
+				// https://measurethat.net/Benchmarks/Show/28483/0/mathmax-vs-bitwise
+				cur_ref.l = cur_ref.l ^ ((cur_ref.l ^ _r.l + 1) & -(cur_ref.l < _r.l + 1))
+				rmemo$._rS.add(cur_ref)
+			}
+			return _a[0]
+		},
+		set(val) {
+			if (!_a.length || val !== _a[0]) {
+				rmemo$.refresh(val)
+			}
+			return val
+		}
+	})
+	rmemo$.refresh = val=>{
+		let length = _a.length
+		_a[0] = val
+		rmemo$.onset(val)
+		if (length) {
+			let run_queue = !queue[0]
+			for (let ref of rmemo$._rS) {
+				if (!~queue.indexOf(ref)) queue.push(ref)
+			}
+			if (run_queue) {
+				for (let ref; ref = queue.shift();) {
+					if (queue.some(_ref=>ref.l > _ref.l)) {
+						queue.push(ref)
+					} else {
+						(ref.deref() || rmemo$._rS.delete)(ref)
+					}
+				}
+			}
+		}
+		return rmemo$
+	}
+	rmemo$._sa = subscriber_a.map(subscriber=>
+		rmemo_(()=>subscriber(rmemo$)).go())
+	return rmemo$
+}
+/**
+ * @param {unknown}init_val
+ * @param {rmemo_subscriber_T[]}subscriber_a
+ * @returns {rmemo_T}
+ * @private
+ */
+export function rsig_(init_val, ...subscriber_a) {
+	let signal$ =
+		rmemo_(signal$=>signal$._v, ...subscriber_a)
+	signal$.onset = val=>signal$._v = val
+	signal$._v = init_val
+	return signal$
+}

package/all/{rememo → rmemo}/index.test.ts

@@ -1,33 +1,43 @@
 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', ()=>{
+import { rmemo_, rmemo_T, rsig_ } from './index.js'
+test('rmemo_|static value', ()=>{
 	let count = 0
-	let rememo$ = rememo_(rememo=>{
+	let rmemo$ = rmemo_(rmemo=>{
 		count++
-		return 'rememo-value'
+		return 'rmemo-value'
 	})
 	equal(count, 0)
-	equal(rememo$(), 'rememo-value')
+	equal(rmemo$(), 'rmemo-value')
 	equal(count, 1)
-	equal(rememo$(), 'rememo-value')
+	equal(rmemo$(), 'rmemo-value')
 	equal(count, 1)
 })
-test('signal_', ()=>{
-	let signal$ = signal_('val0')
-	equal(signal$(), 'val0')
-	signal$('val1')
-	equal(signal$(), 'val1')
+test('rsig_', ()=>{
+	let rsig$ = rsig_('val0')
+	equal(rsig$(), 'val0')
+	rsig$('val1')
+	equal(rsig$(), 'val1')
 })
-test('rememo_|async subsubscriber', async ()=>{
+test('rmemo_|def function|rmemo$ argument', ()=>{
+	let rsig$ = rsig_('val0')
+	let rmemo$:rmemo_T<string>&{custom?:string} = rmemo_<string>((_rmemo$:rmemo_T<string>&{custom?:string})=>
+		`${_rmemo$.custom}-${rsig$()}`)
+	rmemo$.custom = 'custom_val0'
+	equal(rmemo$(), 'custom_val0-val0')
+	rmemo$.custom = 'custom_val1'
+	equal(rmemo$(), 'custom_val0-val0')
+	rsig$('val1')
+	equal(rmemo$(), 'custom_val1-val1')
+})
+test('rsig_|async subsubscriber|case 1', 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>(
+	let id$ = rsig_('id-0')
+	let user$ = rsig_<{ id:string }|null>(
 		null,
 		async (_user$)=>{
 			id$()
@@ -43,13 +53,46 @@ test('rememo_|async subsubscriber', async ()=>{
 	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')
+test('rsig_|async subsubscriber|case 2', async ()=>{
+	let a$ = rsig_(1)
+	let b$ = rsig_(2)
+	let sleepCycles = 5
+	let taskArgumentsCalls:number[][] = []
+	let sum$ = rsig_<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]])
+	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('rmemo_+rsig_|simple graph', ()=>{
+	let base$ = rsig_('base0')
+	let dep0$ = rmemo_(()=>base$() + '-dep0')
+	let dep1$ = rmemo_(()=>dep0$() + '-dep1')
+	let dep2$ = rmemo_(()=>dep1$() + '-dep2')
+	let dep3$ = rmemo_(()=>dep2$() + '-dep3')
+	let dep4$ = rmemo_(()=>dep3$() + '-dep4')
 	equal(dep4$(), 'base0-dep0-dep1-dep2-dep3-dep4')
 	equal(dep3$(), 'base0-dep0-dep1-dep2-dep3')
 	equal(dep2$(), 'base0-dep0-dep1-dep2')
@@ -65,13 +108,13 @@ test('rememo_+signal_|simple graph', ()=>{
 	equal(dep4$(), 'base1-dep0-dep1-dep2-dep3-dep4')
 })
 test('prevents diamond dependency problem 1', ()=>{
-	let store$ = signal_(0)
+	let store$ = rsig_(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$()}`,
+	let a$ = rmemo_(()=>`a${store$()}`)
+	let b$ = rmemo_(()=>a$().replace('a', 'b'))
+	let c$ = rmemo_(()=>a$().replace('a', 'c'))
+	let d$ = rmemo_(()=>a$().replace('a', 'd'))
+	let combined$ = rmemo_(()=>`${b$()}${c$()}${d$()}`,
 		combined$=>
 			values.push(combined$()))
 	deepStrictEqual(values, ['b0c0d0'])
@@ -80,14 +123,14 @@ test('prevents diamond dependency problem 1', ()=>{
 	deepStrictEqual(values, ['b0c0d0', 'b1c1d1', 'b2c2d2'])
 })
 test('prevents diamond dependency problem 2', ()=>{
-	let store$ = signal_(0)
+	let store$ = rsig_(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>(
+	let a$ = rmemo_(()=>`a${store$()}`)
+	let b$ = rmemo_(()=>a$().replace('a', 'b'))
+	let c$ = rmemo_(()=>b$().replace('b', 'c'))
+	let d$ = rmemo_(()=>c$().replace('c', 'd'))
+	let e$ = rmemo_(()=>d$().replace('d', 'e'))
+	let combined$ = rmemo_<string>(
 		()=>[a$(), e$()].join(''),
 		combined$=>values.push(combined$()))
 	deepStrictEqual(values, ['a0e0'])
@@ -95,13 +138,13 @@ test('prevents diamond dependency problem 2', ()=>{
 	deepStrictEqual(values, ['a0e0', 'a1e1'])
 })
 test('prevents diamond dependency problem 3', ()=>{
-	let store$ = signal_(0)
+	let store$ = rsig_(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>(
+	let a$ = rmemo_(()=>`a${store$()}`)
+	let b$ = rmemo_(()=>a$().replace('a', 'b'))
+	let c$ = rmemo_(()=>b$().replace('b', 'c'))
+	let d$ = rmemo_(()=>c$().replace('c', 'd'))
+	rmemo_<string>(
 		()=>`${a$()}${b$()}${c$()}${d$()}`,
 		combined$=>values.push(combined$()))
 	deepStrictEqual(values, ['a0b0c0d0'])
@@ -109,24 +152,24 @@ test('prevents diamond dependency problem 3', ()=>{
 	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
 })
 test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
-	let store1$ = signal_(0)
-	let store2$ = signal_(0)
+	let store1$ = rsig_(0)
+	let store2$ = rsig_(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_(
+	let a$ = rmemo_(()=>`a${store1$()}`)
+	let b$ = rmemo_(()=>`b${store2$()}`)
+	let c$ = rmemo_(()=>`c${a$()}${b$()}`)
+	let d$ = rmemo_(()=>`d${a$()}`)
+	let e$ = rmemo_(()=>`e${c$()}${d$()}`)
+	let f$ = rmemo_(()=>`f${e$()}`)
+	let g$ = rmemo_(()=>`g${f$()}`)
+	rmemo_(
 		()=>e$(),
 		combined1$=>values.push(combined1$()))
-	rememo_(
+	rmemo_(
 		()=>[e$(), g$()].join(''),
 		combined2$=>values.push(combined2$()))
 	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
@@ -143,17 +186,17 @@ test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
 })
 test('prevents diamond dependency problem 5', ()=>{
 	let events = ''
-	let firstName$ = signal_('John')
-	let lastName$ = signal_('Doe')
-	let fullName$ = rememo_(()=>{
+	let firstName$ = rsig_('John')
+	let lastName$ = rsig_('Doe')
+	let fullName$ = rmemo_(()=>{
 		events += 'full '
 		return `${firstName$()} ${lastName$()}`
 	})
-	let isFirstShort$ = rememo_(()=>{
+	let isFirstShort$ = rmemo_(()=>{
 		events += 'short '
 		return firstName$().length < 10
 	})
-	let displayName$ = rememo_(
+	let displayName$ = rmemo_(
 		()=>{
 			events += 'display '
 			return isFirstShort$() ? fullName$() : firstName$()
@@ -170,13 +213,13 @@ test('prevents diamond dependency problem 5', ()=>{
 	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 store1$ = rsig_(0)
+	let store2$ = rsig_(0)
 	let values:string[] = []
-	let a$ = rememo_(()=>`a${store1$()}`)
-	let b$ = rememo_(()=>`b${store2$()}`)
-	let c$ = rememo_(()=>b$().replace('b', 'c'))
-	rememo_(
+	let a$ = rmemo_(()=>`a${store1$()}`)
+	let b$ = rmemo_(()=>`b${store2$()}`)
+	let c$ = rmemo_(()=>b$().replace('b', 'c'))
+	rmemo_(
 		()=>`${a$()}${c$()}`,
 		combined$=>values.push(combined$()))
 	deepStrictEqual(values, ['a0c0'])
@@ -184,12 +227,12 @@ test('prevents diamond dependency problem 6', ()=>{
 	deepStrictEqual(values, ['a0c0', 'a1c0'])
 })
 test('prevents dependency listeners from being out of order', ()=>{
-	let base$ = signal_(0)
-	let a$ = rememo_(()=>{
+	let base$ = rsig_(0)
+	let a$ = rmemo_(()=>{
 		return `${base$()}a`
 	})
 	let values:string[] = []
-	let b$ = rememo_(()=>{
+	let b$ = rmemo_(()=>{
 		return `${a$()}b`
 	}, b$=>values.push(b$()))
 	equal(b$(), '0ab')
@@ -199,43 +242,9 @@ test('prevents dependency listeners from being out of order', ()=>{
 	deepStrictEqual(values, ['0ab', '1ab'])
 })
 test('computes initial value when argument is undefined', ()=>{
-	let one$ = signal_<string|undefined>(undefined)
-	let two$ = rememo_(()=>!!one$())
+	let one$ = rsig_<string|undefined>(undefined)
+	let two$ = rmemo_(()=>!!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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "2.4.0",
+  "version": "3.1.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -53,7 +53,7 @@
     "queue",
     "random",
     "regex",
-    "rememo",
+    "rmemo",
     "set",
     "sleep",
     "string",
@@ -94,7 +94,7 @@
     "./queue": "./queue/index.js",
     "./random": "./random/index.js",
     "./regex": "./regex/index.js",
-    "./rememo": "./rememo/index.js",
+    "./rmemo": "./rmemo/index.js",
     "./set": "./set/index.js",
     "./sleep": "./sleep/index.js",
     "./string": "./string/index.js",
@@ -129,21 +129,21 @@
       "import": {
         "./be": "{ be_ }"
       },
-      "limit": "600 B"
+      "limit": "465 B"
     },
     {
-      "name": "rememo",
+      "name": "rmemo",
       "import": {
-        "./rememo": "{ rememo_ }"
+        "./rmemo": "{ rmemo_ }"
       },
-      "limit": "358 B"
+      "limit": "351 B"
     },
     {
-      "name": "rememo signal",
+      "name": "rmemo signal",
       "import": {
-        "./rememo": "{ signal_ }"
+        "./rmemo": "{ rsig_ }"
       },
-      "limit": "385 B"
+      "limit": "377 B"
     }
   ],
   "scripts": {

package/rmemo/index.d.ts

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

package/rmemo/index.js

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

package/all/rememo/index.d.ts

@@ -1,20 +0,0 @@
-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

@@ -1,82 +0,0 @@
-/** @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/rememo/index.d.ts

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

package/rememo/index.js

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