atom.io 0.16.2 → 0.17.0

package/internal/src/atom/create-regular-atom.ts

@@ -5,9 +5,8 @@ import type {
 	RegularAtomToken,
 	UpdateHandler,
 } from "atom.io"
-import { setState } from "atom.io"
 
-import type { RegularAtom } from ".."
+import { type RegularAtom, setIntoStore } from ".."
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -69,7 +68,7 @@ export function createRegularAtom<T>(
 		const cleanupFunctions: (() => void)[] = []
 		for (const effect of options.effects) {
 			const cleanup = effect({
-				setSelf: (next) => setState(token, next, store),
+				setSelf: (next) => setIntoStore(token, next, store),
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
 			})

package/internal/src/families/find-in-store.ts

@@ -0,0 +1,74 @@
+import type { Json } from "atom.io/json"
+
+import type {
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Transceiver } from "../mutable"
+import { NotFoundError } from "../not-found-error"
+import type { Store } from "../store"
+
+export function findInStore<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+	Key extends K,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	key: Key,
+	store: Store,
+): MutableAtomToken<T, J>
+
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): RegularAtomToken<T>
+
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableSelectorToken<T>
+
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadonlySelectorToken<T>
+
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableToken<T>
+
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadableToken<T>
+
+export function findInStore(
+	token: ReadableFamilyToken<any, any>,
+	key: Json.Serializable,
+	store: Store,
+): ReadableToken<any> {
+	const familyKey = token.key
+	const family = store.families.get(familyKey)
+	if (family === undefined) {
+		throw new NotFoundError(token, store)
+	}
+	const state = family(key)
+	return state
+}

package/internal/src/families/index.ts

@@ -2,3 +2,4 @@ export * from "./create-atom-family"
 export * from "./create-regular-atom-family"
 export * from "./create-readonly-selector-family"
 export * from "./create-selector-family"
+export * from "./find-in-store"

package/internal/src/get-state/get-from-store.ts

@@ -0,0 +1,14 @@
+import type { ReadableToken } from "atom.io"
+
+import { NotFoundError } from "../not-found-error"
+import type { Store } from "../store"
+import { withdraw, withdrawNewFamilyMember } from "../store"
+import { readOrComputeValue } from "./read-or-compute-value"
+
+export function getFromStore<T>(token: ReadableToken<T>, store: Store): T {
+	const state = withdraw(token, store) ?? withdrawNewFamilyMember(token, store)
+	if (state === undefined) {
+		throw new NotFoundError(token, store)
+	}
+	return readOrComputeValue(state, store)
+}

package/internal/src/get-state/index.ts

@@ -0,0 +1,2 @@
+export * from "./get-from-store"
+export * from "./read-or-compute-value"

package/internal/src/{read-or-compute-value.ts → get-state/read-or-compute-value.ts}

@@ -1,6 +1,6 @@
-import type { ReadableState } from "."
-import { readCachedValue } from "./caching"
-import type { Store } from "./store"
+import type { ReadableState } from ".."
+import { readCachedValue } from "../caching"
+import type { Store } from "../store"
 
 export const readOrComputeValue = <T>(
 	state: ReadableState<T>,

package/internal/src/index.ts

@@ -11,13 +11,13 @@ export * from "./lineage"
 export * from "./families"
 export * from "./future"
 export * from "./get-environment-data"
+export * from "./get-state"
 export * from "./ingest-updates"
 export * from "./keys"
 export * from "./lazy-map"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
-export * from "./read-or-compute-value"
 export * from "./selector"
 export * from "./set-state"
 export * from "./store"

package/internal/src/ingest-updates/ingest-atom-update.ts

@@ -1,6 +1,6 @@
 import type { KeyedStateUpdate } from "atom.io"
-import { setState } from "atom.io"
 
+import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 
 export function ingestAtomUpdate(
@@ -10,5 +10,5 @@ export function ingestAtomUpdate(
 ): void {
 	const { key, newValue, oldValue } = atomUpdate
 	const value = applying === `newValue` ? newValue : oldValue
-	setState({ key, type: `atom` }, value, store)
+	setIntoStore({ key, type: `atom` }, value, store)
 }

package/internal/src/ingest-updates/ingest-transaction-update.ts

@@ -1,6 +1,7 @@
 import type { TransactionUpdate } from "atom.io"
 
 import type { Store } from "../store"
+import { isRootStore } from "../transaction/is-root-store"
 import { ingestAtomUpdate } from "./ingest-atom-update"
 
 export function ingestTransactionUpdate(

package/internal/src/mutable/create-mutable-atom.ts

@@ -4,12 +4,11 @@ import type {
 	MutableAtomOptions,
 	MutableAtomToken,
 } from "atom.io"
-import { setState } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
-import { type MutableAtom, cacheValue } from ".."
-import { createRegularAtom, markAtomAsDefault } from "../atom"
+import { type MutableAtom, cacheValue, setIntoStore } from ".."
+import { markAtomAsDefault } from "../atom"
 import { newest } from "../lineage"
 import { type Store, deposit } from "../store"
 import { Subject } from "../subject"
@@ -70,7 +69,7 @@ export function createMutableAtom<
 		const cleanupFunctions: (() => void)[] = []
 		for (const effect of options.effects) {
 			const cleanup = effect({
-				setSelf: (next) => setState(token, next, store),
+				setSelf: (next) => setIntoStore(token, next, store),
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
 			})

package/internal/src/mutable/tracker.ts

@@ -1,10 +1,16 @@
 import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
-import { getState, setState } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
-import { newest, subscribeToState, subscribeToTimeline } from ".."
+import {
+	getFromStore,
+	newest,
+	setIntoStore,
+	subscribeToState,
+	subscribeToTimeline,
+} from ".."
 import { createRegularAtom } from "../atom"
+import { isChildStore } from "../transaction/is-root-store"
 import type { Transceiver } from "./transceiver"
 
 /**
@@ -51,31 +57,26 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	private observeCore(
 		mutableState: MutableAtomToken<Mutable, any>,
 		latestUpdateState: RegularAtomToken<typeof this.Update | null>,
-		store: Store,
+		target: Store,
 	): void {
-		const subscriptionKey = `tracker:${store.config.name}:${
-			store.transactionMeta === null ? `main` : store.transactionMeta.update.key
+		const subscriptionKey = `tracker:${target.config.name}:${
+			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
-		const originalInnerValue = getState(mutableState, store)
-		const target = newest(store)
+		const originalInnerValue = getFromStore(mutableState, target)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
-			`tracker:${store.config.name}:${
-				target.transactionMeta === null
-					? `main`
-					: target.transactionMeta.update.key
-			}`,
+			subscriptionKey,
 			(update) => {
 				if (target.operation.open) {
 					const unsubscribe = target.on.operationClose.subscribe(
 						subscriptionKey,
 						() => {
 							unsubscribe()
-							setState(latestUpdateState, update, target)
+							setIntoStore(latestUpdateState, update, target)
 						},
 					)
 				} else {
-					setState(mutableState, (current) => current, target)
-					setState(latestUpdateState, update, target)
+					setIntoStore(mutableState, (current) => current, target)
+					setIntoStore(latestUpdateState, update, target)
 				}
 			},
 		)
@@ -84,7 +85,6 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			(update) => {
 				if (update.newValue !== update.oldValue) {
 					this.unsubscribeFromInnerValue()
-					const target = newest(store)
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
 						(update) => {
@@ -93,44 +93,45 @@ export class Tracker<Mutable extends Transceiver<any>> {
 									subscriptionKey,
 									() => {
 										unsubscribe()
-										setState(latestUpdateState, update, target)
+										setIntoStore(latestUpdateState, update, target)
 									},
 								)
 							} else {
-								setState(mutableState, (current) => current, target)
-								setState(latestUpdateState, update, target)
+								setIntoStore(mutableState, (current) => current, target)
+								setIntoStore(latestUpdateState, update, target)
 							}
 						},
 					)
 				}
 			},
 			subscriptionKey,
-			store,
+			target,
 		)
 	}
 
 	private updateCore<Core extends Transceiver<any>>(
 		mutableState: MutableAtomToken<Core, Json.Serializable>,
 		latestUpdateState: RegularAtomToken<typeof this.Update | null>,
-		store: Store,
+		target: Store,
 	): void {
-		const subscriptionKey = `tracker:${store.config.name}:${
-			store.transactionMeta === null ? `main` : store.transactionMeta.update.key
+		const subscriptionKey = `tracker:${target.config.name}:${
+			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
 		subscribeToState(
 			latestUpdateState,
 			({ newValue, oldValue }) => {
-				const timelineId = store.timelineAtoms.getRelatedKey(
+				const timelineId = target.timelineAtoms.getRelatedKey(
 					latestUpdateState.key,
 				)
+
 				if (timelineId) {
-					const timelineData = store.timelines.get(timelineId)
+					const timelineData = target.timelines.get(timelineId)
 					if (timelineData?.timeTraveling) {
 						const unsubscribe = subscribeToTimeline(
 							{ key: timelineId, type: `timeline` },
 							(update) => {
 								unsubscribe()
-								setState(
+								setIntoStore(
 									mutableState,
 									(transceiver) => {
 										if (update === `redo` && newValue) {
@@ -140,38 +141,45 @@ export class Tracker<Mutable extends Transceiver<any>> {
 										}
 										return transceiver
 									},
-									store,
+									target,
 								)
 							},
 							subscriptionKey,
-							store,
+							target,
 						)
 						return
 					}
 				}
 
-				const unsubscribe = store.on.operationClose.subscribe(
+				const unsubscribe = target.on.operationClose.subscribe(
 					subscriptionKey,
 					() => {
 						unsubscribe()
-						const mutable = getState(mutableState, store)
-						// debugger
+						const mutable = getFromStore(mutableState, target)
 						const updateNumber =
 							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
 						const eventOffset = updateNumber - mutable.cacheUpdateNumber
 						if (newValue && eventOffset === 1) {
-							// ❗ new:"0=add:\"myHand\"",old:"0=add:\"deckId\""
-							setState(
+							setIntoStore(
 								mutableState,
 								(transceiver) => (transceiver.do(newValue), transceiver),
-								store,
+								target,
+							)
+						} else {
+							target.logger.info(
+								`❌`,
+								`mutable_atom`,
+								mutableState.key,
+								`could not be updated. Expected update number ${
+									mutable.cacheUpdateNumber + 1
+								}, but got ${updateNumber}`,
 							)
 						}
 					},
 				)
 			},
 			subscriptionKey,
-			store,
+			target,
 		)
 	}
 

package/internal/src/mutable/transceiver.ts

@@ -1,7 +1,7 @@
 import type { Json } from "atom.io/json"
 
 export interface Transceiver<Signal extends Json.Serializable> {
-	do: (update: Signal) => void
+	do: (update: Signal) => number | `OUT_OF_RANGE` | null
 	undo: (update: Signal) => void
 	subscribe: (key: string, fn: (update: Signal) => void) => () => void
 	cacheUpdateNumber: number

package/internal/src/not-found-error.ts

@@ -1,10 +1,21 @@
-import type { ReadableToken } from "atom.io"
+import type {
+	ReadableFamilyToken,
+	ReadableToken,
+	TimelineToken,
+	TransactionToken,
+} from "atom.io"
 
 import type { Store } from "./store"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 
-function prettyPrintTokenType(token: ReadableToken<any>) {
+type AtomIOToken =
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TimelineToken<any>
+	| TransactionToken<any>
+
+function prettyPrintTokenType(token: AtomIOToken) {
 	if (token.type === `readonly_selector`) {
 		return `Readonly Selector`
 	}
@@ -12,7 +23,7 @@ function prettyPrintTokenType(token: ReadableToken<any>) {
 }
 
 export class NotFoundError extends Error {
-	public constructor(token: ReadableToken<any>, store: Store) {
+	public constructor(token: AtomIOToken, store: Store) {
 		super(
 			`${prettyPrintTokenType(token)} "${token.key}" not found in store "${
 				store.config.name

package/internal/src/operation.ts

@@ -2,6 +2,7 @@ import type { WritableToken } from "atom.io"
 
 import { newest } from "./lineage"
 import type { Store } from "./store"
+import { isChildStore } from "./transaction/is-root-store"
 
 export type OperationProgress =
 	| {
@@ -40,7 +41,7 @@ export const openOperation = (
 		token.type,
 		token.key,
 		`operation start in store "${store.config.name}"${
-			store.transactionMeta === null
+			!isChildStore(store)
 				? ``
 				: ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`
 		}`,

package/internal/src/selector/create-writable-selector.ts

@@ -11,6 +11,7 @@ import { markDone } from "../operation"
 import { become } from "../set-state/become"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import { isRootStore } from "../transaction/is-root-store"
 import { registerSelector } from "./register-selector"
 
 export const createWritableSelector = <T>(
@@ -45,7 +46,7 @@ export const createWritableSelector = <T>(
 		)
 		cacheValue(options.key, newValue, subject, store)
 		markDone(options.key, store)
-		if (target.transactionMeta === null) {
+		if (isRootStore(target)) {
 			subject.next({ newValue, oldValue })
 		}
 		options.set(transactors, newValue)

package/internal/src/selector/register-selector.ts

@@ -1,11 +1,11 @@
 import type { Transactors, findState } from "atom.io"
-import { findInStore } from "atom.io"
 
+import { findInStore } from "../families"
+import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
-import { readOrComputeValue } from "../read-or-compute-value"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
-import { withdraw } from "../store"
+import { withdraw, withdrawNewFamilyMember } from "../store"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
@@ -15,10 +15,11 @@ export const registerSelector = (
 	get: (dependency) => {
 		const target = newest(store)
 
-		const dependencyState = withdraw(dependency, store)
+		const dependencyState =
+			withdraw(dependency, store) ?? withdrawNewFamilyMember(dependency, store)
 		if (dependencyState === undefined) {
 			throw new Error(
-				`State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
+				`State "${dependency.key}" not found in store "${store.config.name}".`,
 			)
 		}
 		const dependencyValue = readOrComputeValue(dependencyState, store)

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

@@ -1,2 +1,3 @@
 export * from "./become"
 export * from "./set-atom-or-selector"
+export * from "./set-into-store"

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

@@ -1,10 +1,11 @@
 import type { Atom } from ".."
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
+import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import type { Transceiver } from "../mutable"
 import { markDone } from "../operation"
-import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
+import { isRootStore } from "../transaction/is-root-store"
 import { become } from "./become"
 import { copyMutableIfWithinTransaction } from "./copy-mutable-in-transaction"
 import { emitUpdate } from "./emit-update"
@@ -27,7 +28,7 @@ export const setAtom = <T>(
 	markDone(atom.key, target)
 	evictDownStream(atom, target)
 	const update = { oldValue, newValue }
-	if (target.transactionMeta === null) {
+	if (isRootStore(target)) {
 		emitUpdate(atom, update, target)
 	} else if (target.parent) {
 		if (target.on.transactionApplying.state === null) {
@@ -37,7 +38,20 @@ export const setAtom = <T>(
 			const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
 			let mutable: Transceiver<any> = target.valueMap.get(mutableKey)
 			mutable = copyMutableIfWithinTransaction(mutable, mutableAtom, target)
-			mutable.do(update.newValue)
+			const output = mutable.do(update.newValue)
+			if (output !== null) {
+				target.logger.warn(
+					`❌`,
+					`mutable_atom`,
+					mutableKey,
+					`could not be updated.`,
+					typeof output === `number`
+						? `Expected update number ${
+								mutable.cacheUpdateNumber + 1
+						  }, but got ${output}`
+						: output,
+				)
+			}
 		}
 	}
 }

package/internal/src/set-state/set-into-store.ts

@@ -0,0 +1,24 @@
+import type { WritableToken } from "atom.io"
+
+import { NotFoundError } from "../not-found-error"
+import { closeOperation, openOperation } from "../operation"
+import type { Store } from "../store"
+import { withdraw, withdrawNewFamilyMember } from "../store"
+import { setAtomOrSelector } from "./set-atom-or-selector"
+
+export function setIntoStore<T, New extends T>(
+	token: WritableToken<T>,
+	value: New | ((oldValue: T) => New),
+	store: Store,
+): void {
+	const rejection = openOperation(token, store)
+	if (rejection) {
+		return
+	}
+	const state = withdraw(token, store) ?? withdrawNewFamilyMember(token, store)
+	if (state === undefined) {
+		throw new NotFoundError(token, store)
+	}
+	setAtomOrSelector(state, value, store)
+	closeOperation(store)
+}

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

@@ -4,6 +4,7 @@ import type { Atom } from ".."
 import { newest } from "../lineage"
 import { isTransceiver } from "../mutable"
 import type { Store } from "../store"
+import { isChildStore } from "../transaction/is-root-store"
 
 function shouldUpdateBeStowed(key: string, update: StateUpdate<any>): boolean {
 	// do not stow updates that aren't json
@@ -24,10 +25,7 @@ export const stowUpdate = <T>(
 ): void => {
 	const { key } = state
 	const target = newest(store)
-	if (
-		target.transactionMeta === null ||
-		target.transactionMeta.phase !== `building`
-	) {
+	if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
 		store.logger.error(
 			`🐞`,
 			`atom`,

package/internal/src/store/store.ts

@@ -27,7 +27,11 @@ import { getJsonToken, getUpdateToken } from "../mutable"
 import type { OperationProgress } from "../operation"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
-import type { Transaction, TransactionMeta } from "../transaction"
+import type {
+	Transaction,
+	TransactionEpoch,
+	TransactionProgress,
+} from "../transaction"
 
 export class Store implements Lineage {
 	public parent: Store | null = null
@@ -82,11 +86,15 @@ export class Store implements Lineage {
 		>(),
 		transactionCreation: new Subject<TransactionToken<ƒn>>(),
 		timelineCreation: new Subject<TimelineToken<unknown>>(),
-		transactionApplying: new StatefulSubject<TransactionMeta<ƒn> | null>(null),
+		transactionApplying: new StatefulSubject<TransactionProgress<ƒn> | null>(
+			null,
+		),
 		operationClose: new Subject<OperationProgress>(),
 	}
 	public operation: OperationProgress = { open: false }
-	public transactionMeta: TransactionMeta<ƒn> | null = null
+	public transactionMeta: TransactionEpoch | TransactionProgress<ƒn> = {
+		epoch: -1,
+	}
 
 	public config: {
 		name: string
@@ -113,7 +121,8 @@ export class Store implements Lineage {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
-			this.transactionMeta = null
+			this.transactionMeta = { ...store?.transactionMeta }
+
 			this.config = {
 				...store?.config,
 				name,

package/internal/src/subscribe/subscribe-to-root-atoms.ts

@@ -1,6 +1,6 @@
 import type { Selector } from ".."
+import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
-import { readOrComputeValue } from "../read-or-compute-value"
 import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { recallState } from "./recall-state"

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -30,7 +30,6 @@ export const addAtomToTimeline = (
 	store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key })
 
 	atom.subject.subscribe(`timeline`, (update) => {
-		// debugger
 		const target = newest(store)
 		const currentSelectorKey =
 			store.operation.open && store.operation.token.type === `selector`
@@ -40,8 +39,9 @@ export const addAtomToTimeline = (
 			store.operation.open && store.operation.token.type === `selector`
 				? store.operation.time
 				: null
-		const currentTransactionKey = target.on.transactionApplying.state?.update.key
-		const currentTransactionTime = target.on.transactionApplying.state?.time
+		const { transactionApplying } = target.on
+		const currentTransactionKey = transactionApplying.state?.update.key
+		const currentTransactionInstanceId = transactionApplying.state?.update.id
 
 		store.logger.info(
 			`⏳`,
@@ -93,7 +93,7 @@ export const addAtomToTimeline = (
 						`timeline:${tl.key}`,
 						(update) => {
 							unsubscribe()
-							if (tl.timeTraveling === null && currentTransactionTime) {
+							if (tl.timeTraveling === null && currentTransactionInstanceId) {
 								if (tl.at !== tl.history.length) {
 									tl.history.splice(tl.at)
 								}
@@ -132,7 +132,7 @@ export const addAtomToTimeline = (
 
 								const timelineTransactionUpdate: TimelineTransactionUpdate = {
 									type: `transaction_update`,
-									timestamp: currentTransactionTime,
+									timestamp: Date.now(),
 									...update,
 									updates,
 								}