ctx-core 4.5.0 → 4.6.1

package/all/be_memo_pair/index.d.ts

@@ -1,10 +1,10 @@
 import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
-import type { memo_T, rmemo_def_T } from '../rmemo/index.js'
+import type { memo_T, rmemo_def_T, rmemo_val_T } from '../rmemo/index.js'
 export declare function be_memo_pair_<
 	val_T,
 	_memo_T extends memo_T<val_T> = memo_T<val_T>,
 	ctx_T extends Ctx = Ctx
->(be: Be<_memo_T, ctx_T>):be_memo_pair_T<val_T, _memo_T, ctx_T>
+>(be: Be<_memo_T, ctx_T>):be_memo_pair_T<_memo_T, ctx_T>
 export declare function be_memo_pair_<
 	val_T,
 	_memo_T extends memo_T<val_T> = memo_T<val_T>,
@@ -14,12 +14,11 @@ export declare function be_memo_pair_<
 	...subscriber_a_THEN_config:
 		|[...rmemo_def_T<val_T>[]]
 		|[...rmemo_def_T<val_T>[], config:be_config_T]
-):be_memo_pair_T<val_T, _memo_T, ctx_T>
+):be_memo_pair_T<_memo_T, ctx_T>
 export type be_memo_pair_T<
-	val_T,
-	_memo_T extends memo_T<val_T> = memo_T<val_T>,
+	_memo_T extends memo_T<unknown> = memo_T<unknown>,
 	ctx_T extends Ctx = Ctx
 > = [
 	Be<_memo_T, ctx_T>,
-	(ctx:ctx_T)=>val_T
+	(ctx:ctx_T)=>rmemo_val_T<_memo_T>
 ]

package/all/be_sig_triple/index.d.ts

@@ -1,10 +1,10 @@
 import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
-import type { sig_T, rmemo_def_T } from '../rmemo/index.js'
+import type { sig_T, rmemo_def_T, rmemo_val_T } from '../rmemo/index.js'
 export declare function be_sig_triple_<
 	val_T,
 	_sig_T extends sig_T<val_T> = sig_T<val_T>,
 	ctx_T extends Ctx = Ctx
->(be: Be<_sig_T, ctx_T>):be_sig_triple_T<val_T, _sig_T, ctx_T>
+>(be: Be<_sig_T, ctx_T>):be_sig_triple_T<_sig_T, ctx_T>
 export declare function be_sig_triple_<
 	val_T,
 	_sig_T extends sig_T<val_T> = sig_T<val_T>,
@@ -14,13 +14,12 @@ export declare function be_sig_triple_<
 	...subscriber_a_THEN_config:
 		|[...rmemo_def_T<val_T>[]]
 		|[...rmemo_def_T<val_T>[], config:be_config_T]
-):be_sig_triple_T<val_T, _sig_T, ctx_T>
+):be_sig_triple_T<_sig_T, ctx_T>
 export type be_sig_triple_T<
-	val_T,
-	_sig_T extends sig_T<val_T> = sig_T<val_T>,
+	_sig_T extends sig_T<unknown> = sig_T<unknown>,
 	ctx_T extends Ctx = Ctx
 > = [
 	Be<_sig_T>,
-	(ctx:ctx_T)=>val_T,
-	(ctx:ctx_T, val:val_T)=>void
+	(ctx:ctx_T)=>rmemo_val_T<_sig_T>,
+	(ctx:ctx_T, val:rmemo_val_T<_sig_T>)=>void
 ]

package/all/rmemo/index.d.ts

@@ -14,17 +14,17 @@ export type rmemo_T<val_T> = memo_T<val_T>|sig_T<val_T>
 export type memo_T<val_T> = (()=>val_T)&{
 	readonly _:val_T
 	readonly val:val_T
-	rmr:WeakRef<()=>val_T>
-	rmrs:WeakRef<()=>val_T>[]
+	r?:WeakRef<()=>val_T>
+	memor:WeakRef<()=>val_T>[]
 }
 export type sig_T<val_T> = (()=>val_T)&{
 	_:val_T
 	readonly val:val_T
-	rmr:WeakRef<()=>val_T>
-	rmrs:WeakRef<()=>val_T>[]
+	r?:WeakRef<()=>val_T>
+	memor:WeakRef<()=>val_T>[]
 }
 export type rmemo_val_T<sig_T> = sig_T extends { ():infer val_T }
 	? val_T
 	: unknown
-export type rmemo_def_T<val_T> = (rw_rmemo:sig_T<val_T>)=>val_T
-export type rmemo_subscriber_T<val_T> = (rw_rmemo:sig_T<val_T>)=>unknown
+export type rmemo_def_T<val_T> = (sig:sig_T<val_T>)=>val_T
+export type rmemo_subscriber_T<val_T> = (sig:sig_T<val_T>)=>unknown

package/all/rmemo/index.js

@@ -3,7 +3,7 @@
 /** @typedef {import('./index.d.ts').rmemo_subscriber_T} */
 /** @typedef {import('./index.d.ts').sig_T} */
 /** @type {WeakRef<memo_T>} */
-let cur_rmr
+let cur_memo
 /** @type {Set<()=>unknown>} */
 let queue = new Set
 /**
@@ -13,41 +13,41 @@ let queue = new Set
  * @private
  */
 export function memo_(rmemo_def, ...subscriber_a) {
-	let refresh
-	let rmrs
+	let memor
 	let memo = ()=>{
 		if (!('val' in memo)) {
-			refresh()
+			memo.f()
 		}
-		if (cur_rmr) {
-			let cur_rmr_refresh = cur_rmr.deref()
-			~rmrs.indexOf(cur_rmr) || rmrs.push(cur_rmr)
-			cur_rmr_refresh.l < refresh.l + 1 && (cur_rmr_refresh.l = refresh.l + 1)
-			// conditional in rmr calls this r_memo
-			cur_rmr_refresh.s.push(memo)
-			// prevent this rmemo from GC while cur_rmr is still active
-			~cur_rmr_refresh.S.indexOf(memo) || cur_rmr_refresh.S.push(memo)
+		if (cur_memo) {
+			if (!~memor.indexOf(cur_memo.r ||= new WeakRef(cur_memo.f))) memor.push(cur_memo.r)
+			if (cur_memo.f.l < memo.f.l + 1) cur_memo.f.l = memo.f.l + 1
+			// conditional in r calls this r_memo
+			cur_memo.f.s.push(memo)
+			// prevent this rmemo from GC while cur_memo is still active
+			if (!~cur_memo.f.S.indexOf(memo)) cur_memo.f.S.push(memo)
 		}
 		return memo.val
 	}
 	Object.defineProperty(memo, '_', {
 		get: memo,
 		set: val=>{
-			if (memo.val !== val) {
-				memo.val = val // val is available for other purposes
+			let i = memo.val
+			memo.val = val
+			if (i !== val) {
+				// val is available for other purposes
 				let run_queue = !queue.size
-				let i = 0
-				for (let rmr of rmrs) {
-					val = rmr.deref() // val is no longer used...saving bytes
+				i = 0
+				for (let r of memor) {
+					val = r.deref() // val is no longer used...saving bytes
 					if (!val) {
-						rmrs.splice(i, 1)
-					} else if (~val.s.indexOf(memo)) { // if conditional rmr refresh calls this r_memo, add to queue
+						memor.splice(i, 1)
+					} else if (~val.s.indexOf(memo)) { // if conditional r refresh calls this r_memo, add to queue
 						queue.add(val)
 					}
 					i++
 				}
 				// add reference to subscribers to prevent GC
-				memo._s ||=
+				memo.b ||=
 					subscriber_a.map(subscriber=>
 						memo_(subscriber$=>(
 							subscriber(memo),
@@ -68,24 +68,21 @@ export function memo_(rmemo_def, ...subscriber_a) {
 			}
 		},
 	})
-	refresh = ()=>{
-		let prev_rmr = cur_rmr
-		cur_rmr = memo.rmr
-		refresh.s = []
+	memo.f = ()=>{
+		let prev_memo = cur_memo
+		cur_memo = memo
+		memo.f.s = []
 		try {
 			memo._ = rmemo_def(memo)
 		} catch (err) {
 			console.error(err)
 		}
-		cur_rmr = prev_rmr // finally is not necessary...catch does not throw
+		cur_memo = prev_memo // finally is not necessary...catch does not throw
 	}
-	refresh.l = 0
-	// rmrs = new Set
-	// memo.rmrs is kept for GC testing/debugging purposes...small size increase
-	memo.rmrs = rmrs = []
-	memo.rmr = new WeakRef(refresh)
-	refresh.s = []
-	refresh.S = []
+	memo.f.l = 0
+	memo.f.s = []
+	memo.f.S = []
+	memo.memor = memor = []
 	return memo
 }
 export { memo_ as memosig_ }
@@ -96,9 +93,9 @@ export { memo_ as memosig_ }
  * @private
  */
 export function sig_(init_val, ...subscriber_a) {
-	return memo_(rw_rmemo=>
-		'val' in rw_rmemo
-			? rw_rmemo.val
+	return memo_(sig=>
+		'val' in sig
+			? sig.val
 			: init_val,
 	...subscriber_a)
 }

package/all/rmemo/index.test.ts

@@ -7,28 +7,28 @@ import { sleep } from '../sleep/index.js'
 import { memo_, type memo_T, memosig_, sig_ } from './index.js'
 test('memo_|static value', ()=>{
 	let count = 0
-	const r_rmemo = memo_(()=>{
+	const memo = memo_(()=>{
 		count++
 		return 'rmemo-value'
 	})
 	equal(count, 0)
-	equal(r_rmemo(), 'rmemo-value')
+	equal(memo(), 'rmemo-value')
 	equal(count, 1)
-	equal(r_rmemo(), 'rmemo-value')
+	equal(memo(), 'rmemo-value')
 	equal(count, 1)
 })
 test('memo_|def function|rmemo argument', ()=>{
-	const rw_rmemo = sig_('val0')
-	const r_rmemo:memo_T<string>&{ custom?:string } = memo_<string>((_rmemo$:memo_T<string>&{ custom?:string })=>
-		`${_rmemo$.custom}-${rw_rmemo()}`)
-	r_rmemo.custom = 'custom_val0'
-	equal(r_rmemo(), 'custom_val0-val0')
-	r_rmemo.custom = 'custom_val1'
-	equal(r_rmemo(), 'custom_val0-val0')
-	rw_rmemo._ = 'val1'
-	equal(r_rmemo(), 'custom_val1-val1')
+	const sig = sig_('val0')
+	const memo:memo_T<string>&{ custom?:string } = memo_<string>((_rmemo$:memo_T<string>&{ custom?:string })=>
+		`${_rmemo$.custom}-${sig()}`)
+	memo.custom = 'custom_val0'
+	equal(memo(), 'custom_val0-val0')
+	memo.custom = 'custom_val1'
+	equal(memo(), 'custom_val0-val0')
+	sig._ = 'val1'
+	equal(memo(), 'custom_val1-val1')
 })
-test('r_memo_|side effect', ()=>{
+test('memo_|side effect', ()=>{
 	const history:string[] = []
 	const s = sig_('This')
 	memo_(()=>history.push(s()))()
@@ -38,6 +38,18 @@ test('r_memo_|side effect', ()=>{
 	s._ = 'test'
 	equal(history, ['This', 'is', 'a', 'test'])
 })
+test('memo_|undefined', ()=>{
+	let count = 0
+	const memo = memo_(()=>{
+		count++
+		return undefined
+	})
+	equal(count, 0)
+	equal(memo(), undefined)
+	equal(count, 1)
+	equal(memo(), undefined)
+	equal(count, 1)
+})
 test('memo_|conditional', ()=>{
 	const cond$ = sig_(true)
 	const a$ = sig_(1)
@@ -125,16 +137,16 @@ test('memo_|error|case 2', ()=>{
 	equal(r3(), 9)
 })
 test('sig_', ()=>{
-	const rw_rmemo = sig_('val0')
-	equal(rw_rmemo(), 'val0')
-	rw_rmemo._ = 'val1'
-	equal(rw_rmemo(), 'val1')
+	const sig = sig_('val0')
+	equal(sig(), 'val0')
+	sig._ = 'val1'
+	equal(sig(), 'val1')
 })
 test('sig_|undefined', ()=>{
-	const rw_rmemo = sig_(undefined)
-	const r_rmemo = memo_(()=>rw_rmemo())
-	equal(rw_rmemo(), undefined)
-	equal(r_rmemo(), undefined)
+	const sig = sig_(undefined)
+	const memo = memo_(()=>sig())
+	equal(sig(), undefined)
+	equal(memo(), undefined)
 })
 test('sig_|async subsubscriber|case 1', async ()=>{
 	let resolve:(user:{ id:string })=>void

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "4.5.0",
+  "version": "4.6.1",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -150,28 +150,28 @@
       "import": {
         "./rmemo": "{ memo_ }"
       },
-      "limit": "343 B"
+      "limit": "344 B"
     },
     {
       "name": "memo_ sig_",
       "import": {
         "./rmemo": "{ sig_, memo_ }"
       },
-      "limit": "366 B"
+      "limit": "359 B"
     },
     {
       "name": "memo_ sig_ be_ ctx_",
       "import": {
         "./rmemo": "{ sig_, memo_, be_, ctx_ }"
       },
-      "limit": "522 B"
+      "limit": "519 B"
     },
     {
       "name": "memo_ sig_ be_ ctx_ be_memo_pair_ be_sig_triple_",
       "import": {
         "./rmemo": "{ sig_, memo_, be_, ctx_, be_memo_pair_, be_sig_triple_ }"
       },
-      "limit": "609 B"
+      "limit": "602 B"
     }
   ],
   "scripts": {