@e280/strata 0.2.8 → 0.3.0-1

package/s/signals/core/signal.ts

@@ -1,101 +0,0 @@
-
-import {Reactive} from "./parts/reactive.js"
-import {tracker} from "../../tracker/tracker.js"
-import {SignalFn, SignalOptions} from "../types.js"
-import {defaultCompare} from "../utils/default-compare.js"
-
-export class Signal<V> extends Reactive<V> {
-	#lock = false
-	#compare: (a: any, b: any) => boolean
-
-	constructor(value: V, options?: Partial<SignalOptions>) {
-		super(value)
-		this.#compare = options?.compare ?? defaultCompare
-	}
-
-	toString() {
-		return `($signal "${String(this.get())}")`
-	}
-
-	async set(v: V, forcePublish = false) {
-		const previous = this.sneak
-		this.sneak = v
-
-		if (forcePublish || !this.#compare(previous, v))
-			await this.publish()
-
-		return v
-	}
-
-	get value() {
-		return this.get()
-	}
-
-	set value(v: V) {
-		void this.set(v)
-	}
-
-	async publish() {
-		// only wizards are allowed beyond this point.
-		// - the implementation is subtle
-		// - it looks wrong, but it's right
-		// - tarnished alchemists, take heed: lock engages only for sync activity of the async fns (think of the value setter!)
-
-		if (this.#lock)
-			throw new Error("forbid circularity")
-
-		const value = this.sneak
-		let promise: Promise<any> = Promise.resolve()
-
-		try {
-			this.#lock = true
-			promise = Promise.all([
-				tracker.notifyWrite(this),
-				this.on.publish(value),
-			])
-		}
-		finally {
-			this.#lock = false
-		}
-
-		await promise
-		return value
-	}
-
-	get core() {
-		return this
-	}
-
-	fn() {
-		const that = this as Signal<V>
-
-		function f(): V
-		function f(v: V): Promise<V>
-		function f(_v?: V): V | Promise<V> {
-			return (arguments.length === 0)
-				? that.get()
-				: that.set(arguments[0])
-		}
-
-		f.core = that
-		f.get = that.get.bind(that)
-		f.set = that.set.bind(that)
-		f.on = that.on
-		f.dispose = that.dispose.bind(that)
-		f.publish = that.publish.bind(that)
-		f.fn = that.fn.bind(that)
-
-		Object.defineProperty(f, "value", {
-			get: () => that.value,
-			set: (v) => that.value = v,
-		})
-
-		Object.defineProperty(f, "sneak", {
-			get: () => that.sneak,
-			set: (v) => that.sneak = v,
-		})
-
-		return f as SignalFn<V>
-	}
-}
-

package/s/signals/porcelain.ts

@@ -1,30 +0,0 @@
-
-import {SignalOptions} from "./types.js"
-import {Lazy} from "./core/lazy.js"
-import {Signal} from "./core/signal.js"
-import {Derived} from "./core/derived.js"
-
-export function lazy<V>(
-		formula: () => V,
-		options?: Partial<SignalOptions>,
-	) {
-	return new Lazy<V>(formula, options).fn()
-}
-
-export function derived<V>(
-		formula: () => V,
-		options?: Partial<SignalOptions>,
-	) {
-	return new Derived<V>(formula, options).fn()
-}
-
-export function signal<V>(
-		value: V,
-		options?: Partial<SignalOptions>,
-	) {
-	return new Signal<V>(value, options).fn()
-}
-
-signal.lazy = lazy
-signal.derived = derived
-

package/s/signals/tests/effect.test.ts

@@ -1,89 +0,0 @@
-
-import {Science, test, expect} from "@e280/science"
-import {signal} from "../porcelain.js"
-import {effect} from "../core/effect.js"
-
-export default Science.suite({
-	"tracks signal changes": test(async() => {
-		const count = signal(1)
-		let doubled = 0
-
-		effect(() => doubled = count.value * 2)
-		expect(doubled).is(2)
-
-		await count.set(3)
-		expect(doubled).is(6)
-	}),
-
-	"is only called when signal actually changes": test(async() => {
-		const count = signal(1)
-		let runs = 0
-		effect(() => {
-			count.get()
-			runs++
-		})
-		expect(runs).is(1)
-		await count.set(999)
-		expect(runs).is(2)
-		await count.set(999)
-		expect(runs).is(2)
-	}),
-
-	"debounced": test(async() => {
-		const count = signal(1)
-		let runs = 0
-		effect(() => {
-			count.get()
-			runs++
-		})
-		expect(runs).is(1)
-		count.value++
-		count.value++
-		await count.set(count.get() + 1)
-		expect(runs).is(2)
-	}),
-
-	"can be disposed": test(async() => {
-		const count = signal(1)
-		let doubled = 0
-
-		const dispose = effect(() => doubled = count.value * 2)
-		expect(doubled).is(2)
-
-		await count.set(3)
-		expect(doubled).is(6)
-
-		dispose()
-		await count.set(4)
-		expect(doubled).is(6) // old value
-	}),
-
-	"signal set promise waits for effects": test(async() => {
-		const count = signal(1)
-		let doubled = 0
-
-		effect(() => doubled = count.value * 2)
-		expect(doubled).is(2)
-
-		await count.set(3)
-		expect(doubled).is(6)
-	}),
-
-	"only runs on change": test(async() => {
-		const sig = signal("a")
-		let runs = 0
-
-		effect(() => {
-			sig.value
-			runs++
-		})
-		expect(runs).is(1)
-
-		await sig.set("a")
-		expect(runs).is(1)
-
-		await sig.set("b")
-		expect(runs).is(2)
-	}),
-})
-

package/s/tree/index.ts

@@ -1,7 +0,0 @@
-
-export * from "./parts/branch.js"
-export * from "./parts/chronobranch.js"
-export * from "./parts/persistence.js"
-export * from "./parts/trunk.js"
-export * from "./parts/types.js"
-

package/s/tree/parts/branch.ts

@@ -1,55 +0,0 @@
-
-import {deep} from "@e280/stz"
-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> {
-	#previous: Immutable<S>
-	#$data: SignalFn<Immutable<S>>
-
-	constructor(
-			private parent: Tree<ParentState>,
-			private selector: Selector<S, ParentState>,
-			private options: TreeOptions,
-		) {
-
-		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.#$data.get()
-	}
-
-	get on() {
-		return this.#$data.on
-	}
-
-	async mutate(mutator: Mutator<S>) {
-		await this.parent.mutate(
-			parentState => mutator(this.selector(parentState))
-		)
-		return this.state
-	}
-
-	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S> {
-		return new Branch(this, selector, this.options)
-	}
-}
-

package/s/tree/parts/chronobranch.ts

@@ -1,86 +0,0 @@
-
-import {Chronicle, Immutable} from "../../prism/index.js"
-import {Branch} from "./branch.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>
-
-	constructor(
-			public limit: number,
-			public parent: Tree<ParentState>,
-			public selector: Selector<Chronicle<S>, ParentState>,
-			public options: TreeOptions,
-		) {
-		this.#branch = parent.branch(selector)
-	}
-
-	get state() {
-		return this.#branch.state.present
-	}
-
-	get undoable() {
-		return this.#branch.state.past.length
-	}
-
-	get redoable() {
-		return this.#branch.state.future.length
-	}
-
-	on(fn: (state: Immutable<S>) => void) {
-		return this.#branch.on(chronicle => fn(chronicle.present))
-	}
-
-	/** progress forwards in history */
-	async mutate(mutator: Mutator<S>) {
-		const limit = Math.max(0, this.limit)
-		const snapshot = this.options.clone(this.#branch.state.present) as S
-		await this.#branch.mutate(chronicle => {
-			mutator(chronicle.present)
-			chronicle.past.push(snapshot)
-			chronicle.past = chronicle.past.slice(-limit)
-			chronicle.future = []
-		})
-		return this.state
-	}
-
-	/** step backwards into the past, by n steps */
-	async undo(n = 1) {
-		await this.#branch.mutate(chronicle => {
-			const snapshots = chronicle.past.slice(-n)
-			if (snapshots.length >= n) {
-				const oldPresent = chronicle.present
-				chronicle.present = snapshots.shift()!
-				chronicle.past = chronicle.past.slice(0, -n)
-				chronicle.future.unshift(oldPresent, ...snapshots)
-			}
-		})
-	}
-
-	/** step forwards into the future, by n steps */
-	async redo(n = 1) {
-		await this.#branch.mutate(chronicle => {
-			const snapshots = chronicle.future.slice(0, n)
-			if (snapshots.length >= n) {
-				const oldPresent = chronicle.present
-				chronicle.present = snapshots.shift()!
-				chronicle.past.push(oldPresent, ...snapshots)
-				chronicle.future = chronicle.future.slice(n)
-			}
-		})
-	}
-
-	/** wipe past and future snapshots */
-	async wipe() {
-		await this.#branch.mutate(chronicle => {
-			chronicle.past = []
-			chronicle.future = []
-		})
-	}
-
-	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S> {
-		return new Branch(this, selector, this.options)
-	}
-}
-

package/s/tree/parts/persistence.ts

@@ -1,31 +0,0 @@
-
-import {Persistence} from "./types.js"
-
-export const localPersistence = <X>(
-		key: string,
-		storage: Storage = window.localStorage,
-	): Persistence<X> => ({
-
-	store: {
-		async get() {
-			const json = storage.getItem(key)
-			return json
-				? JSON.parse(json)
-				: undefined
-		},
-		async set(state) {
-			const json = JSON.stringify(state)
-			storage.setItem(key, json)
-		},
-	},
-
-	onChange: (fn: () => void) => {
-		const listener = (event: StorageEvent) => {
-			if (event.storageArea === storage && event.key === key)
-				fn()
-		}
-		window.addEventListener("storage", listener)
-		return () => window.removeEventListener("storage", listener)
-	},
-})
-

package/s/tree/parts/trunk.ts

@@ -1,70 +0,0 @@
-
-import {deep} from "@e280/stz"
-import {Branch} from "./branch.js"
-import {Immute} from "./utils/immute.js"
-import {trunkSetup} from "./utils/setup.js"
-import {Chronobranch} from "./chronobranch.js"
-import {processOptions} from "./utils/process-options.js"
-import {Branchstate, Mutator, TreeOptions, Selector, Tree, Trunkstate} from "./types.js"
-import {Chronicle} from "../../prism/index.js"
-
-/** @deprecated tree stuff has been replaced by prism/lens stuff */
-export class Trunk<S extends Trunkstate> implements Tree<S> {
-	static setup = trunkSetup
-	static chronicle = <S extends Branchstate>(state: S): Chronicle<S> => ({
-		present: state,
-		past: [],
-		future: [],
-	})
-
-	options: TreeOptions
-	#mutationLock = 0
-	#immute: Immute<S>
-
-	constructor(state: S, options: Partial<TreeOptions> = {}) {
-		this.options = processOptions(options)
-		this.#immute = new Immute(state, this.options)
-	}
-
-	get state() {
-		return this.#immute.immutable
-	}
-
-	get on() {
-		return this.#immute.on
-	}
-
-	async mutate(mutator: Mutator<S>) {
-		const oldState = this.#immute.get()
-		if (this.#mutationLock > 0)
-			throw new Error("nested mutations are forbidden")
-		let promise = Promise.resolve()
-		try {
-			this.#mutationLock++
-			const newState = this.options.clone(oldState)
-			mutator(newState)
-			const isChanged = !deep.equal(newState, oldState)
-			if (isChanged)
-				promise = this.overwrite(newState)
-		}
-		finally { this.#mutationLock-- }
-		await promise
-		return this.state
-	}
-
-	async overwrite(state: S) {
-		await this.#immute.set(state)
-	}
-
-	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S> {
-		return new Branch(this, selector, this.options)
-	}
-
-	chronobranch<Sub extends Branchstate>(
-			limit: number,
-			selector: Selector<Chronicle<Sub>, S>,
-		) {
-		return new Chronobranch(limit, this, selector, this.options)
-	}
-}
-

package/s/tree/parts/types.ts

@@ -1,70 +0,0 @@
-
-import { EzStore, Versioned } from "../../prism/index.js"
-import { Immutable } from "../../prism/types.js"
-import {Branch} from "./branch.js"
-
-export type TreeOptions = {
-	clone: <X>(x: X) => X
-}
-
-/** @deprecated renamed to `TreeOptions` */
-export type Options = TreeOptions
-
-export type Selector<Sub, S> = (state: S) => Sub
-export type Mutator<S> = (state: S) => void
-
-export type Trunkstate = {}
-export type Branchstate = {} | null | undefined
-
-// export type Versioned<S extends Trunkstate> = {
-// 	state: S
-// 	version: number
-// }
-//
-// 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
-
-export type Tree<S extends Branchstate> = {
-	get state(): Immutable<S>
-	on(fn: (state: Immutable<S>) => void): () => void
-	mutate(mutator: Mutator<S>): Promise<Immutable<S>>
-	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S>
-}
-
-export type SetupOptions<S extends Trunkstate> = {
-	version: number
-	initialState: S
-	saveDebounceTime?: number
-	persistence?: Persistence<Versioned<S>>
-}
-
-// export type Chronicle<S extends Branchstate> = {
-// 	// [abc] d [efg]
-// 	//    \   \   \
-// 	//     \   \   future
-// 	//      \   present
-// 	//       past
-// 	past: S[]
-// 	present: S
-// 	future: S[]
-// }
-
-// export type EzStore<X> = {
-// 	get(): Promise<X | undefined>
-// 	set(state: X | undefined): Promise<void>
-// }
-
-export type Persistence<X> = {
-	store: EzStore<X>
-	onChange: (fn: () => void) => (() => void)
-}
-

package/s/tree/parts/utils/immute.ts

@@ -1,43 +0,0 @@
-
-import {deep, sub} from "@e280/stz"
-import {TreeOptions} from "../types.js"
-import {tracker} from "../../../tracker/tracker.js"
-import {Immutable} from "../../../prism/types.js"
-
-export class Immute<S> {
-	#mutable: S
-	#immutable: Immutable<S>
-
-	constructor(mutable: S, private options: TreeOptions) {
-		this.#mutable = mutable
-		this.#immutable = this.#petrify(mutable)
-	}
-
-	#petrify<X>(x: X) {
-		return deep.freeze(
-			this.options.clone(x)
-		) as Immutable<X>
-	}
-
-	on = sub<[Immutable<S>]>()
-
-	get() {
-		tracker.notifyRead(this)
-		return this.#mutable
-	}
-
-	async set(mutable: S) {
-		this.#mutable = mutable
-		this.#immutable = deep.freeze(this.options.clone(this.get())) as Immutable<S>
-		await Promise.all([
-			this.on.publish(this.#immutable),
-			tracker.notifyWrite(this),
-		])
-	}
-
-	get immutable() {
-		tracker.notifyRead(this)
-		return this.#immutable
-	}
-}
-

package/s/tree/parts/utils/process-options.ts

@@ -1,7 +0,0 @@
-
-import {TreeOptions} from "../types.js"
-
-export const processOptions = (options: Partial<TreeOptions>): TreeOptions => ({
-	clone: options.clone ?? (<X>(x: X) => structuredClone(x)),
-})
-

package/s/tree/parts/utils/setup.ts

@@ -1,40 +0,0 @@
-
-import {debounce} from "@e280/stz"
-
-import {Trunk} from "../trunk.js"
-import {localPersistence} from "../persistence.js"
-import {SetupOptions, Trunkstate} from "../types.js"
-
-export async function trunkSetup<S extends Trunkstate>(options: SetupOptions<S>) {
-	const {
-		version,
-		initialState,
-		saveDebounceTime = 500,
-		persistence = localPersistence("strataTree"),
-	} = options
-
-	const trunk = new Trunk<S>(initialState)
-
-	async function load() {
-		const pickle = await persistence.store.get()
-		if (pickle && pickle.version === version)
-			await trunk.overwrite(pickle.state)
-	}
-
-	const save = debounce(saveDebounceTime, async() => persistence.store.set({
-		version,
-		state: trunk.state as any,
-	}))
-
-	// persistence: initial load from store
-	await load()
-
-	// persistence: save to store
-	trunk.on(save)
-
-	// cross-tab sync
-	const dispose = persistence.onChange(load)
-
-	return {trunk, load, save, dispose}
-}
-