atom.io 0.12.1 → 0.14.0

package/internal/src/selector/update-selector-atoms.ts

@@ -1,7 +1,7 @@
 import type { ReadonlySelectorToken, StateToken } from "atom.io"
 
+import { newest } from "../lineage"
 import type { Store } from "../store"
-import { target } from "../transaction"
 import { traceSelectorAtoms } from "./trace-selector-atoms"
 
 export const updateSelectorAtoms = (
@@ -9,9 +9,9 @@ export const updateSelectorAtoms = (
 	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
 	store: Store,
 ): void => {
-	const core = target(store)
+	const target = newest(store)
 	if (dependency.type === `atom`) {
-		core.selectorAtoms = core.selectorAtoms.set({
+		target.selectorAtoms.set({
 			selectorKey,
 			atomKey: dependency.key,
 		})
@@ -32,7 +32,7 @@ export const updateSelectorAtoms = (
 				.join(`, `)} ]`,
 		)
 		for (const atomKey of rootKeys) {
-			core.selectorAtoms = core.selectorAtoms.set({
+			target.selectorAtoms = target.selectorAtoms.set({
 				selectorKey,
 				atomKey,
 			})

package/internal/src/set-state/copy-mutable-if-needed.ts

@@ -2,19 +2,20 @@ import type { JsonInterface } from "atom.io/json"
 
 import type { Atom } from "../atom"
 import { Tracker } from "../mutable"
-import type { Store, StoreCore } from "../store"
+import type { Store } from "../store"
 
 export function copyMutableIfNeeded<T>(
 	atom: Atom<T>,
 	transform: JsonInterface<T>,
 	origin: Store,
-	target: StoreCore,
+	target: Store,
 ): T {
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)
 	if (originValue === targetValue) {
 		origin.logger.info(`📃`, `atom`, `${atom.key}`, `copying`)
-		const copiedValue = transform.fromJson(transform.toJson(originValue))
+		const jsonValue = transform.toJson(originValue)
+		const copiedValue = transform.fromJson(jsonValue)
 		target.valueMap.set(atom.key, copiedValue)
 		new Tracker(atom, origin)
 		return copiedValue

package/internal/src/set-state/copy-mutable-in-transaction.ts

@@ -1,7 +1,7 @@
 import type { AtomFamily } from "atom.io"
 import type { Json, JsonInterface } from "atom.io/json"
-import { readOrComputeValue } from ".."
-import type { Store, StoreCore } from ".."
+import { newest } from ".."
+import type { Store } from ".."
 import type { Atom } from "../atom"
 import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 
@@ -10,27 +10,21 @@ export function copyMutableIfWithinTransaction<T>(
 	atom: Atom<T> | (Atom<T> & JsonInterface<T, Json.Serializable>),
 	store: Store,
 ): T {
-	if (
-		store.transactionStatus.phase === `building` ||
-		store.transactionStatus.phase === `applying`
-	) {
+	const target = newest(store)
+	const parent = target.parent
+	if (parent !== null) {
 		if (`toJson` in atom && `fromJson` in atom) {
-			const copiedValue = copyMutableIfNeeded(
-				atom,
-				atom,
-				store,
-				store.transactionStatus.core,
-			)
+			const copiedValue = copyMutableIfNeeded(atom, atom, parent, target)
 			return copiedValue
 		}
 		if (`family` in atom) {
-			const family = store.transactionStatus.core.families.get(atom.family.key)
+			const family = parent.families.get(atom.family.key)
 			if (family && family.type === `atom_family`) {
 				const result = copyMutableFamilyMemberWithinTransaction<T>(
 					atom,
 					family,
-					store,
-					store.transactionStatus.core,
+					parent,
+					target,
 				)
 				if (result) {
 					return result
@@ -47,7 +41,7 @@ export function copyMutableFamilyMemberWithinTransaction<T>(
 		| AtomFamily<T, any>
 		| (AtomFamily<T, any> & JsonInterface<T, Json.Serializable>),
 	origin: Store,
-	target: StoreCore,
+	target: Store,
 ): T | null {
 	if (`toJson` in family && `fromJson` in family) {
 		const copyCreated = copyMutableIfNeeded(atom, family, origin, target)

package/internal/src/set-state/copy-mutable-into-new-store.ts

@@ -1,6 +1,6 @@
 import type { AtomFamily } from "atom.io"
 import type { Json, JsonInterface } from "atom.io/json"
-import type { Store, StoreCore } from ".."
+import type { Store } from ".."
 import type { Atom } from "../atom"
 import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 

package/internal/src/set-state/evict-downstream.ts

@@ -1,12 +1,12 @@
 import type { Atom } from "../atom"
 import { evictCachedValue } from "../caching"
+import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
-import { target } from "../transaction"
 
 export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
-	const core = target(store)
-	const downstreamKeys = core.selectorAtoms.getRelatedKeys(atom.key)
+	const target = newest(store)
+	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key)
 	store.logger.info(
 		`🧹`,
 		atom.type,
@@ -17,12 +17,12 @@ export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
 		downstreamKeys ?? `to evict`,
 	)
 	if (downstreamKeys) {
-		if (core.operation.open) {
+		if (target.operation.open) {
 			store.logger.info(
 				`🧹`,
 				atom.type,
 				atom.key,
-				`[ ${[...core.operation.done].join(`, `)} ] already done`,
+				`[ ${[...target.operation.done].join(`, `)} ] already done`,
 			)
 		}
 		for (const key of downstreamKeys) {

package/internal/src/set-state/set-atom.ts

@@ -1,6 +1,7 @@
 import type { Atom } from "../atom"
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
+import { newest } from "../lineage"
 import { markDone } from "../operation"
 import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
@@ -15,6 +16,7 @@ export const setAtom = <T>(
 	next: T | ((oldValue: T) => T),
 	store: Store,
 ): void => {
+	const target = newest(store)
 	const oldValue = readOrComputeValue(atom, store)
 	let newValue = copyMutableIfWithinTransaction(oldValue, atom, store)
 	newValue = become(next)(newValue)
@@ -26,7 +28,10 @@ export const setAtom = <T>(
 	markDone(atom.key, store)
 	evictDownStream(atom, store)
 	const update = { oldValue, newValue }
-	if (store.transactionStatus.phase !== `building`) {
+	if (
+		target.transactionMeta === null ||
+		target.transactionMeta.phase === `applying`
+	) {
 		emitUpdate(atom, update, store)
 	} else {
 		stowUpdate(atom, update, store)

package/internal/src/set-state/stow-update.ts

@@ -1,6 +1,7 @@
 import type { KeyedStateUpdate, StateUpdate } from "atom.io"
 
 import type { Atom } from "../atom"
+import { newest } from "../lineage"
 import { isTransceiver } from "../mutable"
 import type { Store } from "../store"
 
@@ -22,7 +23,11 @@ export const stowUpdate = <T>(
 	store: Store,
 ): void => {
 	const { key } = state
-	if (store.transactionStatus.phase !== `building`) {
+	const target = newest(store)
+	if (
+		target.transactionMeta === null ||
+		target.transactionMeta.phase !== `building`
+	) {
 		store.logger.error(
 			`🐞`,
 			`atom`,
@@ -39,7 +44,7 @@ export const stowUpdate = <T>(
 	if (state.family) {
 		atomUpdate.family = state.family
 	}
-	store.transactionStatus.atomUpdates.push(atomUpdate)
+	target.transactionMeta.update.updates.push(atomUpdate)
 	store.logger.info(
 		`📁`,
 		`atom`,

package/internal/src/store/store.ts

@@ -1,4 +1,4 @@
-import { AtomIOLogger, simpleLogger } from "atom.io"
+import { AtomIOLogger } from "atom.io"
 import type {
 	AtomFamily,
 	AtomToken,
@@ -15,31 +15,35 @@ import type {
 import { Junction } from "~/packages/rel8/junction/src"
 
 import type { Atom } from "../atom"
+import type { Lineage } from "../lineage"
 import type { MutableAtom, Tracker, Transceiver } from "../mutable"
 import type { OperationProgress } from "../operation"
 import type { ReadonlySelector, Selector } from "../selector"
-import { Subject } from "../subject"
+import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
-import type { Transaction, TransactionStatus } from "../transaction"
-
-export type StoreCore = Pick<
-	Store,
-	| `atoms`
-	| `atomsThatAreDefault`
-	| `families`
-	| `operation`
-	| `readonlySelectors`
-	| `selectorAtoms`
-	| `selectorGraph`
-	| `selectors`
-	| `timelineAtoms`
-	| `timelines`
-	| `trackers`
-	| `transactions`
-	| `valueMap`
->
-
-export class Store {
+import type { Transaction, TransactionMeta } from "../transaction"
+
+// export type StoreCore = Pick<
+// 	Store,
+// 	| `atoms`
+// 	| `atomsThatAreDefault`
+// 	| `families`
+// 	| `operation`
+// 	| `readonlySelectors`
+// 	| `selectorAtoms`
+// 	| `selectorGraph`
+// 	| `selectors`
+// 	| `timelineAtoms`
+// 	| `timelines`
+// 	| `trackers`
+// 	| `transactions`
+// 	| `valueMap`
+// >
+
+export class Store implements Lineage {
+	public parent: Store | null = null
+	public child: Store | null = null
+
 	public valueMap = new Map<string, any>()
 
 	public atoms = new Map<string, Atom<any> | MutableAtom<any>>()
@@ -88,10 +92,11 @@ export class Store {
 		>(),
 		transactionCreation: new Subject<TransactionToken<ƒn>>(),
 		timelineCreation: new Subject<TimelineToken>(),
+		transactionApplying: new StatefulSubject<TransactionMeta<ƒn> | null>(null),
 		operationStatus: new Subject<OperationProgress>(),
 	}
 	public operation: OperationProgress = { open: false }
-	public transactionStatus: TransactionStatus<ƒn> = { phase: `idle` }
+	public transactionMeta: TransactionMeta<ƒn> | null = null
 
 	public config: {
 		name: string
@@ -118,7 +123,9 @@ export class Store {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
-			this.transactionStatus = { ...store?.transactionStatus }
+			this.transactionMeta = store?.transactionMeta
+				? { ...store?.transactionMeta }
+				: null
 			this.config = {
 				...store?.config,
 				name,

package/internal/src/store/withdraw-new-family-member.ts

@@ -5,8 +5,7 @@ import type {
 	StateToken,
 } from "atom.io"
 import type { Atom, ReadonlySelector, Selector, Store } from ".."
-import { withdraw } from ".."
-import { target } from "../transaction"
+import { newest, withdraw } from ".."
 
 export function withdrawNewFamilyMember<T>(
 	token: AtomToken<T>,
@@ -43,8 +42,8 @@ export function withdrawNewFamilyMember<T>(
 			token.key,
 			`creating new family member in store "${store.config.name}"`,
 		)
-		const core = target(store)
-		const family = core.families.get(token.family.key)
+		const target = newest(store)
+		const family = target.families.get(token.family.key)
 		if (family) {
 			const jsonSubKey = JSON.parse(token.family.subKey)
 			family(jsonSubKey)

package/internal/src/store/withdraw.ts

@@ -9,11 +9,10 @@ import type {
 } from "atom.io"
 
 import type { Atom } from "../atom"
+import { newest } from "../lineage"
 import type { ReadonlySelector, Selector } from "../selector"
-import { addAtomToTimeline } from "../timeline"
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
-import { target } from "../transaction"
 import type { Store } from "./store"
 
 export function withdraw<T>(
@@ -58,67 +57,67 @@ export function withdraw<T>(
 	| Timeline
 	| Transaction<T extends ƒn ? T : never>
 	| undefined {
-	let core = target(store)
-	let state =
-		core.atoms.get(token.key) ??
-		core.selectors.get(token.key) ??
-		core.readonlySelectors.get(token.key) ??
-		core.transactions.get(token.key) ??
-		core.timelines.get(token.key)
+	const target = newest(store)
+	const state =
+		target.atoms.get(token.key) ??
+		target.selectors.get(token.key) ??
+		target.readonlySelectors.get(token.key) ??
+		target.transactions.get(token.key) ??
+		target.timelines.get(token.key)
 	if (state) {
 		return state
 	}
-	if (store.transactionStatus.phase === `applying`) {
-		core = store.transactionStatus.core
-		state =
-			core.atoms.get(token.key) ??
-			core.selectors.get(token.key) ??
-			core.readonlySelectors.get(token.key) ??
-			core.transactions.get(token.key) ??
-			core.timelines.get(token.key)
+	// if (target.transactionMeta?.phase === `applying`) {
 
-		if (state) {
-			store.logger.info(
-				`🛠️`,
-				token.type,
-				token.key,
-				`add ${token.type} "${token.key}"`,
-			)
-			switch (state.type) {
-				case `atom`: {
-					store.atoms.set(token.key, state)
-					store.valueMap.set(token.key, state.default)
-					const stateKey = state.key
-					const familyKey = state.family?.key
-					let timelineKey = core.timelineAtoms.getRelatedKey(stateKey)
-					if (timelineKey === undefined && typeof familyKey === `string`) {
-						timelineKey = core.timelineAtoms.getRelatedKey(familyKey)
-					}
-					const timeline =
-						typeof timelineKey === `string`
-							? store.timelines.get(timelineKey)
-							: undefined
+	// 	state =
+	// 		target.atoms.get(token.key) ??
+	// 		core.selectors.get(token.key) ??
+	// 		core.readonlySelectors.get(token.key) ??
+	// 		core.transactions.get(token.key) ??
+	// 		core.timelines.get(token.key)
 
-					if (timeline) {
-						addAtomToTimeline(state, timeline, store)
-					}
-					break
-				}
-				case `selector`:
-					core.selectors.set(token.key, state)
-					break
-				case `readonly_selector`:
-					core.readonlySelectors.set(token.key, state)
-					break
-				case `transaction`:
-					core.transactions.set(token.key, state)
-					break
-				case `timeline`:
-					core.timelines.set(token.key, state)
-					break
-			}
-			return state
-		}
-	}
+	// 	if (state) {
+	// 		store.logger.info(
+	// 			`🛠️`,
+	// 			token.type,
+	// 			token.key,
+	// 			`add ${token.type} "${token.key}"`,
+	// 		)
+	// 		switch (state.type) {
+	// 			case `atom`: {
+	// 				store.atoms.set(token.key, state)
+	// 				store.valueMap.set(token.key, state.default)
+	// 				const stateKey = state.key
+	// 				const familyKey = state.family?.key
+	// 				let timelineKey = core.timelineAtoms.getRelatedKey(stateKey)
+	// 				if (timelineKey === undefined && typeof familyKey === `string`) {
+	// 					timelineKey = core.timelineAtoms.getRelatedKey(familyKey)
+	// 				}
+	// 				const timeline =
+	// 					typeof timelineKey === `string`
+	// 						? store.timelines.get(timelineKey)
+	// 						: undefined
+
+	// 				if (timeline) {
+	// 					addAtomToTimeline(state, timeline, store)
+	// 				}
+	// 				break
+	// 			}
+	// 			case `selector`:
+	// 				core.selectors.set(token.key, state)
+	// 				break
+	// 			case `readonly_selector`:
+	// 				core.readonlySelectors.set(token.key, state)
+	// 				break
+	// 			case `transaction`:
+	// 				core.transactions.set(token.key, state)
+	// 				break
+	// 			case `timeline`:
+	// 				core.timelines.set(token.key, state)
+	// 				break
+	// 		}
+	// 		return state
+	// 	}
+	// }
 	return undefined
 }

package/internal/src/subject.ts

@@ -19,3 +19,17 @@ export class Subject<T> {
 		}
 	}
 }
+
+export class StatefulSubject<T> extends Subject<T> {
+	public state: T
+
+	public constructor(initialState: T) {
+		super()
+		this.state = initialState
+	}
+
+	public next(value: T): void {
+		this.state = value
+		super.next(value)
+	}
+}

package/internal/src/subscribe/index.ts

@@ -1 +1,4 @@
 export * from "./subscribe-to-root-atoms"
+export * from "./subscribe-to-state"
+export * from "./subscribe-to-timeline"
+export * from "./subscribe-to-transaction"

package/internal/src/subscribe/recall-state.ts

@@ -1,21 +1,15 @@
 import type { Atom } from "../atom"
+import { newest } from "../lineage"
 import type { ReadonlySelector, Selector } from "../selector"
 import type { Store } from "../store"
-import { target } from "../transaction"
 
 export const recallState = <T>(
 	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
 	store: Store,
 ): T => {
-	const core = target(store)
-	if (!core.operation.open) {
-		store.logger.warn(
-			`🐞`,
-			state.type,
-			state.key,
-			`recall called outside of an operation. This is probably a bug.`,
-		)
-		return core.valueMap.get(state.key)
+	const target = newest(store)
+	if (!target.operation.open) {
+		return target.valueMap.get(state.key)
 	}
-	return core.operation.prev.get(state.key)
+	return target.operation.prev.get(state.key)
 }

package/internal/src/subscribe/subscribe-to-state.ts

@@ -0,0 +1,47 @@
+import type { ReadonlySelectorToken, StateToken, UpdateHandler } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { subscribeToRootAtoms, withdraw } from "atom.io/internal"
+
+export function subscribeToState<T>(
+	token: ReadonlySelectorToken<T> | StateToken<T>,
+	handleUpdate: UpdateHandler<T>,
+	key: string,
+	store: Store,
+): () => void {
+	const state = withdraw<T>(token, store)
+	if (state === undefined) {
+		throw new Error(
+			`State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
+		)
+	}
+	const unsubFunction = state.subject.subscribe(key, handleUpdate)
+	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`)
+	const dependencyUnsubFunctions =
+		state.type !== `atom` ? subscribeToRootAtoms(state, store) : null
+
+	const unsubscribe =
+		dependencyUnsubFunctions === null
+			? () => {
+					store.logger.info(
+						`🙈`,
+						state.type,
+						state.key,
+						`Removing subscription "${key}"`,
+					)
+					unsubFunction()
+			  }
+			: () => {
+					store.logger.info(
+						`🙈`,
+						state.type,
+						state.key,
+						`Removing subscription "${key}"`,
+					)
+					unsubFunction()
+					for (const unsubFromDependency of dependencyUnsubFunctions) {
+						unsubFromDependency()
+					}
+			  }
+
+	return unsubscribe
+}

package/internal/src/subscribe/subscribe-to-timeline.ts

@@ -0,0 +1,28 @@
+import type { TimelineToken, TimelineUpdate } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { withdraw } from "atom.io/internal"
+
+export const subscribeToTimeline = (
+	token: TimelineToken,
+	handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void,
+	key: string,
+	store: Store,
+): (() => void) => {
+	const tl = withdraw(token, store)
+	if (tl === undefined) {
+		throw new Error(
+			`Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`,
+		)
+	}
+	store.logger.info(`👀`, `timeline`, token.key, `Adding subscription "${key}"`)
+	const unsubscribe = tl.subject.subscribe(key, handleUpdate)
+	return () => {
+		store.logger.info(
+			`🙈`,
+			`timeline`,
+			token.key,
+			`Removing subscription "${key}" from timeline`,
+		)
+		unsubscribe()
+	}
+}

package/internal/src/subscribe/subscribe-to-transaction.ts

@@ -0,0 +1,33 @@
+import type { TransactionToken, TransactionUpdateHandler, ƒn } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { withdraw } from "atom.io/internal"
+
+export const subscribeToTransaction = <ƒ extends ƒn>(
+	token: TransactionToken<ƒ>,
+	handleUpdate: TransactionUpdateHandler<ƒ>,
+	key: string,
+	store: Store,
+): (() => void) => {
+	const tx = withdraw(token, store)
+	if (tx === undefined) {
+		throw new Error(
+			`Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`,
+		)
+	}
+	store.logger.info(
+		`👀`,
+		`transaction`,
+		token.key,
+		`Adding subscription "${key}"`,
+	)
+	const unsubscribe = tx.subject.subscribe(key, handleUpdate)
+	return () => {
+		store.logger.info(
+			`🙈`,
+			`transaction`,
+			token.key,
+			`Removing subscription "${key}"`,
+		)
+		unsubscribe()
+	}
+}