ctx-core 5.4.0 → 5.5.0

package/all/file_exists/index.js

@@ -8,11 +8,10 @@ import { waitfor } from '../waitfor/index.js'
 export async function file_exists_(path) {
 	return (
 		(process_release_name ?? false)
-		&& import('node:fs/promises').then(({ access, constants })=>{
-			return access(path, constants.F_OK)
+		&& import('node:fs/promises').then(({ access, constants })=>
+			access(path, constants.F_OK)
 				.then(()=>true)
-				.catch(()=>false)
-		}))
+				.catch(()=>false)))
 }
 export {
 	file_exists_ as path__exists_

package/all/rmemo/index.d.ts

@@ -17,6 +17,7 @@ export declare function lock_memosig_<val_T>(
 ):sig_T<val_T>
 export declare function on(rmemo:rmemo_T<unknown>):void
 export declare function off(rmemo:rmemo_T<unknown>):void
+export declare function rmemo__subscribe(rmemo:rmemo_T<unknown>, listener:()=>unknown):()=>void
 export type rmemo_T<val_T> = memo_T<val_T>|sig_T<val_T>|lock_memosig_T<val_T>
 export type memo_T<val_T> = (()=>val_T)&{
 	readonly _:val_T

package/all/rmemo/index.js

@@ -135,3 +135,21 @@ export function off(rmemo) {
 		}
 	}
 }
+/**
+ * Bind reactive listener onto the given memo to prevent GC.
+ * The listener can autosubscribe to any rmemo.
+ * Returns an "off" function which deactivates the reactive listener & removes the GC binding from the given memo.
+ * @param {rmemo_T}memo
+ * @param {()=>unknown}listener
+ * @returns {()=>void}
+ */
+export function rmemo__subscribe(memo, listener) {
+	let listener_memo = memo_(()=>listener())
+	listener_memo()
+	memo.b ??= []
+	memo.b.push(listener_memo)
+	return ()=>{
+		off(listener_memo)
+		memo.b.splice(memo.b.indexOf(listener_memo), 1)
+	}
+}

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_, off, on, sig_ } from './index.js'
+import { lock_memosig_, memo_, type memo_T, memosig_, off, on, rmemo__subscribe, sig_ } from './index.js'
 test('memo_|static value', ()=>{
 	let count = 0
 	const memo = memo_(()=>{
@@ -454,4 +454,22 @@ test('.on + .off', ()=>{
 	equal(memo$(), 14)
 	equal(count, 5)
 })
+test('rmemo__subscribe', ()=>{
+	const base$ = sig_(1)
+	let count = 0
+	const subscriber_base_a:number[] = []
+	const off = rmemo__subscribe(base$, ()=>{
+		count++
+		subscriber_base_a.push(base$())
+	})
+	equal(subscriber_base_a, [1])
+	equal(count, 1)
+	base$._ = 2
+	equal(subscriber_base_a, [1, 2])
+	equal(count, 2)
+	off()
+	base$._ = 3
+	equal(subscriber_base_a, [1, 2])
+	equal(count, 2)
+})
 test.run()

package/all/rmemo__wait/index.d.ts

@@ -1,8 +1,11 @@
-import type { rmemo_T, rmemo_val_T } from '../rmemo/index.js'
+import type { memo_T, rmemo_T, rmemo_val_T } from '../rmemo/index.js'
 export declare function rmemo__wait<
 	_rmemo_T extends rmemo_T<unknown> = rmemo_T<unknown>
 >(
 	memo:_rmemo_T,
 	condition_fn:(val:rmemo_val_T<_rmemo_T>)=>unknown,
 	timeout?:number
-):Promise<rmemo_val_T<_rmemo_T>>
+):Promise<rmemo_val_T<_rmemo_T>>&{
+	// prevent early usGC
+	m:memo_T<unknown>
+}

package/all/rmemo__wait/index.js

@@ -10,12 +10,20 @@ import { memo_ } from '../rmemo/index.js'
  * @returns {Promise<*>|Promise<unknown>}
  */
 export function rmemo__wait(rmemo, condition_fn, timeout) {
+	let memo
 	const _subscribe_wait = new Promise(resolve=>{
-		memo_(()=>{
+		memo = memo_(()=>{
 			if (condition_fn(rmemo())) {
 				resolve(rmemo())
 			}
-		})()
+		})
+		memo()
 	})
-	return isNumber_(timeout) ? promise_timeout(_subscribe_wait, timeout) : _subscribe_wait
+	let promise =
+	isNumber_(timeout)
+		? promise_timeout(_subscribe_wait, timeout)
+		: _subscribe_wait
+	// prevent GC
+	promise.m = memo
+	return promise
 }

package/all/rmemo__wait/index.test.ts

@@ -3,21 +3,16 @@ import { equal } from 'uvu/assert'
 import { sig_ } from '../rmemo/index.js'
 import { rmemo__wait } from './index.js'
 test('rmemo__wait', async ()=>{
-	const subject = await new Promise(resolve=>{
-		let subject = -1
-		const subject$ = sig_(subject)
-		rmemo__wait(subject$, $=>$ >= 0, 10_000).then(_subject=>{
-			subject = _subject
-			equal(_subject, 1)
-			equal(subject, 1)
-			resolve(_subject)
-			return _subject
-		})
-		equal(subject, -1)
-		subject$._ = 1
-		equal(subject, -1)
-		equal(subject$(), 1)
-	})
-	equal(subject, 1)
+	const subject$ = sig_(-1)
+	const promise = rmemo__wait(
+		subject$,
+		subject=>subject >= 0,
+		10_000)
+	equal(promise.m.memor, [])
+	equal(subject$(), -1)
+	subject$._ = 1
+	equal(subject$(), 1)
+	await promise
+	equal(subject$(), 1)
 })
 test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -196,21 +196,21 @@
       "import": {
         "./rmemo": "{ sig_, memo_ }"
       },
-      "limit": "351 B"
+      "limit": "352 B"
     },
     {
       "name": "memo_ sig_ be_ ctx_",
       "import": {
         "./rmemo": "{ sig_, memo_, be_, ctx_ }"
       },
-      "limit": "456 B"
+      "limit": "458 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": "549 B"
+      "limit": "552 B"
     }
   ],
   "scripts": {

package/rmemo/index.d.ts

@@ -1,3 +1,5 @@
+import { rmemo__subscribe } from '../rmemo/index.js'
+export { rmemo__subscribe as subscribe }
 export * from '../all/be_/index.js'
 export * from '../all/be_lock_memosig_triple/index.js'
 export * from '../all/be_memo_pair/index.js'

package/rmemo/index.js

@@ -1,3 +1,5 @@
+import { rmemo__subscribe } from '../rmemo/index.js'
+export { rmemo__subscribe as subscribe }
 export * from '../all/be_/index.js'
 export * from '../all/be_lock_memosig_triple/index.js'
 export * from '../all/be_memo_pair/index.js'

package/tsconfig.json

@@ -5,7 +5,6 @@
 		"moduleResolution": "nodenext",
 		"target": "ESNext",
 		"strict": true,
-		"skipLibCheck": true,
 		"lib": ["ESNext"],
 		"types": [
 			"node"