@e280/strata 0.2.1 → 0.2.3

package/s/prism/prism.test.ts

@@ -0,0 +1,330 @@
+
+import {suite, test, expect} from "@e280/science"
+
+import {Prism} from "./prism.js"
+import {Chrono} from "./chrono/chrono.js"
+import {chronicle} from "./chrono/chronicle.js"
+import {effect} from "../signals/core/effect.js"
+
+export default suite({
+	"prism": suite({
+		"get and set state": test(async() => {
+			const prism = new Prism({count: 1})
+			expect(prism.get().count).is(1)
+			await prism.set({count: 2})
+			expect(prism.get().count).is(2)
+		}),
+	}),
+
+	"lens": suite({
+		"get state": test(async() => {
+			const prism = new Prism({data: {count: 1}})
+			const lens = prism.lens(s => s.data)
+			expect(lens.state.count).is(1)
+		}),
+
+		"state is immutable": test(async() => {
+			const prism = new Prism({data: {count: 1}})
+			const lens = prism.lens(s => s.data)
+			expect(() => (lens.state as any).count++).throws()
+		}),
+
+		"proper mutation": test(async() => {
+			const prism = new Prism({data: {count: 1}})
+			const lens = prism.lens(s => s.data)
+			await lens.mutate(s => s.count++)
+			expect(lens.state.count).is(2)
+			await lens.mutate(s => s.count++)
+			expect(lens.state.count).is(3)
+		}),
+
+		"state after mutation is frozen": test(async() => {
+			const prism = new Prism({data: {count: 1}})
+			const lens = prism.lens(s => s)
+			await lens.mutate(s => s.data = {count: 2})
+			expect(lens.state.data.count).is(2)
+			expect(() => (lens.state.data as any).count++).throws()
+		}),
+
+		"effect reacts": test(async() => {
+			const prism = new Prism({data: {count: 1}})
+			const lens = prism.lens(s => s.data)
+			let happenings = 0
+			const stop = effect(() => {
+				void lens.state.count
+				happenings++
+			})
+			await lens.mutate(s => s.count++)
+			expect(happenings).is(2)
+			stop()
+		}),
+
+		"lens.on is debounced": test(async() => {
+			const prism = new Prism({data: {count: 1}})
+			const lens = prism.lens(s => s.data)
+			let happenings = 0
+			const stop = lens.on(() => void happenings++)
+			await Promise.all([
+				lens.mutate(s => s.count++),
+				lens.mutate(s => s.count++),
+			])
+			expect(happenings).is(1)
+			stop()
+		}),
+
+		"array pushes are reactive": test(async() => {
+			const prism = new Prism({data: {array: ["lol"]}})
+			const lens = prism.lens(s => s.data)
+			let happenings = 0
+			const stop = lens.on(() => void happenings++)
+			await lens.mutate(s => s.array.push("lmao"))
+			expect(happenings).is(1)
+			expect(lens.state.array.length).is(2)
+			stop()
+		}),
+
+		"sync coherence": test(async() => {
+			const prism = new Prism({data: {count: 1}})
+			const lens = prism.lens(s => s.data)
+			const p1 = lens.mutate(s => s.count++)
+			expect(lens.state.count).is(2)
+			const p2 = lens.mutate(s => s.count++)
+			expect(lens.state.count).is(3)
+			await p1
+			await p2
+		}),
+
+		"nullable selector": test(async() => {
+			type S = {a?: {b: {count: number}}}
+			const prism = new Prism<S>({a: {b: {count: 1}}})
+			const lens = prism.lens(s => s.a?.b)
+			expect(lens.state?.count).is(1)
+			await prism.set({a: undefined})
+			expect(lens.state?.count).is(undefined)
+		}),
+
+		"deep composition": test(async() => {
+			const prism = new Prism({a: {b: {count: 1}}})
+			const lensA = prism.lens(s => s.a)
+			const lensB = lensA.lens(s => s.b)
+			expect(prism.get().a.b.count).is(1)
+			expect(lensA.state.b.count).is(1)
+			expect(lensB.state.count).is(1)
+		}),
+
+		"deep mutations": test(async() => {
+			const prism = new Prism({a: {b: {count: 1}}})
+			const lensA = prism.lens(s => s.a)
+			const lensB = lensA.lens(s => s.b)
+			await lensB.mutate(s => s.count++)
+			expect(prism.get().a.b.count).is(2)
+			expect(lensA.state.b.count).is(2)
+			expect(lensB.state.count).is(2)
+			await lensA.mutate(s => s.b = {count: 3})
+			expect(prism.get().a.b.count).is(3)
+			expect(lensA.state.b.count).is(3)
+			expect(lensB.state.count).is(3)
+		}),
+
+		"outside mutations ignored": test(async() => {
+			const prism = new Prism({a: {count: 1}, b: {count: 101}})
+			const lensA = prism.lens(s => s.a)
+			const lensB = prism.lens(s => s.b)
+			let happeningsA = 0
+			let happeningsB = 0
+			const stopA = lensA.on(() => void happeningsA++)
+			const stopB = lensB.on(() => void happeningsA++)
+			await lensA.mutate(s => s.count++)
+			expect(happeningsA).is(1)
+			expect(happeningsB).is(0)
+			stopA()
+			stopB()
+		}),
+
+		"outside mutations ignored for effects": test(async() => {
+			const prism = new Prism({a: {count: 1}, b: {count: 101}})
+			const lensA = prism.lens(s => s.a)
+			const lensB = prism.lens(s => s.b)
+			let happeningsA = 0
+			let happeningsB = 0
+			const stopA = effect(() => {
+				void lensA.state.count
+				happeningsA++
+			})
+			const stopB = effect(() => {
+				void lensB.state.count
+				happeningsB++
+			})
+			await lensA.mutate(s => s.count++)
+			expect(happeningsA).is(2)
+			expect(happeningsB).is(1)
+			stopA()
+			stopB()
+		}),
+	}),
+
+	"chrono": suite({
+		"get present state": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+			expect(chrono.state.count).is(1)
+		}),
+
+		"mutation": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+			await chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(2)
+			await chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(3)
+		}),
+
+		"undoable/redoable": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+			expect(chrono.undoable).is(0)
+			expect(chrono.redoable).is(0)
+			await chrono.mutate(s => s.count++)
+			expect(chrono.undoable).is(1)
+			await chrono.mutate(s => s.count++)
+			expect(chrono.undoable).is(2)
+			await chrono.undo()
+			expect(chrono.undoable).is(1)
+			expect(chrono.redoable).is(1)
+			await chrono.undo()
+			expect(chrono.undoable).is(0)
+			expect(chrono.redoable).is(2)
+			await chrono.redo()
+			expect(chrono.undoable).is(1)
+			expect(chrono.redoable).is(1)
+		}),
+
+		"undo": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+
+			await chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(2)
+
+			await chrono.undo()
+			expect(chrono.state.count).is(1)
+		}),
+
+		"sync undo": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+
+			chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(2)
+
+			chrono.undo()
+			expect(chrono.state.count).is(1)
+		}),
+
+		"redo": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+
+			await chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(2)
+
+			await chrono.undo()
+			expect(chrono.state.count).is(1)
+
+			await chrono.redo()
+			expect(chrono.state.count).is(2)
+		}),
+
+		"undo/redo is orderly": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+
+			await chrono.mutate(s => s.count++)
+			await chrono.mutate(s => s.count++)
+			await chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(4)
+
+			await chrono.undo()
+			expect(chrono.state.count).is(3)
+
+			await chrono.undo()
+			expect(chrono.state.count).is(2)
+
+			await chrono.redo()
+			expect(chrono.state.count).is(3)
+
+			await chrono.redo()
+			expect(chrono.state.count).is(4)
+
+			await chrono.undo()
+			expect(chrono.state.count).is(3)
+
+			await chrono.undo()
+			expect(chrono.state.count).is(2)
+
+			await chrono.undo()
+			expect(chrono.state.count).is(1)
+		}),
+
+		"undo nothing does nothing": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+			await chrono.undo()
+			expect(chrono.state.count).is(1)
+		}),
+
+		"redo nothing does nothing": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+			await chrono.redo()
+			expect(chrono.state.count).is(1)
+		}),
+
+		"undo 2x": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+			await chrono.mutate(s => s.count++)
+			await chrono.mutate(s => s.count++)
+			await chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(4)
+			await chrono.undo(2)
+			expect(chrono.state.count).is(2)
+		}),
+
+		"redo 2x": test(async() => {
+			const prism = new Prism({data: chronicle({count: 1})})
+			const lens = prism.lens(s => s.data)
+			const chrono = new Chrono(64, lens)
+			await chrono.mutate(s => s.count++)
+			await chrono.mutate(s => s.count++)
+			await chrono.mutate(s => s.count++)
+			expect(chrono.state.count).is(4)
+			await chrono.undo(2)
+			expect(chrono.state.count).is(2)
+			await chrono.redo(2)
+			expect(chrono.state.count).is(4)
+		}),
+
+		"sublens mutations are undoable": test(async() => {
+			const prism = new Prism({data: chronicle({a: {count: 1}})})
+			const chrono = new Chrono(64, prism.lens(s => s.data))
+			const sublens = chrono.lens(s => s.a)
+			expect(sublens.state.count).is(1)
+			await sublens.mutate(s => s.count++)
+			expect(sublens.state.count).is(2)
+			await chrono.undo()
+			expect(sublens.state.count).is(1)
+		}),
+	}),
+})
+

package/s/prism/prism.ts

@@ -0,0 +1,41 @@
+
+import {microbounce, sub} from "@e280/stz"
+import {Lens} from "./lens.js"
+
+/** state mangagement source-of-truth */
+export class Prism<State> {
+	#state: State
+	#lenses = new Set<Lens<any>>()
+
+	on = sub<[state: State]>()
+	#onPublishDebounced = microbounce(() => this.on.publish(this.#state))
+
+	constructor(state: State) {
+		this.#state = state
+	}
+
+	get() {
+		return this.#state
+	}
+
+	async set(state: State) {
+		this.#state = state
+		await Promise.all([...this.#lenses].map(lens => lens.update()))
+		await this.#onPublishDebounced()
+	}
+
+	lens<State2>(selector: (state: State) => State2) {
+		const lens = new Lens<State2>({
+			getState: () => selector(this.#state),
+			mutate: async fn => {
+				const result = fn(selector(this.#state))
+				await this.set(this.#state)
+				return result
+			},
+			registerLens: lens => this.#lenses.add(lens),
+		})
+		this.#lenses.add(lens)
+		return lens
+	}
+}
+

package/s/prism/types.ts

@@ -0,0 +1,27 @@
+
+import {Lens} from "./lens.js"
+
+export type LensLike<State> = {
+	readonly state: Immutable<State>
+	mutate<R>(fn: (state: State) => R): Promise<R>
+	lens<S2>(selector: (state: State) => S2): Lens<S2>
+}
+
+export type Optic<State> = {
+	getState: () => State
+	mutate: <R>(fn: (state: State) => R) => Promise<R>
+	registerLens: (lens: Lens<any>) => void
+}
+
+export type Immutable<T> =
+	T extends (...args: any[]) => any ? T :
+	T extends readonly any[] ? ReadonlyArray<Immutable<T[number]>> :
+	T extends object ? { readonly [K in keyof T]: Immutable<T[K]> } :
+	T
+
+export type Mutable<T> =
+	T extends (...args: any[]) => any ? T :
+	T extends ReadonlyArray<infer U> ? Mutable<U>[] :
+	T extends object ? { -readonly [K in keyof T]: Mutable<T[K]> } :
+	T
+

package/s/prism/utils/cache-cell.ts

@@ -0,0 +1,22 @@
+
+export class CacheCell<R> {
+	#dirty = false
+	#value: R
+
+	constructor(private calculate: () => R) {
+		this.#value = calculate()
+	}
+
+	get() {
+		if (this.#dirty) {
+			this.#dirty = false
+			this.#value = this.calculate()
+		}
+		return this.#value
+	}
+
+	invalidate() {
+		this.#dirty = true
+	}
+}
+

package/s/prism/utils/immute.ts

@@ -0,0 +1,8 @@
+
+import {deep} from "@e280/stz"
+import {Immutable} from "../types.js"
+
+export function immute<S>(s: S) {
+	return deep.freeze(deep.clone(s)) as Immutable<S>
+}
+

package/s/prism/utils/optic-symbol.ts

@@ -0,0 +1,3 @@
+
+export const _optic = Symbol("optic")
+

package/s/prism/vault/local-store.ts

@@ -0,0 +1,31 @@
+
+import {EzStore} from "./types.js"
+
+export class LocalStore<X> implements EzStore<X> {
+	constructor(
+		private key: string,
+		private storage: Storage = window.localStorage,
+	) {}
+
+	async get() {
+		const json = this.storage.getItem(this.key)
+		return json
+			? JSON.parse(json)
+			: undefined
+	}
+
+	async set(data: X) {
+		const json = JSON.stringify(data)
+		this.storage.setItem(this.key, json)
+	}
+
+	onStorageEvent(fn: () => void) {
+		const listener = (event: StorageEvent) => {
+			if (event.storageArea === this.storage && event.key === this.key)
+				fn()
+		}
+		window.addEventListener("storage", listener)
+		return () => window.removeEventListener("storage", listener)
+	}
+}
+

package/s/prism/vault/types.ts

@@ -0,0 +1,19 @@
+
+import {Prism} from "../prism.js"
+
+export type Versioned<State> = {
+	state: State
+	version: number
+}
+
+export type EzStore<X> = {
+	get(): Promise<X | undefined>
+	set(data: X | undefined): Promise<void>
+}
+
+export type VaultOptions<State> = {
+	version: number
+	prism: Prism<State>
+	store: EzStore<Versioned<State>>
+}
+

package/s/prism/vault/vault.ts

@@ -0,0 +1,19 @@
+
+import {VaultOptions} from "./types.js"
+
+export class Vault<State> {
+	constructor(private options: VaultOptions<State>) {}
+
+	load = async() => {
+		const {store, version, prism} = this.options
+		const pickle = await store.get()
+		if (pickle && pickle.version === version)
+			await prism.set(pickle.state)
+	}
+
+	save = async() => {
+		const {store, version, prism} = this.options
+		await store.set({version, state: prism.get()})
+	}
+}
+

package/s/signals/core/effect.ts

@@ -1,5 +1,5 @@
 
-import {debounce} from "@e280/stz"
+import {microbounce} from "@e280/stz"
 import {tracker} from "../../tracker/tracker.js"
 
 export function effect(
@@ -16,7 +16,7 @@ export function collectorEffect<C = void>(
 	) {
 
 	const {seen, result} = tracker.observe(collector)
-	const fn = debounce(0, responder)
+	const fn = microbounce(responder)
 
 	const disposers: (() => void)[] = []
 	const dispose = () => disposers.forEach(d => d())

package/s/tests.test.ts

@@ -2,6 +2,7 @@
 import {expect, Science, test} from "@e280/science"
 
 import tree from "./tree/tree.test.js"
+import prism from "./prism/prism.test.js"
 import signals from "./signals/signals.test.js"
 import tracker from "./tracker/tracker.test.js"
 
@@ -11,10 +12,12 @@ import {Trunk} from "./tree/parts/trunk.js"
 
 await Science.run({
 	tree,
+	prism,
+
 	signals,
 	tracker,
 
-	interop: Science.suite({
+	interop: Science.suite.skip({
 		"effect responds to trunk change": test(async() => {
 			const trunk = new Trunk({count: 1})
 

package/s/tree/parts/branch.ts

@@ -1,37 +1,51 @@
 
 import {deep} from "@e280/stz"
-import {derived} from "../../signals/porcelain.js"
-import {Derived} from "../../signals/core/derived.js"
-import {Branchstate, Immutable, Mutator, Options, Selector, Tree} from "./types.js"
+import {Immutable} from "../../prism/types.js"
+import {SignalFn} from "../../signals/types.js"
+import {signal} from "../../signals/porcelain.js"
+import {Branchstate, Mutator, TreeOptions, Selector, Tree} from "./types.js"
 
+/** @deprecated tree stuff has been replaced by prism/lens stuff */
 export class Branch<S extends Branchstate, ParentState extends Branchstate = any> implements Tree<S> {
-	#immutable: Derived<Immutable<S>>
+	#previous: Immutable<S>
+	#$data: SignalFn<Immutable<S>>
 
 	constructor(
 			private parent: Tree<ParentState>,
 			private selector: Selector<S, ParentState>,
-			private options: Options,
+			private options: TreeOptions,
 		) {
 
-		this.#immutable = derived(() => {
-			const state = selector(parent.state as any)
-			return deep.freeze(options.clone(state)) as Immutable<S>
-		}, {compare: deep.equal})
+		this.#$data = signal(this.#pull())
+		this.#previous = this.state
+
+		this.parent.on(() => {
+			const oldState = this.#previous
+			const newState = this.#pull()
+			if (!deep.equal(newState, oldState)) {
+				this.#previous = newState
+				this.#$data.set(newState, true)
+			}
+		})
+	}
+
+	#pull() {
+		return this.selector(this.parent.state as ParentState) as Immutable<S>
 	}
 
 	get state() {
-		return this.#immutable.get()
+		return this.#$data.get()
 	}
 
 	get on() {
-		return this.#immutable.on
+		return this.#$data.on
 	}
 
 	async mutate(mutator: Mutator<S>) {
-		await this.parent.mutate(parentState =>
-			mutator(this.selector(parentState))
+		await this.parent.mutate(
+			parentState => mutator(this.selector(parentState))
 		)
-		return this.#immutable.get()
+		return this.state
 	}
 
 	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S> {

package/s/tree/parts/chronobranch.ts

@@ -1,7 +1,9 @@
 
+import {Chronicle, Immutable} from "../../prism/index.js"
 import {Branch} from "./branch.js"
-import {Branchstate, Chronicle, Immutable, Mutator, Options, Selector, Tree} from "./types.js"
+import {Branchstate, Mutator, TreeOptions, Selector, Tree} from "./types.js"
 
+/** @deprecated tree stuff has been replaced by prism/lens stuff */
 export class Chronobranch<S extends Branchstate, ParentState extends Branchstate = any> implements Tree<S> {
 	#branch: Branch<Chronicle<S>, ParentState>
 
@@ -9,7 +11,7 @@ export class Chronobranch<S extends Branchstate, ParentState extends Branchstate
 			public limit: number,
 			public parent: Tree<ParentState>,
 			public selector: Selector<Chronicle<S>, ParentState>,
-			public options: Options,
+			public options: TreeOptions,
 		) {
 		this.#branch = parent.branch(selector)
 	}