ctx-core 2.3.0 → 3.0.0

package/all/index.d.ts

@@ -5,6 +5,7 @@ export * from './Map__object/index.js'
 export * from './NumericRange/index.js'
 export * from './NumericUnit/index.js'
 export * from './PHI/index.js'
+export * from './primitive/index.js'
 export * from './Request/index.js'
 export * from './Response/index.js'
 export * from './Timeout/index.js'

package/all/index.js

@@ -5,6 +5,7 @@ export * from './Map__object/index.js'
 export * from './NumericRange/index.js'
 export * from './NumericUnit/index.js'
 export * from './PHI/index.js'
+export * from './primitive/index.js'
 export * from './Request/index.js'
 export * from './Response/index.js'
 export * from './Timeout/index.js'

package/all/noop/index.js

@@ -2,5 +2,5 @@
  * Returns function that does nothing
  * @param {unknown}_
  */
-export function noop(..._) {
+export function noop() {
 }

package/all/primitive/index.d.ts

@@ -0,0 +1,2 @@
+import type { nullish } from '../nullish/index.js'
+export type primitive_T = boolean|number|string|nullish

package/all/primitive/index.js

@@ -0,0 +1 @@
+export {}

package/all/prototype/index.d.ts

@@ -1,2 +1,5 @@
 import type { nullish } from '../nullish/index.js'
+import type { primitive_T } from '../primitive/index.js'
 export declare function prototype_(val:Exclude<any, nullish>):Object
+export declare function prototype__set(obj:Exclude<any, primitive_T>, val:Object):Object
+export declare const fn__proto:Object

package/all/prototype/index.js

@@ -1,8 +1,6 @@
-/**
- * @param {Object}val
- * @returns {Object}
- * @private
- */
-export function prototype_(val) {
-  return Object.getPrototypeOf(val)
+export const { getPrototypeOf, setPrototypeOf, defineProperty, defineProperties } = Object
+export {
+	getPrototypeOf as prototype_,
+	setPrototypeOf as prototype__set,
 }
+export const fn__proto = getPrototypeOf(getPrototypeOf)

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/rmemo/index.test.ts

@@ -0,0 +1,250 @@
+import { deepStrictEqual } from 'node:assert'
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { sleep } from '../sleep/index.js'
+import { rmemo_, rmemo_T, rsig_ } from './index.js'
+test('rmemo_|static value', ()=>{
+	let count = 0
+	let rmemo$ = rmemo_(rmemo=>{
+		count++
+		return 'rmemo-value'
+	})
+	equal(count, 0)
+	equal(rmemo$(), 'rmemo-value')
+	equal(count, 1)
+	equal(rmemo$(), 'rmemo-value')
+	equal(count, 1)
+})
+test('rsig_', ()=>{
+	let rsig$ = rsig_('val0')
+	equal(rsig$(), 'val0')
+	rsig$('val1')
+	equal(rsig$(), 'val1')
+})
+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$ = rsig_('id-0')
+	let user$ = rsig_<{ id:string }|null>(
+		null,
+		async (_user$)=>{
+			id$()
+			let user:{ id:string } = await new Promise(_resolve=>resolve = _resolve)
+			_user$(user)
+		})
+	equal(user$(), null)
+	resolve!(user0)
+	await sleep(0)
+	equal(user$(), user0)
+	id$('id-1')
+	equal(user$(), user0)
+	resolve!(user1)
+	await sleep(0)
+})
+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')
+	equal(dep1$(), 'base0-dep0-dep1')
+	equal(dep0$(), 'base0-dep0')
+	equal(base$(), 'base0')
+	base$('base1')
+	equal(base$(), 'base1')
+	equal(dep0$(), 'base1-dep0')
+	equal(dep1$(), 'base1-dep0-dep1')
+	equal(dep2$(), 'base1-dep0-dep1-dep2')
+	equal(dep3$(), 'base1-dep0-dep1-dep2-dep3')
+	equal(dep4$(), 'base1-dep0-dep1-dep2-dep3-dep4')
+})
+test('prevents diamond dependency problem 1', ()=>{
+	let store$ = rsig_(0)
+	let values:string[] = []
+	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'])
+	store$(1)
+	store$(2)
+	deepStrictEqual(values, ['b0c0d0', 'b1c1d1', 'b2c2d2'])
+})
+test('prevents diamond dependency problem 2', ()=>{
+	let store$ = rsig_(0)
+	let values: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'])
+	store$(1)
+	deepStrictEqual(values, ['a0e0', 'a1e1'])
+})
+test('prevents diamond dependency problem 3', ()=>{
+	let store$ = rsig_(0)
+	let values: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'])
+	store$(1)
+	deepStrictEqual(values, ['a0b0c0d0', 'a1b1c1d1'])
+})
+test('autosubscribe: prevents diamond dependency problem 4 (complex)', ()=>{
+	let store1$ = rsig_(0)
+	let store2$ = rsig_(0)
+	let values:string[] = []
+	let fn =
+		(name:string)=>
+			(...v:(number|string)[])=>
+				`${name}${v.join('')}`
+	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$()))
+	rmemo_(
+		()=>[e$(), g$()].join(''),
+		combined2$=>values.push(combined2$()))
+	deepStrictEqual(values, ['eca0b0da0', 'eca0b0da0gfeca0b0da0'])
+	store1$(1)
+	store2$(2)
+	deepStrictEqual(values, [
+		'eca0b0da0',
+		'eca0b0da0gfeca0b0da0',
+		'eca1b0da1',
+		'eca1b0da1gfeca1b0da1',
+		'eca1b2da1',
+		'eca1b2da1gfeca1b2da1'
+	])
+})
+test('prevents diamond dependency problem 5', ()=>{
+	let events = ''
+	let firstName$ = rsig_('John')
+	let lastName$ = rsig_('Doe')
+	let fullName$ = rmemo_(()=>{
+		events += 'full '
+		return `${firstName$()} ${lastName$()}`
+	})
+	let isFirstShort$ = rmemo_(()=>{
+		events += 'short '
+		return firstName$().length < 10
+	})
+	let displayName$ = rmemo_(
+		()=>{
+			events += 'display '
+			return isFirstShort$() ? fullName$() : firstName$()
+		}
+	)
+	equal(events, '')
+	equal(displayName$(), 'John Doe')
+	equal(events, 'display short full ')
+	firstName$('Benedict')
+	equal(displayName$(), 'Benedict Doe')
+	equal(events, 'display short full short full display ')
+	firstName$('Montgomery')
+	equal(displayName$(), 'Montgomery')
+	equal(events, 'display short full short full display short full display ')
+})
+test('prevents diamond dependency problem 6', ()=>{
+	let store1$ = rsig_(0)
+	let store2$ = rsig_(0)
+	let values:string[] = []
+	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'])
+	store1$(1)
+	deepStrictEqual(values, ['a0c0', 'a1c0'])
+})
+test('prevents dependency listeners from being out of order', ()=>{
+	let base$ = rsig_(0)
+	let a$ = rmemo_(()=>{
+		return `${base$()}a`
+	})
+	let values:string[] = []
+	let b$ = rmemo_(()=>{
+		return `${a$()}b`
+	}, b$=>values.push(b$()))
+	equal(b$(), '0ab')
+	deepStrictEqual(values, ['0ab'])
+	equal(a$(), '0a')
+	base$(1)
+	deepStrictEqual(values, ['0ab', '1ab'])
+})
+test('computes initial value when argument is undefined', ()=>{
+	let one$ = rsig_<string|undefined>(undefined)
+	let two$ = rmemo_(()=>!!one$())
+	equal(one$(), undefined)
+	equal(two$(), false)
+})
+test.run()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-core",
-  "version": "2.3.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,6 +94,7 @@
     "./queue": "./queue/index.js",
     "./random": "./random/index.js",
     "./regex": "./regex/index.js",
+    "./rmemo": "./rmemo/index.js",
     "./set": "./set/index.js",
     "./sleep": "./sleep/index.js",
     "./string": "./string/index.js",
@@ -105,11 +106,13 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.13.1",
-    "@types/node": "^20.9.0",
+    "@size-limit/preset-small-lib": "^11.0.0",
+    "@types/node": "^20.9.1",
     "@types/sinon": "^17.0.1",
     "c8": "^8.0.1",
     "check-dts": "^0.7.2",
     "sinon": "^17.0.1",
+    "size-limit": "^11.0.0",
     "ts-node": "^10.9.1",
     "tsx": "^4.1.2",
     "typescript": "next",
@@ -120,12 +123,37 @@
     "cache": "~/.npm"
   },
   "sideEffects": false,
+  "size-limit": [
+    {
+      "name": "be",
+      "import": {
+        "./be": "{ be_ }"
+      },
+      "limit": "600 B"
+    },
+    {
+      "name": "rmemo",
+      "import": {
+        "./rmemo": "{ rmemo_ }"
+      },
+      "limit": "351 B"
+    },
+    {
+      "name": "rmemo signal",
+      "import": {
+        "./rmemo": "{ rsig_ }"
+      },
+      "limit": "377 B"
+    }
+  ],
   "scripts": {
     "build": ":",
     "clean": ":",
     "exec": "$@",
-    "test": "pnpm test-unit && check-dts",
-    "test-unit": "tsx node_modules/uvu/bin.js . '\\.test\\.(ts|js)$'",
-    "test-unit-coverage": "c8 pnpm test-unit"
+    "test": "pnpm run /^test:/",
+    "test:size": "size-limit",
+    "test:type": "check-dts",
+    "test:unit": "tsx node_modules/uvu/bin.js . '\\.test\\.(ts|js)$'",
+    "disable:test:coverage": "c8 pnpm test-unit"
   }
 }

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,8 +0,0 @@
-export declare function rememo_<val_T>(def:()=>val_T):rememo_T<val_T>
-export type rememo_T<val_T> =
-	((rememo:rememo_T<val>)=>val_T)
-	&rememo_o_T<val_T>
-export type rememo_o_T<val_T> = {
-	val:val_T
-	listeners:Set<WeakRef<rememo_T<val_T>>>
-}

package/all/rememo/index.js

@@ -1,9 +0,0 @@
-/** @typedef {import('./index.d.ts').rememo_o_T} */
-/**
- * @param {(rememo:rememo_T<unknown>)=>unknown}fn
- * @returns {rememo_T}
- * @private
- */
-export function rememo_(fn) {
-	// let
-}

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'