ctx-core 5.16.1 → 5.16.2

package/all/rmemo/index.d.ts

@@ -5,26 +5,37 @@ export declare function memosig_<val_T>(def:memo_def_T<val_T>):sig_T<val_T>
 export declare function lock_memosig_<val_T>(def:memo_def_T<val_T>):sig_T<val_T>
 export declare function rmemo__on(rmemo:rmemo_T<unknown>):void
 export declare function rmemo__off(rmemo:rmemo_T<unknown>):void
-export declare function rmemo__add(rmemo:rmemo_T<unknown>, listener:()=>unknown):()=>void
+export declare function rmemo__add<val_T, listener_val_T>(
+	rmemo:rmemo_T<val_T>,
+	listener:(sig:sig_T<val_T>, prev_val:listener_val_T|undefined)=>listener_val_T
+):()=>void
 export type rmemo_T<val_T> = memo_T<val_T>|sig_T<val_T>|lock_memosig_T<val_T>
 export type circular_rmemo_T = circular_memo_T|circular_sig_T|circular_lock_memosig_T
 export type memo_T<val_T> = (()=>val_T)&{
 	readonly _:val_T
+	readonly a?:rmemo_a_T[]
+	readonly f?:rmemo_f_T
+	readonly memor:rmemo_r_T[]
+	readonly r?:rmemo_r_T
 	readonly val:val_T
-	r?:WeakRef<()=>val_T>
-	memor:WeakRef<()=>val_T>[]
-	a?:rmemo_a_T[]
-	add<add_val_T>(add_def:(sig:sig_T<val_T>, prev_val:add_val_T|undefined)=>add_val_T):memo_T<val_T>
+	add<add_val_T>(add_def:rmemo_add_def_T<val_T, add_val_T>):memo_T<val_T>
+	memo_<_val_T>(def:memo_def_T<_val_T>):memo_T<_val_T>
 }
 export interface circular_memo_T extends memo_T<circular_memo_T> {
 }
 export type sig_T<val_T> = (()=>val_T)&{
 	_:val_T
+	readonly a?:rmemo_a_T[]
+	readonly f?:(()=>void)&{
+		readonly l:number
+		readonly s:rmemo_T<unknown>[]
+		readonly S:rmemo_T<unknown>[]
+	}
+	readonly memor:rmemo_r_T[]
+	readonly r?:rmemo_r_T
 	readonly val:val_T
-	r?:WeakRef<()=>val_T>
-	memor:WeakRef<()=>val_T>[]
-	a?:rmemo_a_T[]
-	add<add_val_T>(fn:(sig:sig_T<val_T>, prev_val:add_val_T|undefined)=>add_val_T):sig_T<val_T>
+	add<add_val_T>(fn:rmemo_add_def_T<val_T, add_val_T>):sig_T<val_T>
+	memo_<_val_T>(def:memo_def_T<_val_T>):memo_T<_val_T>
 }
 export interface circular_sig_T extends sig_T<circular_sig_T> {
 }
@@ -39,3 +50,10 @@ export type rmemo_val_T<sig_T> = sig_T extends { ():infer val_T }
 export type memo_def_T<val_T> = (sig:sig_T<val_T>)=>val_T
 export type rmemo_a_T = [memo_T<unknown>, unknown]
 export type rmemo_add_T<val_T, SV> = (sig:sig_T<val_T>, old_val:SV|undefined)=>SV
+export type rmemo_add_def_T<val_T, add_val_T> = (sig:sig_T<val_T>, prev_val:add_val_T|undefined)=>add_val_T
+export type rmemo_f_T = (()=>void)&{
+	readonly l:number
+	readonly s:rmemo_T<unknown>[]
+	readonly S:rmemo_T<unknown>[]
+}
+export type rmemo_r_T = WeakRef<rmemo_f_T>&{ readonly d?: ()=>rmemo_f_T }

package/all/rmemo/index.js

@@ -1,21 +1,26 @@
 /// <reference types="./index.d.ts" />
-/** @type {WeakRef<memo_T>} */
+/** @type {memo_T} */
 let cur_memo
-/** @type {Set<()=>unknown>} */
+/** @type {Set<(()=>unknown)&{ l:number }>} */
 let queue = new Set
 /**
  * @param {memo_def_T}memo_def
- * @param {rmemo_add_T<unknown>[]}add_def_a
+ * @param {rmemo_add_def_T}add_def_a
  * @returns {memo_T}
  * @private
  */
 export function memo_(memo_def, ...add_def_a) {
+	/** @type {memo_T} */
 	let memo = ()=>{
 		if (!('val' in memo)) {
 			memo.f()
 		}
 		if (cur_memo) {
-			if (!memo.memor.includes(cur_memo.r ||= new WeakRef(cur_memo.f))) memo.memor.push(cur_memo.r)
+			if (!memo.memor.includes(
+				cur_memo.r ||= new WeakRef(cur_memo.f)
+			)) {
+				memo.memor.push(cur_memo.r)
+			}
 			if (cur_memo.f.l < memo.f.l + 1) cur_memo.f.l = memo.f.l + 1
 			// memo is called by cur_memo's conditional execution...next change to memo will notify cur_memo
 			cur_memo.f.s.push(memo)
@@ -53,6 +58,10 @@ export function memo_(memo_def, ...add_def_a) {
 			}
 		},
 	})
+	/**
+	 * @param {rmemo_add_def_T}add_def
+	 * @returns {memo_T}
+	 */
 	memo.add = add_def=>{
 		if (memo.a) {
 			let pair = [memo_(()=>pair[1] = add_def(memo, pair[1]))]
@@ -78,20 +87,21 @@ export function memo_(memo_def, ...add_def_a) {
 	memo.f.s = []
 	memo.f.S = []
 	memo.memor = []
+	// memo.memo_ = memo_
 	return memo
 }
 export { memo_ as memosig_ }
 /**
  * @param {memo_def_T}memo_def
- * @param {rmemo_add_T<unknown>[]}subscriber_a
+ * @param {rmemo_add_def_T}add_def_a
  * @returns {sig_T}
  * @private
  */
-export function lock_memosig_(memo_def, ...subscriber_a) {
+export function lock_memosig_(memo_def, ...add_def_a) {
 	let lock_memosig = new Proxy(
 		/** @type {sig_T} */memo_(memo=>
 			memo.lock ? memo._ : memo_def(memo),
-		...subscriber_a),
+		...add_def_a),
 		{
 			get(memo, prop) {
 				if (prop === 'add') {
@@ -114,16 +124,16 @@ export function lock_memosig_(memo_def, ...subscriber_a) {
 }
 /**
  * @param {unknown}init_val
- * @param {rmemo_add_T[]}add_a
+ * @param {rmemo_add_def_T}add_def_a
  * @returns {sig_T}
  * @private
  */
-export function sig_(init_val, ...add_a) {
+export function sig_(init_val, ...add_def_a) {
 	return memo_(sig=>
 		'val' in sig
 			? sig.val
 			: init_val,
-	...add_a)
+	...add_def_a)
 }
 /**
  * Call the rmemo & enable updates from it's parents.
@@ -151,14 +161,14 @@ export function rmemo__off(rmemo) {
  * The add_def can autosubscribe to any rmemo.
  * Returns an "off" function which deactivates the reactive add_def & removes the GC binding from the given memo.
  * @param {rmemo_T}memo
- * @param {()=>unknown}add_def
+ * @param {rmemo_add_def_T}add_def
  * @returns {()=>void}
  */
 export function rmemo__add(memo, add_def) {
 	let pair
-	memo.add(()=>{
+	memo.add((...arg_a)=>{
 		pair = memo.a[memo.a.length - 1]
-		return add_def(memo)
+		return add_def(...arg_a)
 	})
 	return ()=>{
 		rmemo__off(pair[0])

package/all/rmemo/index.test.ts

@@ -4,7 +4,7 @@ import { deepStrictEqual } from 'node:assert'
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { sleep } from '../sleep/index.js'
-import { lock_memosig_, memo_, type memo_T, memosig_, rmemo__off, rmemo__on, rmemo__add, sig_ } from './index.js'
+import { lock_memosig_, memo_, type memo_T, memosig_, rmemo__off, rmemo__on, rmemo__add, sig_, sig_T } from './index.js'
 test('memo_|static value', ()=>{
 	let count = 0
 	const memo = memo_(()=>{
@@ -471,23 +471,18 @@ test('.rmemo__on + .rmemo__off', ()=>{
 })
 test('rmemo__add', ()=>{
 	const base$ = sig_(1)
-	let count = 0
-	const subscriber_base_a:number[] = []
-	const off = rmemo__add(base$, ()=>{
-		count++
-		subscriber_base_a.push(base$())
+	const add_arg_aa_val_aaa:[[sig_T<number>, string|undefined], number][] = []
+	const off = rmemo__add<number, string>(base$, (...arg_a)=>{
+		add_arg_aa_val_aaa.push([arg_a, arg_a[0]()])
+		return 'val-'+arg_a[0]()
 	})
-	equal(subscriber_base_a, [])
-	equal(count, 0)
+	equal(add_arg_aa_val_aaa, [])
 	base$()
-	equal(subscriber_base_a, [1])
-	equal(count, 1)
+	equal(add_arg_aa_val_aaa, [[[base$, undefined], 1]])
 	base$._ = 2
-	equal(subscriber_base_a, [1, 2])
-	equal(count, 2)
+	equal(add_arg_aa_val_aaa, [[[base$, undefined], 1], [[base$, 'val-1'], 2]])
 	off()
 	base$._ = 3
-	equal(subscriber_base_a, [1, 2])
-	equal(count, 2)
+	equal(add_arg_aa_val_aaa, [[[base$, undefined], 1], [[base$, 'val-1'], 2]])
 })
 test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ctx-core",
-	"version": "5.16.1",
+	"version": "5.16.2",
 	"description": "ctx-core core library",
 	"keywords": [
 		"ctx-core",
@@ -145,8 +145,8 @@
 		"@arethetypeswrong/cli": "^0.13.5",
 		"@ctx-core/preprocess": "^0.1.0",
 		"@size-limit/preset-small-lib": "^11.0.1",
-		"@types/node": "^20.10.7",
-		"@types/sinon": "^17.0.2",
+		"@types/node": "^20.10.8",
+		"@types/sinon": "^17.0.3",
 		"c8": "^9.0.0",
 		"check-dts": "^0.7.2",
 		"esbuild": "^0.19.11",
@@ -248,4 +248,4 @@
 			"limit": "116 B"
 		}
 	]
-}
+}