ctx-core 4.14.1 → 4.15.0

package/all/be_lock_memosig_triple/index.d.ts

@@ -0,0 +1,35 @@
+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_lock_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_lock_memosig_triple_T<val_T, _sig_T, ctx_T>
+export declare function be_lock_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_lock_memosig_triple_T<val_T, _sig_T, ctx_T>
+export declare function globalThis__be_lock_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)[], config:be_config_T&{ id:string }]
+):be_lock_memosig_triple_T<val_T, _sig_T, ctx_T>
+export type be_lock_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_lock_memosig_triple/index.js

@@ -0,0 +1,38 @@
+/// <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_ } from '../be_/index.js'
+import { lock_memosig_ } from '../rmemo/index.js'
+/**
+ * @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_sig_triple_T}
+ * @private
+ */
+export function be_lock_memosig_triple_(
+	be_OR_val__new,
+	...subscriber_a_THEN_config
+) {
+	let config =
+		typeof subscriber_a_THEN_config[subscriber_a_THEN_config.length - 1] === 'object'
+			? subscriber_a_THEN_config.pop()
+			: 0
+	/** @type {Be<sig_T>} */
+	let be =
+		be_OR_val__new.is_be
+			? be_OR_val__new
+			: be_(ctx=>
+				lock_memosig_(
+					memo=>be_OR_val__new(ctx, memo),
+					...subscriber_a_THEN_config.map(subscriber=>
+						sig=>subscriber(ctx, sig))),
+			config)
+	return [
+		be,
+		ctx=>be(ctx)(),
+		(ctx, val)=>{
+			be(ctx)._ = val
+		},
+	]
+}

package/all/be_lock_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_lock_memosig_triple_ } from './index.js'
+test('be_lock_memosig_triple_', ()=>{
+	const [
+		,
+		base_,
+		base__set,
+	] = be_sig_triple_(()=>1)
+	const [
+		foobar$_,
+		foobar_,
+		foobar__set,
+	] = be_lock_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)._, 5)
+	equal(foobar_(ctx), 5)
+	equal(foobar$_(ctx).count, 1)
+})
+test('be_lock_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_lock_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])._, 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(subscriber_dep_(ctx), 7)
+})
+test('be_lock_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_lock_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_memosig_triple/index.js

@@ -3,19 +3,4 @@
 /// <reference types="../rmemo/index.d.ts" />
 /// <reference types="./index.d.ts" />
 import { be_memo_pair_ } from '../be_memo_pair/index.js'
-/**
- * @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
-		},
-	]
-}
+export { be_memo_pair_ as be_memosig_triple_ }

package/all/be_sig_triple/index.js

@@ -1,8 +1,7 @@
 /// <reference types="../be_/index.d.ts" />
 /// <reference types="../rmemo/index.d.ts" />
 /// <reference types="./index.d.ts" />
-import { be_, globalThis__be_ } from '../be_/index.js'
-import { ctx_, ctx__new } from '../ctx'
+import { be_ } from '../be_/index.js'
 import { sig_ } from '../rmemo/index.js'
 /**
  * @param {Be<sig_T>|be__val__new_T<unknown>}be_OR_val__new

package/all/index.d.ts

@@ -35,6 +35,7 @@ export * from './base64__buffer/index.js'
 export * from './batch_queue/index.js'
 export * from './be/index.js'
 export * from './be_/index.js'
+export * from './be_lock_memosig_triple/index.js'
 export * from './be_memo_pair/index.js'
 export * from './be_sig_triple/index.js'
 export * from './binary_sort_rank/index.js'

package/all/index.js

@@ -35,6 +35,7 @@ export * from './base64__buffer/index.js'
 export * from './batch_queue/index.js'
 export * from './be/index.js'
 export * from './be_/index.js'
+export * from './be_lock_memosig_triple/index.js'
 export * from './be_memo_pair/index.js'
 export * from './be_sig_triple/index.js'
 export * from './binary_sort_rank/index.js'

package/all/rmemo/index.d.ts

@@ -1,16 +1,19 @@
 export declare function memo_<val_T>(
-	def:rmemo_def_T<val_T>,
-	...subscriber_a:rmemo_subscriber_T<val_T>[]
+	def:memo_def_T<val_T>,
+	...subscriber_a:memo_subscriber_T<val_T>[]
 ):memo_T<val_T>
 export declare function sig_<val_T>(
 	init_val:val_T,
-	...subscriber_a:rmemo_subscriber_T<val_T>[]
+	...subscriber_a:memo_subscriber_T<val_T>[]
 ):sig_T<val_T>
 export declare function memosig_<val_T>(
-	def:rmemo_def_T<val_T>,
-	...subscriber_a:rmemo_subscriber_T<val_T>[]
+	def:memo_def_T<val_T>,
+	...subscriber_a:memo_subscriber_T<val_T>[]
+):sig_T<val_T>
+export declare function lock_memosig_<val_T>(
+	def:memo_def_T<val_T>,
+	...subscriber_a:memo_subscriber_T<val_T>[]
 ):sig_T<val_T>
-// TODO: lock_memosig_
 export declare function on(rmemo:rmemo_T<unknown>):void
 export declare function off(rmemo:rmemo_T<unknown>):void
 export type rmemo_T<val_T> = memo_T<val_T>|sig_T<val_T>
@@ -29,5 +32,5 @@ export type sig_T<val_T> = (()=>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> = (sig:sig_T<val_T>)=>val_T
-export type rmemo_subscriber_T<val_T> = (sig:sig_T<val_T>)=>unknown
+export type memo_def_T<val_T> = (sig:sig_T<val_T>)=>val_T
+export type memo_subscriber_T<val_T> = (sig:sig_T<val_T>)=>unknown

package/all/rmemo/index.js

@@ -4,12 +4,12 @@ let cur_memo
 /** @type {Set<()=>unknown>} */
 let queue = new Set
 /**
- * @param {rmemo_def_T}rmemo_def
+ * @param {rmemo_def_T}memo_def
  * @param {rmemo_subscriber_T<unknown>[]}subscriber_a
  * @returns {memo_T}
  * @private
  */
-export function memo_(rmemo_def, ...subscriber_a) {
+export function memo_(memo_def, ...subscriber_a) {
 	let memo = ()=>{
 		if (!('val' in memo)) {
 			memo.f()
@@ -66,7 +66,7 @@ export function memo_(rmemo_def, ...subscriber_a) {
 		cur_memo = memo
 		memo.f.s = []
 		try {
-			memo._ = rmemo_def(memo)
+			memo._ = memo_def(memo)
 		} catch (err) {
 			console.error(err)
 		}
@@ -79,6 +79,27 @@ export function memo_(rmemo_def, ...subscriber_a) {
 	return memo
 }
 export { memo_ as memosig_ }
+/**
+ * @param {rmemo_def_T}memo_def
+ * @param {rmemo_subscriber_T<unknown>[]}subscriber_a
+ * @returns {sig_T}
+ * @private
+ */
+export function lock_memosig_(memo_def, ...subscriber_a) {
+	return new Proxy(
+		/** @type {sig_T} */memo_(memo=>
+			memo.c ? memo._ : memo_def(memo),
+		...subscriber_a),
+		{
+			set(memo, prop, val) {
+				if (prop === '_') {
+					memo.c = 1
+					memo._ = val
+				}
+				return 1
+			}
+		})
+}
 /**
  * @param {unknown}init_val
  * @param {rmemo_subscriber_T[]}subscriber_a
@@ -111,6 +132,7 @@ export function on(rmemo) {
 export function off(rmemo) {
 	if (rmemo.r) {
 		rmemo.r.d ||= rmemo.r.deref
-		rmemo.r.deref = ()=>{}
+		rmemo.r.deref = ()=>{
+		}
 	}
 }

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 { memo_, type memo_T, memosig_, off, on, sig_ } from './index.js'
+import { lock_memosig_, memo_, type memo_T, memosig_, off, on, sig_ } from './index.js'
 test('memo_|static value', ()=>{
 	let count = 0
 	const memo = memo_(()=>{
@@ -113,6 +113,24 @@ test('memosig_', ()=>{
 	equal(selected_index$(), 3)
 	equal(selected_item$(), 'Item 4')
 })
+test('lock_memosig_', ()=>{
+	const num_items$ = sig_(0)
+	const items$ = memo_(()=>[...Array(num_items$()).keys()].map(i=>`Item ${i + 1}`))
+	// TODO: Jetbrains or Typescript type inference is wrong without generic
+	const selected_index$ = lock_memosig_<number>(()=>(items$(), 0))
+	const selected_item$ = memo_(()=>items$()[selected_index$()])
+	num_items$._ = 3
+	equal(num_items$(), 3)
+	equal(items$().join(','), 'Item 1,Item 2,Item 3')
+	equal(selected_index$(), 0)
+	equal(selected_item$(), 'Item 1')
+	selected_index$._ = 2
+	equal(selected_index$(), 2)
+	equal(selected_item$(), 'Item 3')
+	num_items$._ = 5
+	equal(num_items$(), 5)
+	equal(selected_index$(), 2)
+})
 test('memo_|error|case 1', ()=>{
 	const r$ = memo_(()=>{
 		throw new Error('error case')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "4.14.1",
+  "version": "4.15.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -156,7 +156,7 @@
       "import": {
         "./rmemo": "{ sig_, memo_ }"
       },
-      "limit": "355 B"
+      "limit": "356 B"
     },
     {
       "name": "memo_ sig_ be_ ctx_",
@@ -170,7 +170,7 @@
       "import": {
         "./rmemo": "{ sig_, memo_, be_, ctx_, be_memo_pair_, be_sig_triple_ }"
       },
-      "limit": "591 B"
+      "limit": "588 B"
     }
   ],
   "scripts": {

package/rmemo/index.d.ts

@@ -1,4 +1,5 @@
 export * from '../all/be_/index.js'
+export * from '../all/be_lock_memosig_triple/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'

package/rmemo/index.js

@@ -1,4 +1,5 @@
 export * from '../all/be_/index.js'
+export * from '../all/be_lock_memosig_triple/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'