ctx-core 4.8.2 → 4.9.1

package/all/be_memo_pair/index.d.ts

@@ -1,16 +1,16 @@
-import type { Be, be__val__new_T, be_config_T, Ctx } from '../be_/index.js'
+import type { Be, be_config_T, Ctx } from '../be_/index.js'
 import type { memo_T, sig_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<val_T, _memo_T, ctx_T>
 export declare function be_memo_pair_<
 	val_T,
 	_memo_T extends memo_T<val_T> = memo_T<val_T>,
 	ctx_T extends Ctx = Ctx
 >(
-	rmemo__new:be__val__new_T<val_T>,
+	rmemo__new:(ctx:Ctx, memo:_memo_T&{ _:val_T })=>val_T,
 	...subscriber_a_THEN_config:
 		|[...((ctx:Ctx, memosig:sig_T<val_T>)=>unknown)[]]
 		|[...((ctx:Ctx, memosig:sig_T<val_T>)=>unknown)[], config:be_config_T]

package/all/be_memo_pair/index.js

@@ -1,10 +1,8 @@
+/// <reference types="../be_/index.d.ts" />
+/// <reference types="../rmemo/index.d.ts" />
+/// <reference types="./index.d.ts" />
 import { be_ } from '../be_/index.js'
 import { memo_ } from '../rmemo/index.js'
-/** @typedef {import('../be_/index.d.ts').Be} */
-/** @typedef {import('../be_/index.d.ts').be__val__new_T} */
-/** @typedef {import('../be_/index.d.ts').be_config_T} */
-/** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
-/** @typedef {import('./index.d.ts').be_memo_pair_T} */
 /**
  * @param {Be|be__val__new_T<unknown>}be_OR_val__new
  * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
@@ -18,14 +16,14 @@ export function be_memo_pair_(
 	let config =
 		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
 			? subscriber_a_THEN_config.pop()
-			: undefined
+			: 0
 	/** @type {Be} */
 	let be =
 		be_OR_val__new.is_be
 			? be_OR_val__new
 			: be_(ctx=>
 				memo_(
-					()=>be_OR_val__new(ctx),
+					memo=>be_OR_val__new(ctx, memo),
 					...subscriber_a_THEN_config.map(subscriber=>
 						memo=>subscriber(ctx, memo))),
 			config)

package/all/be_memo_pair/index.test.ts

@@ -15,13 +15,20 @@ test('be_memo_pair_', ()=>{
 	const [
 		foobar$_,
 		foobar_,
-	] = be_memo_pair_(ctx=>base_(ctx) + 1)
+	] = be_memo_pair_<number, sig_T<number>&{ count:number }>((_ctx, foobar$)=>{
+		equal(_ctx, ctx)
+		foobar$.count = (foobar$.count ||= 0) + 1
+		return base_(ctx) + 1
+	})
 	const ctx = ctx__new()
+	equal(foobar$_(ctx).count, undefined)
 	equal(foobar$_(ctx)._, 2)
 	equal(foobar_(ctx), 2)
+	equal(foobar$_(ctx).count, 1)
 	base__set(ctx, 2)
 	equal(foobar$_(ctx)._, 3)
 	equal(foobar_(ctx), 3)
+	equal(foobar$_(ctx).count, 2)
 })
 test('be_memo_pair_|+id|+is_source_|+oninit|+subscriber_a', ()=>{
 	const ctx = ctx__new()

package/all/be_memosig_triple/index.d.ts

@@ -0,0 +1,26 @@
+import type { Be, be_config_T, Ctx } from '../be_/index.js'
+import type { rmemo_val_T, sig_T } from '../rmemo/index.js'
+export declare function be_memosig_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_memosig_triple_T<val_T, _sig_T, ctx_T>
+export declare function be_memosig_triple_<
+	val_T,
+	_sig_T extends sig_T<val_T> = sig_T<val_T>,
+	ctx_T extends Ctx = Ctx
+>(
+	rmemo__new:(ctx:Ctx, memosig:_sig_T)=>val_T,
+	...subscriber_a_THEN_config:
+		|[...((ctx:Ctx, sig:_sig_T)=>unknown)[]]
+		|[...((ctx:Ctx, sig:_sig_T)=>unknown)[], config:be_config_T]
+):be_memosig_triple_T<val_T, _sig_T, ctx_T>
+export type be_memosig_triple_T<
+	val_T,
+	_sig_T extends sig_T<val_T> = sig_T<val_T>,
+	ctx_T extends Ctx = Ctx
+> = [
+	Be<_sig_T>,
+	(ctx:ctx_T)=>val_T,
+	(ctx:ctx_T, val:rmemo_val_T<_sig_T>)=>void
+]

package/all/be_memosig_triple/index.js

@@ -0,0 +1,21 @@
+/// <reference types="../be_/index.d.ts" />
+/// <reference types="../be_sig_triple/index.d.ts" />
+/// <reference types="../rmemo/index.d.ts" />
+/// <reference types="./index.d.ts" />
+import { be_memo_pair_ } from '../be_memo_pair'
+/**
+ * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new
+ * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
+ * @returns {be_memosig_triple_T}
+ * @private
+ */
+export function be_memosig_triple_(...arg_a) {
+	/** @type {be_sig_triple_T} */
+	let memo_pair = be_memo_pair_(...arg_a)
+	return [
+		...memo_pair,
+		(ctx, val)=>{
+			memo_pair[0](ctx)._ = val
+		},
+	]
+}

package/all/be_memosig_triple/index.test.ts

@@ -0,0 +1,144 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { be_ } from '../be_/index.js'
+import { be_sig_triple_ } from '../be_sig_triple/index.js'
+import { ctx__new } from '../ctx/index.js'
+import { memosig_, type sig_T } from '../rmemo/index.js'
+import { be_memosig_triple_ } from './index.js'
+test('be_memosig_triple_', ()=>{
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(()=>1)
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = be_memosig_triple_<number, sig_T<number>&{
+		count:number
+	}>((_ctx, foobar$)=>{
+		equal(_ctx, ctx)
+		foobar$.count = (foobar$.count ||= 0) + 1
+		return base_(ctx) + 1
+	})
+	const ctx = ctx__new()
+	equal(foobar$_(ctx).count, undefined)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(foobar$_(ctx).count, 1)
+	foobar__set(ctx, 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(foobar$_(ctx).count, 1)
+	base__set(ctx, 2)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal(foobar$_(ctx).count, 2)
+})
+test('be_memosig_triple_|+id|+is_source_', ()=>{
+	const ctx = ctx__new()
+	let subscriber_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(
+		()=>1,
+		{ is_source_: map_ctx=>map_ctx === ctx })
+	const [
+		,
+		subscriber_dep_,
+		subscriber_dep__set
+	] = be_sig_triple_(()=>1,
+		{ is_source_: map_ctx=>map_ctx === ctx })
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = be_memosig_triple_(
+		ctx=>
+			base_(ctx) + 1,
+		(ctx, foobar$)=>{
+			subscriber_count++
+			subscriber_dep__set(ctx, subscriber_count + foobar$())
+		},
+		{ id: 'foobar', is_source_: map_ctx=>map_ctx === ctx })
+	equal(subscriber_count, 0)
+	equal(foobar$_([ctx__new(), ctx])._, 2)
+	equal(foobar_([ctx__new(), ctx]), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(subscriber_count, 1)
+	equal((ctx.get('foobar') as sig_T<number>)._, 2)
+	equal(subscriber_dep_(ctx), 3)
+	foobar__set([ctx__new(), ctx], 5)
+	equal(foobar$_([ctx__new(), ctx])._, 5)
+	equal(foobar_([ctx__new(), ctx]), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal((ctx.get('foobar') as sig_T<number>)._, 5)
+	equal(subscriber_count, 2)
+	equal(subscriber_dep_(ctx), 7)
+	base__set(ctx, 2)
+	equal(foobar$_([ctx__new(), ctx])._, 3)
+	equal(foobar_([ctx__new(), ctx]), 3)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal(subscriber_count, 3)
+	equal((ctx.get('foobar') as sig_T<number>)._, 3)
+	equal(subscriber_dep_(ctx), 6)
+})
+test('be_memosig_triple_|+be', ()=>{
+	const ctx = ctx__new()
+	let subscriber_count = 0
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(()=>1,
+		{ is_source_: map_ctx=>map_ctx === ctx })
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = be_memosig_triple_<number, custom_sig_T>(
+		be_(ctx=>{
+			const foobar$ =
+				memosig_(()=>base_(ctx) + 1,
+					foobar$=>{
+						foobar$()
+						subscriber_count++
+					}) as custom_sig_T
+			foobar$.custom = 'custom-val'
+			return foobar$
+		}, { id: 'foobar', is_source_: map_ctx=>map_ctx === ctx }))
+	equal(subscriber_count, 0)
+	equal(foobar$_([ctx__new(), ctx])._, 2)
+	equal(foobar_([ctx__new(), ctx]), 2)
+	equal(foobar$_(ctx)._, 2)
+	equal(foobar_(ctx), 2)
+	equal(subscriber_count, 1)
+	equal((ctx.get('foobar') as sig_T<number>)._, 2)
+	equal(foobar$_(ctx).custom, 'custom-val')
+	foobar__set(ctx, 5)
+	equal(foobar$_([ctx__new(), ctx])._, 5)
+	equal(foobar_([ctx__new(), ctx]), 5)
+	equal(foobar$_(ctx)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(subscriber_count, 2)
+	equal((ctx.get('foobar') as sig_T<number>)._, 5)
+	equal(foobar$_(ctx).custom, 'custom-val')
+	base__set([ctx__new(), ctx], 2)
+	equal(foobar$_([ctx__new(), ctx])._, 3)
+	equal(foobar_([ctx__new(), ctx]), 3)
+	equal(foobar$_(ctx)._, 3)
+	equal(foobar_(ctx), 3)
+	equal((ctx.get('foobar') as sig_T<number>)._, 3)
+	equal(foobar$_(ctx).custom, 'custom-val')
+	equal(subscriber_count, 3)
+})
+test.run()
+type custom_sig_T = sig_T<number>&{
+	custom:string
+}

package/all/be_sig_triple/index.d.ts

@@ -10,7 +10,7 @@ export declare function be_sig_triple_<
 	_sig_T extends sig_T<val_T> = sig_T<val_T>,
 	ctx_T extends Ctx = Ctx
 >(
-	val__new:(ctx:Ctx, sig:_sig_T)=>val_T,
+	val__new:(ctx:Ctx)=>val_T,
 	...subscriber_a_THEN_config:
 		|[...((ctx:Ctx, sig:_sig_T)=>unknown)[]]
 		|[...((ctx:Ctx, sig:_sig_T)=>unknown)[], config:be_config_T]

package/all/be_sig_triple/index.js

@@ -1,11 +1,8 @@
+/// <reference types="../be_/index.d.ts" />
+/// <reference types="../rmemo/index.d.ts" />
+/// <reference types="./index.d.ts" />
 import { be_ } from '../be_/index.js'
 import { sig_ } from '../rmemo/index.js'
-/** @typedef {import('../be_/index.d.ts').Be} */
-/** @typedef {import('../be_/index.d.ts').be__val__new_T} */
-/** @typedef {import('../be_/index.d.ts').be_config_T} */
-/** @typedef {import('../rmemo/index.d.ts').sig_T} */
-/** @typedef {import('../rmemo/index.d.ts').rmemo_subscriber_T} */
-/** @typedef {import('./index.d.ts').be_sig_triple_T} */
 /**
  * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new
  * @param {rmemo_subscriber_T[]|[...rmemo_subscriber_T[], be_config_T]}subscriber_a_THEN_config
@@ -19,7 +16,7 @@ export function be_sig_triple_(
 	let config =
 		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
 			? subscriber_a_THEN_config.pop()
-			: undefined
+			: 0
 	/** @type {Be<sig_T>} */
 	let be =
 		be_OR_val__new.is_be

package/all/be_sig_triple/index.test.ts

@@ -9,7 +9,10 @@ test('be_sig_triple_', ()=>{
 		foobar$_,
 		foobar_,
 		foobar__set,
-	] = be_sig_triple_(()=>1)
+	] = be_sig_triple_(_ctx=>{
+		equal(_ctx, ctx)
+		return 1
+	})
 	const ctx = ctx__new()
 	equal(foobar$_(ctx)._, 1)
 	equal(foobar_(ctx), 1)

package/all/rmemo/index.d.ts

@@ -10,6 +10,7 @@ export declare function memosig_<val_T>(
 	def:rmemo_def_T<val_T>,
 	...subscriber_a:rmemo_subscriber_T<val_T>[]
 ):sig_T<val_T>
+// TODO: lock_memosig_
 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

package/all/rmemo/index.js

@@ -1,7 +1,4 @@
-/** @typedef {import('./index.d.ts').rmemo_def_T} */
-/** @typedef {import('./index.d.ts').memo_T} */
-/** @typedef {import('./index.d.ts').rmemo_subscriber_T} */
-/** @typedef {import('./index.d.ts').sig_T} */
+/// <reference types="./index.d.ts" />
 /** @type {WeakRef<memo_T>} */
 let cur_memo
 /** @type {Set<()=>unknown>} */
@@ -30,30 +27,36 @@ export function memo_(rmemo_def, ...subscriber_a) {
 	Object.defineProperty(memo, '_', {
 		get: memo,
 		set: val=>{
-			let i = memo.val
-			memo.val = val
-			if (i !== val) {
-				// val is available for other purposes
-				let run_queue = !queue.size
+			let run_queue
+			if (memo.val !== val) {
+				run_queue = !queue.size
 				memo.memor = memo.memor.filter(r=>{
-					// val is no longer used...saving bytes
-					val = r.deref() // val is no longer used...saving bytes
-					if (val && ~val.s.indexOf(memo)) { // if conditional r refresh calls this r_memo, add to queue
-						queue.add(val)
+					r = r.deref()
+					if (r && ~r.s.indexOf(memo)) { // if conditional r refresh calls this r_memo, add to queue
+						queue.add(r)
 					}
-					return val
+					return r
 				})
-				if (run_queue) {
-					cur_refresh_loop:for (let cur_refresh of queue) {
-						queue.delete(cur_refresh)
-						for (let queue_refresh of queue) {
-							if (cur_refresh.l > queue_refresh.l) {
-								queue.add(cur_refresh)
-								continue cur_refresh_loop
-							}
+			}
+			memo.val = val
+			if (!memo.b) {
+				// add reference to subscribers to prevent GC
+				memo.b = subscriber_a.map(subscriber=>
+					memo_(()=>subscriber(memo)))
+				for (let s of memo.b) {
+					s()
+				}
+			}
+			if (run_queue) {
+				cur_refresh_loop:for (let cur_refresh of queue) {
+					queue.delete(cur_refresh)
+					for (let queue_refresh of queue) {
+						if (cur_refresh.l > queue_refresh.l) {
+							queue.add(cur_refresh)
+							continue cur_refresh_loop
 						}
-						cur_refresh()
 					}
+					cur_refresh()
 				}
 			}
 		},
@@ -68,13 +71,6 @@ export function memo_(rmemo_def, ...subscriber_a) {
 			console.error(err)
 		}
 		cur_memo = prev_memo // finally is not necessary...catch does not throw
-		// add reference to subscribers to prevent GC
-		memo.b ||=
-			subscriber_a.map(subscriber=>
-				memo_(subscriber$=>(
-					subscriber(memo),
-					subscriber$
-				))())
 	}
 	memo.f.l = 0
 	memo.f.s = []
@@ -97,3 +93,4 @@ export function sig_(init_val, ...subscriber_a) {
 	},
 	...subscriber_a)
 }
+// TODO: lock_memosig_

package/all/rmemo/index.test.ts

@@ -153,12 +153,30 @@ test('sig_|undefined', ()=>{
 	equal(sig(), undefined)
 	equal(memo(), undefined)
 })
+test('sig_|subscriber|notified if sig is set before read', ()=>{
+	let count = 0
+	let subscriber__num:number|undefined = undefined
+	const num$ = sig_<number|undefined>(
+		undefined,
+		num$=>{
+			count++
+			subscriber__num = num$()
+		})
+	equal(count, 0)
+	equal(subscriber__num, undefined)
+	num$._ = 1
+	equal(count, 1)
+	equal(subscriber__num, 1)
+	num$()
+	equal(count, 1)
+	equal(subscriber__num, 1)
+})
 test('sig_|subscriber|sets sig', ()=>{
 	const base$ = sig_(0)
 	let count = 0
 	const num$ = sig_(
 		0,
-		async (num$)=>{
+		async num$=>{
 			count++
 			num$._ = base$() + 1
 		})

package/all/weak_r/index.js

@@ -3,6 +3,7 @@ import { assign } from '../assign/index.js'
 const { get } = Reflect
 const add_strong_sym = Symbol('add_strong')
 const delete_strong_sym = Symbol('delete_strong')
+let _undefined
 /**
  * @param {object}[back_o]
  * @returns {object}
@@ -24,12 +25,16 @@ export function weak_r_(back_o = {}) {
 			if ((value === null || value === void 0 ? void 0 : value.deref) && !strong_set.has(prop)) {
 				value = value.deref()
 			}
-			return value === undefined ? undefined : {
-				configurable: true,
-				enumerable: true,
-				value,
-				writable: true
-			}
+			return (
+				value === _undefined
+					? _undefined
+					: {
+						configurable: true,
+						enumerable: true,
+						value,
+						writable: true
+					}
+			)
 		},
 		get(back_ctx, prop) {
 			const uw_val = get(back_ctx, prop)
@@ -61,7 +66,7 @@ export { strong__call as ref_strong }
  */
 export function strong__assign(obj, prop, val) {
 	strong__call(obj, prop)
-	if (val !== undefined) {
+	if (val !== _undefined) {
 		assign(obj, {
 			[prop]: val
 		})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "4.8.2",
+  "version": "4.9.1",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -107,7 +107,7 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.13.2",
     "@size-limit/preset-small-lib": "^11.0.0",
-    "@types/node": "^20.10.2",
+    "@types/node": "^20.10.3",
     "@types/sinon": "^17.0.2",
     "c8": "^8.0.1",
     "check-dts": "^0.7.2",
@@ -150,28 +150,28 @@
       "import": {
         "./rmemo": "{ memo_ }"
       },
-      "limit": "342 B"
+      "limit": "338 B"
     },
     {
       "name": "memo_ sig_",
       "import": {
         "./rmemo": "{ sig_, memo_ }"
       },
-      "limit": "357 B"
+      "limit": "354 B"
     },
     {
       "name": "memo_ sig_ be_ ctx_",
       "import": {
         "./rmemo": "{ sig_, memo_, be_, ctx_ }"
       },
-      "limit": "511 B"
+      "limit": "506 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": "607 B"
+      "limit": "602 B"
     }
   ],
   "scripts": {

package/rmemo/index.d.ts

@@ -1,6 +1,6 @@
-export { sig__set_ as set_ } from '../all/rmemo/index.js'
 export * from '../all/be_/index.js'
 export * from '../all/be_memo_pair/index.js'
+export * from '../all/be_memosig_triple/index.js'
 export * from '../all/be_sig_triple/index.js'
 export * from '../all/ctx/index.js'
 export * from '../all/rmemo/index.js'

package/rmemo/index.js

@@ -1,5 +1,6 @@
 export * from '../all/be_/index.js'
 export * from '../all/be_memo_pair/index.js'
+export * from '../all/be_memosig_triple/index.js'
 export * from '../all/be_sig_triple/index.js'
 export * from '../all/ctx/index.js'
 export * from '../all/rmemo/index.js'