ctx-core 2.4.0 → 3.0.0

package/all/rmemo/index.d.ts

@@ -0,0 +1,18 @@
+export declare function rmemo_<val_T>(
+	def:rmemo_def_T<val_T>,
+	...subscriber_a:rmemo_subscriber_T<val_T>[]
+):rmemo_T<val_T>
+export declare function rsig_<val_T>(
+	init_val:val_T,
+	...subscriber_a:rmemo_subscriber_T<val_T>[]
+):rmemo_T<val_T>
+export type rmemo_T<val_T> = ((val?:val_T)=>val_T)&rmemo_o_T<val_T>
+export type rmemo_def_T<val_T> = (rmemo:rmemo_T<val_T>)=>val_T
+export type rmemo_subscriber_T<val_T> = (rmemo:rmemo_T<val_T>)=>unknown
+export type rmemo_o_T<val_T> = {
+	_:val_T
+	readonly val:val_T
+	go():unknown
+	onset(val:val_T):unknown
+	refresh():val_T
+}

package/all/rmemo/index.js

@@ -0,0 +1,88 @@
+/** @typedef {import('./index.d.ts').rmemo_T} */
+/** @typedef {import('./index.d.ts').rmemo_subscriber_T} */
+/** @type {(()=>unknown)[]} */
+let queue = []
+/** @type {WeakRef<rmemo_T>} */
+let cur_ref
+/**
+ * @param {(rmemo:rmemo_T<unknown>)=>unknown}_f
+ * @param {rmemo_subscriber_T<unknown>[]}subscriber_a
+ * @returns {rmemo_T}
+ * @private
+ */
+export function rmemo_(_f, ...subscriber_a) {
+	let rmemo$ = (...arg_a)=>arg_a.length ? rmemo$._ = arg_a[0] : rmemo$._
+	let _a = []
+	let _r = new WeakRef(()=>rmemo$.refresh(_f(rmemo$)))
+	_r.l = 0
+	rmemo$._a = _a
+	rmemo$._f = _f
+	rmemo$._r = _r
+	rmemo$._rS = new Set
+	rmemo$.go = ()=>(rmemo$(), rmemo$)
+	rmemo$.onset = ()=>0
+	Object.defineProperty(rmemo$, '_', {
+		get() {
+			if (!_a.length) {
+				let prev_ref = cur_ref
+				cur_ref = _r
+				try {
+					_a[0] = _f(rmemo$)
+				} finally {
+					cur_ref = prev_ref
+				}
+			}
+			// allow self-referencing
+			if (cur_ref && cur_ref !== _r) {
+				// Math.max: bitwise is much faster on chrome
+				// https://measurethat.net/Benchmarks/Show/28483/0/mathmax-vs-bitwise
+				cur_ref.l = cur_ref.l ^ ((cur_ref.l ^ _r.l + 1) & -(cur_ref.l < _r.l + 1))
+				rmemo$._rS.add(cur_ref)
+			}
+			return _a[0]
+		},
+		set(val) {
+			if (!_a.length || val !== _a[0]) {
+				rmemo$.refresh(val)
+			}
+			return val
+		}
+	})
+	rmemo$.refresh = val=>{
+		let length = _a.length
+		_a[0] = val
+		rmemo$.onset(val)
+		if (length) {
+			let run_queue = !queue[0]
+			for (let ref of rmemo$._rS) {
+				if (!~queue.indexOf(ref)) queue.push(ref)
+			}
+			if (run_queue) {
+				for (let ref; ref = queue.shift();) {
+					if (queue.some(_ref=>ref.l > _ref.l)) {
+						queue.push(ref)
+					} else {
+						(ref.deref() || rmemo$._rS.delete)(ref)
+					}
+				}
+			}
+		}
+		return rmemo$
+	}
+	rmemo$._sa = subscriber_a.map(subscriber=>
+		rmemo_(()=>subscriber(rmemo$)).go())
+	return rmemo$
+}
+/**
+ * @param {unknown}init_val
+ * @param {rmemo_subscriber_T[]}subscriber_a
+ * @returns {rmemo_T}
+ * @private
+ */
+export function rsig_(init_val, ...subscriber_a) {
+	let signal$ =
+		rmemo_(signal$=>signal$._v, ...subscriber_a)
+	signal$.onset = val=>signal$._v = val
+	signal$._v = init_val
+	return signal$
+}

package/all/{rememo → rmemo}/index.test.ts

@@ -1,33 +1,43 @@
 import { deepStrictEqual } from 'node:assert'
-import { clock } from 'sinon'
 import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { sleep } from '../sleep/index.js'
-import { rememo_, signal_ } from './index.js'
-test('rememo_|static value', ()=>{
+import { rmemo_, rmemo_T, rsig_ } from './index.js'
+test('rmemo_|static value', ()=>{
 	let count = 0
-	let rememo$ = rememo_(rememo=>{
+	let rmemo$ = rmemo_(rmemo=>{
 		count++
-		return 'rememo-value'
+		return 'rmemo-value'
 	})
 	equal(count, 0)
-	equal(rememo$(), 'rememo-value')
+	equal(rmemo$(), 'rmemo-value')
 	equal(count, 1)
-	equal(rememo$(), 'rememo-value')
+	equal(rmemo$(), 'rmemo-value')
 	equal(count, 1)
 })
-test('signal_', ()=>{
-	let signal$ = signal_('val0')
-	equal(signal$(), 'val0')
-	signal$('val1')
-	equal(signal$(), 'val1')
+test('rsig_', ()=>{
+	let rsig$ = rsig_('val0')
+	equal(rsig$(), 'val0')
+	rsig$('val1')
+	equal(rsig$(), 'val1')
 })
-test('rememo_|async subsubscriber', async ()=>{
+test('rmemo_|def function|rmemo$ argument', ()=>{
+	let rsig$ = rsig_('val0')
+	let rmemo$:rmemo_T<string>&{custom?:string} = rmemo_<string>((_rmemo$:rmemo_T<string>&{custom?:string})=>
+		`${_rmemo$.custom}-${rsig$()}`)
+	rmemo$.custom = 'custom_val0'
+	equal(rmemo$(), 'custom_val0-val0')
+	rmemo$.custom = 'custom_val1'
+	equal(rmemo$(), 'custom_val0-val0')
+	rsig$('val1')
+	equal(rmemo$(), 'custom_val1-val1')
+})
+test('rsig_|async subsubscriber|case 1', async ()=>{
 	let resolve:(user:{ id:string })=>void
 	let user0 = { id: 'id-0' }
 	let user1 = { id: 'id-1' }
-	let id$ = signal_('id-0')
-	let user$ = signal_<{ id:string }|null>(
+	let id$ = rsig_('id-0')
+	let user$ = rsig_<{ id:string }|null>(
 		null,
 		async (_user$)=>{
 			id$()
@@ -43,13 +53,46 @@ test('rememo_|async subsubscriber', async ()=>{
 	resolve!(user1)
 	await sleep(0)
 })
-test('rememo_+signal_|simple graph', ()=>{
-	let base$ = signal_('base0')
-	let dep0$ = rememo_(()=>base$() + '-dep0')
-	let dep1$ = rememo_(()=>dep0$() + '-dep1')
-	let dep2$ = rememo_(()=>dep1$() + '-dep2')
-	let dep3$ = rememo_(()=>dep2$() + '-dep3')
-	let dep4$ = rememo_(()=>dep3$() + '-dep4')
+test('rsig_|async subsubscriber|case 2', async ()=>{
+	let a$ = rsig_(1)
+	let b$ = rsig_(2)
+	let sleepCycles = 5
+	let taskArgumentsCalls:number[][] = []
+	let sum$ = rsig_<null|number>(null,
+		async sum$=>{
+			taskArgumentsCalls.push([a$(), b$()])
+			for (let i = 0; i < sleepCycles; i++) {
+				await Promise.resolve()
+			}
+			sum$(a$() + b$())
+		})
+	equal(sum$(), null)
+	deepStrictEqual(taskArgumentsCalls, [[1, 2]])
+	a$(10)
+	b$(20)
+	for (let i = 0; i < sleepCycles; i++) {
+		equal(sum$(), null)
+		await Promise.resolve()
+		deepStrictEqual(taskArgumentsCalls, [
+			[1, 2],
+			[10, 2],
+			[10, 20]
+		])
+	}
+	equal(sum$(), 30)
+	deepStrictEqual(taskArgumentsCalls, [
+		[1, 2],
+		[10, 2],
+		[10, 20]
+	])
+})
+test('rmemo_+rsig_|simple graph', ()=>{
+	let base$ = rsig_('base0')
+	let dep0$ = rmemo_(()=>base$() + '-dep0')
+	let dep1$ = rmemo_(()=>dep0$() + '-dep1')
+	let dep2$ = rmemo_(()=>dep1$() + '-dep2')
+	let dep3$ = rmemo_(()=>dep2$() + '-dep3')
+	let dep4$ = rmemo_(()=>dep3$() + '-dep4')
 	equal(dep4$(), 'base0-dep0-dep1-dep2-dep3-dep4')
 	equal(dep3$(), 'base0-dep0-dep1-dep2-dep3')
 	equal(dep2$(), 'base0-dep0-dep1-dep2')
@@ -65,13 +108,13 @@ test('rememo_+signal_|simple graph', ()=>{
 	equal(dep4$(), 'base1-dep0-dep1-dep2-dep3-dep4')
 })
 test('prevents diamond dependency problem 1', ()=>{
-	let store$ = signal_(0)
+	let store$ = rsig_(0)
 	let values:string[] = []
-	let a$ = rememo_(()=>`a${store$()}`)
-	let b$ = rememo_(()=>a$().replace('a', 'b'))
-	let c$ = rememo_(()=>a$().replace('a', 'c'))
-	let d$ = rememo_(()=>a$().replace('a', 'd'))
-	let combined$ = rememo_(()=>`${b$()}${c$()}${d$()}`,
+	let a$ = rmemo_(()=>`a${store$()}`)
+	let b$ = rmemo_(()=>a$().replace('a', 'b'))
+	let c$ = rmemo_(()=>a$().replace('a', 'c'))
+	let d$ = rmemo_(()=>a$().replace('a', 'd'))
+	let combined$ = rmemo_(()=>`${b$()}${c$()}${d$()}`,
 		combined$=>
 			values.push(combined$()))
 	deepStrictEqual(values, ['b0c0d0'])
@@ -80,14 +123,14 @@ test('prevents diamond dependency problem 1', ()=>{
 	deepStrictEqual(values, ['b0c0d0', 'b1c1d1', 'b2c2d2'])
 })
 test('prevents diamond dependency problem 2', ()=>{
-	let store$ = signal_(0)
+	let store$ = rsig_(0)
 	let values:string[] = []
-	let a$ = rememo_(()=>`a${store$()}`)
-	let b$ = rememo_(()=>a$().replace('a', 'b'))
-	let c$ = rememo_(()=>b$().replace('b', 'c'))
-	let d$ = rememo_(()=>c$().replace('c', 'd'))
-	let e$ = rememo_(()=>d$().replace('d', 'e'))
-	let combined$ = rememo_<string>(
+	let a$ = rmemo_(()=>`a${store$()}`)
+	let b$ = rmemo_(()=>a$().replace('a', 'b'))
+	let c$ = rmemo_(()=>b$().replace('b', 'c'))
+	let d$ = rmemo_(()=>c$().replace('c', 'd'))
+	let e$ = rmemo_(()=>d$().replace('d', 'e'))
+	let combined$ = rmemo_<string>(
 		()=>[a$(), e$()].join(''),
 		combined$=>values.push(combined$()))
 	deepStrictEqual(values, ['a0e0'])
@@ -95,13 +138,13 @@ test('prevents diamond dependency problem 2', ()=>{
 	deepStrictEqual(values, ['a0e0', 'a1e1'])
 })
 test('prevents diamond dependency problem 3', ()=>{
-	let store$ = signal_(0)
+	let store$ = rsig_(0)
 	let values:string[] = []
-	let a$ = rememo_(()=>`a${store$()}`)
-	let b$ = rememo_(()=>a$().replace('a', 'b'))
-	let c$ = rememo_(()=>b$().replace('b', 'c'))
-	let d$ = rememo_(()=>c$().replace('c', 'd'))
-	rememo_<string>(
+	let a$ = rmemo_(()=>`a${store$()}`)
+	let b$ = rmemo_(()=>a$().replace('a', 'b'))
+	let c$ = rmemo_(()=>b$().replace('b', 'c'))
+	let d$ = rmemo_(()=>c$().replace('c', 'd'))
+	rmemo_<string>(
 		()=>`${a$()}${b$()}${c$()}${d$()}`,
 		combined$=>values.push(combined$()))
 	deepStrictEqual(values, ['a0b0c0d0'])
@@ -109,24 +152,24 @@ test('prevents diamond dependency problem 3', ()=>{
 	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
 })
 test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
-	let store1$ = signal_(0)
-	let store2$ = signal_(0)
+	let store1$ = rsig_(0)
+	let store2$ = rsig_(0)
 	let values:string[] = []
 	let fn =
 		(name:string)=>
 			(...v:(number|string)[])=>
 				`${name}${v.join('')}`
-	let a$ = rememo_(()=>`a${store1$()}`)
-	let b$ = rememo_(()=>`b${store2$()}`)
-	let c$ = rememo_(()=>`c${a$()}${b$()}`)
-	let d$ = rememo_(()=>`d${a$()}`)
-	let e$ = rememo_(()=>`e${c$()}${d$()}`)
-	let f$ = rememo_(()=>`f${e$()}`)
-	let g$ = rememo_(()=>`g${f$()}`)
-	rememo_(
+	let a$ = rmemo_(()=>`a${store1$()}`)
+	let b$ = rmemo_(()=>`b${store2$()}`)
+	let c$ = rmemo_(()=>`c${a$()}${b$()}`)
+	let d$ = rmemo_(()=>`d${a$()}`)
+	let e$ = rmemo_(()=>`e${c$()}${d$()}`)
+	let f$ = rmemo_(()=>`f${e$()}`)
+	let g$ = rmemo_(()=>`g${f$()}`)
+	rmemo_(
 		()=>e$(),
 		combined1$=>values.push(combined1$()))
-	rememo_(
+	rmemo_(
 		()=>[e$(), g$()].join(''),
 		combined2$=>values.push(combined2$()))
 	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
@@ -143,17 +186,17 @@ test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
 })
 test('prevents diamond dependency problem 5', ()=>{
 	let events = ''
-	let firstName$ = signal_('John')
-	let lastName$ = signal_('Doe')
-	let fullName$ = rememo_(()=>{
+	let firstName$ = rsig_('John')
+	let lastName$ = rsig_('Doe')
+	let fullName$ = rmemo_(()=>{
 		events += 'full '
 		return `${firstName$()} ${lastName$()}`
 	})
-	let isFirstShort$ = rememo_(()=>{
+	let isFirstShort$ = rmemo_(()=>{
 		events += 'short '
 		return firstName$().length < 10
 	})
-	let displayName$ = rememo_(
+	let displayName$ = rmemo_(
 		()=>{
 			events += 'display '
 			return isFirstShort$() ? fullName$() : firstName$()
@@ -170,13 +213,13 @@ test('prevents diamond dependency problem 5', ()=>{
 	equal(events, 'display short full short full display short full display ')
 })
 test('prevents diamond dependency problem 6', ()=>{
-	let store1$ = signal_(0)
-	let store2$ = signal_(0)
+	let store1$ = rsig_(0)
+	let store2$ = rsig_(0)
 	let values:string[] = []
-	let a$ = rememo_(()=>`a${store1$()}`)
-	let b$ = rememo_(()=>`b${store2$()}`)
-	let c$ = rememo_(()=>b$().replace('b', 'c'))
-	rememo_(
+	let a$ = rmemo_(()=>`a${store1$()}`)
+	let b$ = rmemo_(()=>`b${store2$()}`)
+	let c$ = rmemo_(()=>b$().replace('b', 'c'))
+	rmemo_(
 		()=>`${a$()}${c$()}`,
 		combined$=>values.push(combined$()))
 	deepStrictEqual(values, ['a0c0'])
@@ -184,12 +227,12 @@ test('prevents diamond dependency problem 6', ()=>{
 	deepStrictEqual(values, ['a0c0', 'a1c0'])
 })
 test('prevents dependency listeners from being out of order', ()=>{
-	let base$ = signal_(0)
-	let a$ = rememo_(()=>{
+	let base$ = rsig_(0)
+	let a$ = rmemo_(()=>{
 		return `${base$()}a`
 	})
 	let values:string[] = []
-	let b$ = rememo_(()=>{
+	let b$ = rmemo_(()=>{
 		return `${a$()}b`
 	}, b$=>values.push(b$()))
 	equal(b$(), '0ab')
@@ -199,43 +242,9 @@ test('prevents dependency listeners from being out of order', ()=>{
 	deepStrictEqual(values, ['0ab', '1ab'])
 })
 test('computes initial value when argument is undefined', ()=>{
-	let one$ = signal_<string|undefined>(undefined)
-	let two$ = rememo_(()=>!!one$())
+	let one$ = rsig_<string|undefined>(undefined)
+	let two$ = rmemo_(()=>!!one$())
 	equal(one$(), undefined)
 	equal(two$(), false)
 })
-test('async computed using task', async ()=>{
-	let a$ = signal_(1)
-	let b$ = signal_(2)
-	let sleepCycles = 5
-	let taskArgumentsCalls:number[][] = []
-	let sum$ = signal_<null|number>(null,
-		async sum$=>{
-			taskArgumentsCalls.push([a$(), b$()])
-			for (let i = 0; i < sleepCycles; i++) {
-				await Promise.resolve()
-			}
-			sum$(a$() + b$())
-		})
-	equal(sum$(), null)
-	deepStrictEqual(taskArgumentsCalls, [[1, 2]])
-	// sleepCycles = 0
-	a$(10)
-	b$(20)
-	for (let i = 0; i < sleepCycles; i++) {
-		equal(sum$(), null)
-		await Promise.resolve()
-		deepStrictEqual(taskArgumentsCalls, [
-			[1, 2],
-			[10, 2],
-			[10, 20]
-		])
-	}
-	equal(sum$(), 30)
-	deepStrictEqual(taskArgumentsCalls, [
-		[1, 2],
-		[10, 2],
-		[10, 20]
-	])
-})
 test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "2.4.0",
+  "version": "3.0.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -53,7 +53,7 @@
     "queue",
     "random",
     "regex",
-    "rememo",
+    "rmemo",
     "set",
     "sleep",
     "string",
@@ -94,7 +94,7 @@
     "./queue": "./queue/index.js",
     "./random": "./random/index.js",
     "./regex": "./regex/index.js",
-    "./rememo": "./rememo/index.js",
+    "./rmemo": "./rmemo/index.js",
     "./set": "./set/index.js",
     "./sleep": "./sleep/index.js",
     "./string": "./string/index.js",
@@ -132,18 +132,18 @@
       "limit": "600 B"
     },
     {
-      "name": "rememo",
+      "name": "rmemo",
       "import": {
-        "./rememo": "{ rememo_ }"
+        "./rmemo": "{ rmemo_ }"
       },
-      "limit": "358 B"
+      "limit": "351 B"
     },
     {
-      "name": "rememo signal",
+      "name": "rmemo signal",
       "import": {
-        "./rememo": "{ signal_ }"
+        "./rmemo": "{ rsig_ }"
       },
-      "limit": "385 B"
+      "limit": "377 B"
     }
   ],
   "scripts": {

package/rmemo/index.d.ts

@@ -0,0 +1 @@
+export * from '../all/rmemo/index.js'

package/rmemo/index.js

@@ -0,0 +1 @@
+export * from '../all/rmemo/index.js'

package/all/rememo/index.d.ts

@@ -1,20 +0,0 @@
-export declare function rememo_<val_T>(
-	def:(rememo:rememo__T<val_T>)=>val_T,
-	...subscriber_a:rememo_subscriber_T<val_T>[]
-):rememo_T<val_T>
-export declare function signal_<val_T>(
-	init_val:val_T,
-	...subscriber_a:rememo_subscriber_T<val_T>[]
-):rememo_T<val_T>
-export type rememo__T<val_T> =
-	(def:rememo_def_T<val_T>, ...subscriber_a:rememo_subscriber_T<val_T>[])=>val_T
-export type rememo_T<val_T> = ((val?:val_T)=>val_T)&rememo_o_T<val_T>
-export type rememo_def_T<val_T> = (rememo:rememo__T<val>)=>val_T
-export type rememo_subscriber_T<val_T> = (rememo:rememo_T<val_T>)=>unknown
-export type rememo_o_T<val_T> = {
-	_:val_T
-	readonly val:val_T
-	init():unknown
-	onset(val:val_T):unknown
-	refresh():val_T
-}

package/all/rememo/index.js

@@ -1,82 +0,0 @@
-/** @typedef {import('./index.d.ts').rememo_T} */
-/** @typedef {import('./index.d.ts').rememo_subscriber_T} */
-/** @type {(()=>unknown)[]} */
-let queue = []
-/** @type {WeakRef<rememo_T>} */
-let cur_ref
-/**
- * @param {(rememo:rememo_T<unknown>)=>unknown}_f
- * @param {rememo_subscriber_T<unknown>[]}subscriber_a
- * @returns {rememo_T}
- * @private
- */
-export function rememo_(_f, ...subscriber_a) {
-	let _a = []
-	let _rS = new Set
-	let rememo$ = (...arg_a)=>arg_a.length ? rememo$._ = arg_a[0] : rememo$._
-	rememo$._a = _a
-	rememo$._f = _f
-	rememo$._rS = _rS
-	rememo$._r = new WeakRef(()=>rememo$.refresh(_f(rememo$)))
-	rememo$.onset = ()=>0
-	rememo$._r.l = 0
-	rememo$.init = ()=>(rememo$(), rememo$)
-	Object.defineProperty(rememo$, '_', {
-		get() {
-			// allow self-referencing
-			if (!_a.length) {
-				let prev_ref = cur_ref
-				cur_ref = rememo$._r
-				try {
-					_a[0] = _f(rememo$)
-				} finally {
-					cur_ref = prev_ref
-				}
-			}
-			if (cur_ref && cur_ref !== rememo$._r) {
-				cur_ref.l = Math.max(rememo$._r.l + 1, cur_ref.l)
-				_rS.add(cur_ref)
-			}
-			return _a[0]
-		},
-		set(val) {
-			if (!_a.length || val !== _a[0]) {
-				rememo$.refresh(val)
-			}
-			return val
-		}
-	})
-	rememo$.refresh = val=>{
-		let { length } = _a
-		_a[0] = val
-		rememo$.onset(val)
-		if (length) {
-			let run_queue = !queue[0]
-			for (let ref of _rS) {
-				if (!~queue.indexOf(ref)) queue.push(ref)
-			}
-			if (run_queue) {
-				for (let ref; ref = queue.shift();) {
-					queue.some(_ref=>ref.l > _ref.l) ? queue.push(ref) : ref.deref()?.() ?? _rS.delete(ref)
-				}
-			}
-		}
-		return rememo$
-	}
-	rememo$._sa = subscriber_a.map(subscriber=>
-		rememo_(()=>subscriber(rememo$)).init())
-	return rememo$
-}
-/**
- * @param {unknown}init_val
- * @param {rememo_subscriber_T[]}subscriber_a
- * @returns {rememo_T}
- * @private
- */
-export function signal_(init_val, ...subscriber_a) {
-	let signal$ =
-		rememo_(signal$=>signal$._v, ...subscriber_a)
-	signal$.onset = val=>signal$._v = val
-	signal$._v = init_val
-	return signal$
-}

package/rememo/index.d.ts

@@ -1 +0,0 @@
-export * from '../all/rememo/index.js'

package/rememo/index.js

@@ -1 +0,0 @@
-export * from '../all/rememo/index.js'