ctx-core 2.3.0 → 2.4.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/rememo/index.d.ts

@@ -1,8 +1,20 @@
-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 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:val_T
-	listeners:Set<WeakRef<rememo_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,9 +1,82 @@
-/** @typedef {import('./index.d.ts').rememo_o_T} */
+/** @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}fn
+ * @param {(rememo:rememo_T<unknown>)=>unknown}_f
+ * @param {rememo_subscriber_T<unknown>[]}subscriber_a
  * @returns {rememo_T}
  * @private
  */
-export function rememo_(fn) {
-	// let
+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/all/rememo/index.test.ts

@@ -0,0 +1,241 @@
+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', ()=>{
+	let count = 0
+	let rememo$ = rememo_(rememo=>{
+		count++
+		return 'rememo-value'
+	})
+	equal(count, 0)
+	equal(rememo$(), 'rememo-value')
+	equal(count, 1)
+	equal(rememo$(), 'rememo-value')
+	equal(count, 1)
+})
+test('signal_', ()=>{
+	let signal$ = signal_('val0')
+	equal(signal$(), 'val0')
+	signal$('val1')
+	equal(signal$(), 'val1')
+})
+test('rememo_|async subsubscriber', 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>(
+		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('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')
+	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$ = signal_(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$()}`,
+		combined$=>
+			values.push(combined$()))
+	deepStrictEqual(values, ['b0c0d0'])
+	store$(1)
+	store$(2)
+	deepStrictEqual(values, ['b0c0d0', 'b1c1d1', 'b2c2d2'])
+})
+test('prevents diamond dependency problem 2', ()=>{
+	let store$ = signal_(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>(
+		()=>[a$(), e$()].join(''),
+		combined$=>values.push(combined$()))
+	deepStrictEqual(values, ['a0e0'])
+	store$(1)
+	deepStrictEqual(values, ['a0e0', 'a1e1'])
+})
+test('prevents diamond dependency problem 3', ()=>{
+	let store$ = signal_(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>(
+		()=>`${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$ = signal_(0)
+	let store2$ = signal_(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_(
+		()=>e$(),
+		combined1$=>values.push(combined1$()))
+	rememo_(
+		()=>[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$ = signal_('John')
+	let lastName$ = signal_('Doe')
+	let fullName$ = rememo_(()=>{
+		events += 'full '
+		return `${firstName$()} ${lastName$()}`
+	})
+	let isFirstShort$ = rememo_(()=>{
+		events += 'short '
+		return firstName$().length < 10
+	})
+	let displayName$ = rememo_(
+		()=>{
+			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$ = signal_(0)
+	let store2$ = signal_(0)
+	let values:string[] = []
+	let a$ = rememo_(()=>`a${store1$()}`)
+	let b$ = rememo_(()=>`b${store2$()}`)
+	let c$ = rememo_(()=>b$().replace('b', 'c'))
+	rememo_(
+		()=>`${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$ = signal_(0)
+	let a$ = rememo_(()=>{
+		return `${base$()}a`
+	})
+	let values:string[] = []
+	let b$ = rememo_(()=>{
+		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$ = signal_<string|undefined>(undefined)
+	let two$ = rememo_(()=>!!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.3.0",
+  "version": "2.4.0",
   "description": "ctx-core core library",
   "keywords": [
     "ctx-core",
@@ -94,6 +94,7 @@
     "./queue": "./queue/index.js",
     "./random": "./random/index.js",
     "./regex": "./regex/index.js",
+    "./rememo": "./rememo/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": "rememo",
+      "import": {
+        "./rememo": "{ rememo_ }"
+      },
+      "limit": "358 B"
+    },
+    {
+      "name": "rememo signal",
+      "import": {
+        "./rememo": "{ signal_ }"
+      },
+      "limit": "385 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"
   }
 }