atom.io 0.16.1 → 0.16.3

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/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/tracker.ts

@@ -5,6 +5,7 @@ import type { Json } from "atom.io/json"
 import type { Store } from ".."
 import { newest, subscribeToState, subscribeToTimeline } from ".."
 import { createRegularAtom } from "../atom"
+import { isChildStore, isRootStore } from "../transaction/is-root-store"
 import type { Transceiver } from "./transceiver"
 
 /**
@@ -51,20 +52,18 @@ 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 originalInnerValue = getState(mutableState, store)
-		const target = newest(store)
+		const subscriptionKey = `tracker:${target.config.name}:${
+			isChildStore(target) ? target.transactionMeta.update.key : `main`
+		}:${mutableState.key}`
+		const originalInnerValue = getState(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(
-						mutableState.key,
+						subscriptionKey,
 						() => {
 							unsubscribe()
 							setState(latestUpdateState, update, target)
@@ -81,17 +80,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			(update) => {
 				if (update.newValue !== update.oldValue) {
 					this.unsubscribeFromInnerValue()
-					const target = newest(store)
 					this.unsubscribeFromInnerValue = update.newValue.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(
-									mutableState.key,
+									subscriptionKey,
 									() => {
 										unsubscribe()
 										setState(latestUpdateState, update, target)
@@ -105,24 +99,28 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					)
 				}
 			},
-			`${store.config.name}: tracker observing inner value`,
-			store,
+			subscriptionKey,
+			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:${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` },
@@ -138,38 +136,45 @@ export class Tracker<Mutable extends Transceiver<any>> {
 										}
 										return transceiver
 									},
-									store,
+									target,
 								)
 							},
-							`${mutableState.key}: tracker observing timeline`,
-							store,
+							subscriptionKey,
+							target,
 						)
 						return
 					}
 				}
 
-				const unsubscribe = store.on.operationClose.subscribe(
-					latestUpdateState.key,
+				const unsubscribe = target.on.operationClose.subscribe(
+					subscriptionKey,
 					() => {
 						unsubscribe()
-						const mutable = getState(mutableState, store)
-						// debugger
+						const mutable = getState(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(
 								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}`,
 							)
 						}
 					},
 				)
 			},
-			`${store.config.name}: tracker observing latest update`,
-			store,
+			subscriptionKey,
+			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 { 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/set-atom.ts

@@ -5,6 +5,7 @@ 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,14 +28,30 @@ 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.on.transactionApplying && target.parent) {
-		stowUpdate(atom, update, target)
-		if (atom.key.startsWith(`*`)) {
+	} else if (target.parent) {
+		if (target.on.transactionApplying.state === null) {
+			stowUpdate(atom, update, target)
+		} else if (atom.key.startsWith(`*`)) {
 			const mutableKey = atom.key.slice(1)
-			const mutable: Transceiver<any> = target.valueMap.get(mutableKey)
-			mutable.do(update.newValue)
+			const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
+			let mutable: Transceiver<any> = target.valueMap.get(mutableKey)
+			mutable = copyMutableIfWithinTransaction(mutable, mutableAtom, target)
+			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/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/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,
 								}

package/internal/src/transaction/abort-transaction.ts

@@ -1,9 +1,10 @@
 import { newest } from "../lineage"
 import type { Store } from "../store"
+import { isChildStore } from "./is-root-store"
 
 export const abortTransaction = (store: Store): void => {
 	const target = newest(store)
-	if (target.transactionMeta === null || target.parent === null) {
+	if (!isChildStore(target)) {
 		store.logger.warn(
 			`🐞`,
 			`transaction`,

package/internal/src/transaction/apply-transaction.ts

@@ -4,6 +4,7 @@ import { ingestTransactionUpdate } from "../ingest-updates"
 import { newest } from "../lineage"
 import { withdraw } from "../store"
 import type { Store } from "../store"
+import { isChildStore, isRootStore } from "./is-root-store"
 
 export const applyTransaction = <ƒ extends ƒn>(
 	output: ReturnType<ƒ>,
@@ -13,7 +14,7 @@ export const applyTransaction = <ƒ extends ƒn>(
 	const { parent } = child
 	if (
 		parent === null ||
-		child.transactionMeta === null ||
+		!isChildStore(child) ||
 		child.transactionMeta?.phase !== `building`
 	) {
 		store.logger.warn(
@@ -57,7 +58,8 @@ export const applyTransaction = <ƒ extends ƒn>(
 		}
 	}
 	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent)
-	if (parent.transactionMeta === null) {
+	if (isRootStore(parent)) {
+		parent.transactionMeta.epoch = child.transactionMeta.update.epoch
 		const myTransaction = withdraw<ƒ>(
 			{ key: child.transactionMeta.update.key, type: `transaction` },
 			store,
@@ -69,7 +71,7 @@ export const applyTransaction = <ƒ extends ƒn>(
 			child.transactionMeta.update.key,
 			`Finished applying transaction.`,
 		)
-	} else {
+	} else if (isChildStore(parent)) {
 		parent.transactionMeta.update.updates.push(child.transactionMeta.update)
 	}
 	parent.on.transactionApplying.next(null)

package/internal/src/transaction/build-transaction.ts

@@ -1,28 +1,31 @@
-import { findInStore, getState, runTransaction, setState } from "atom.io"
-import type { findState } from "atom.io"
+import { getState, runTransaction, setState } from "atom.io"
+import type { findState, ƒn } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
+import type { TransactionProgress } from "."
+import { findInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
 import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import type { Store } from "../store"
+import type { ChildStore, RootStore } from "./is-root-store"
+import { isRootStore } from "./is-root-store"
 
 export const buildTransaction = (
 	key: string,
 	params: any[],
 	store: Store,
 	id?: string,
-): void => {
-	const parent = newest(store)
-	const child: Store = {
+): ChildStore => {
+	const parent = newest(store) as ChildStore | RootStore
+	const childBase: Omit<ChildStore, `transactionMeta`> = {
 		parent,
 		child: null,
 		on: parent.on,
 		loggers: parent.loggers,
 		logger: parent.logger,
 		config: parent.config,
-		transactionMeta: null,
 		atoms: new LazyMap(parent.atoms),
 		atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
 		families: new LazyMap(parent.families),
@@ -39,12 +42,12 @@ export const buildTransaction = (
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
 	}
-	child.transactionMeta = {
-		phase: `building`,
-		time: Date.now(),
+	const transactionMeta: TransactionProgress<ƒn> = {
+		phase: `building` as const,
 		update: {
 			key,
 			id: id ?? Math.random().toString(36).slice(2),
+			epoch: isRootStore(parent) ? parent.transactionMeta.epoch + 1 : NaN,
 			updates: [],
 			params,
 			output: undefined,
@@ -52,11 +55,14 @@ export const buildTransaction = (
 		transactors: {
 			get: (token) => getState(token, child),
 			set: (token, value) => setState(token, value, child),
-			run: (token) => runTransaction(token, child),
+			run: (token, id) => runTransaction(token, id, child),
 			find: ((token, key) => findInStore(token, key, child)) as typeof findState,
 			env: () => getEnvironmentData(child),
 		},
 	}
+	const child: ChildStore = Object.assign(childBase, {
+		transactionMeta,
+	})
 	parent.child = child
 	store.logger.info(
 		`🛫`,
@@ -65,4 +71,5 @@ export const buildTransaction = (
 		`Building transaction with params:`,
 		params,
 	)
+	return child
 }

package/internal/src/transaction/create-transaction.ts

@@ -29,11 +29,10 @@ export function createTransaction<ƒ extends ƒn>(
 		key: options.key,
 		type: `transaction`,
 		run: (params: Parameters<ƒ>, id?: string) => {
-			buildTransaction(options.key, params, store, id)
+			const childStore = buildTransaction(options.key, params, store, id)
 			try {
 				const target = newest(store)
-				// biome-ignore lint/style/noNonNullAssertion: this happens right above
-				const { transactors } = target.transactionMeta!
+				const { transactors } = childStore.transactionMeta
 				const output = options.do(transactors, ...params)
 				applyTransaction(output, target)
 				return output

package/internal/src/transaction/index.ts

@@ -8,9 +8,10 @@ export * from "./create-transaction"
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
 export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
 
-export type TransactionMeta<ƒ extends ƒn> = {
+export type TransactionProgress<ƒ extends ƒn> = {
 	phase: `applying` | `building`
-	time: number
 	update: TransactionUpdate<ƒ>
 	transactors: TransactorsWithRunAndEnv
 }
+
+export type TransactionEpoch = { epoch: number }

package/internal/src/transaction/is-root-store.ts

@@ -0,0 +1,23 @@
+import type { ƒn } from "atom.io"
+
+import type { TransactionEpoch, TransactionProgress } from "."
+import type { Store } from "../store"
+
+export interface RootStore extends Store {
+	transactionMeta: TransactionEpoch
+	parent: null
+	child: ChildStore | null
+}
+export interface ChildStore extends Store {
+	transactionMeta: TransactionProgress<ƒn>
+	parent: ChildStore | RootStore
+	child: ChildStore | null
+}
+
+export function isRootStore(store: Store): store is RootStore {
+	return `epoch` in store.transactionMeta
+}
+
+export function isChildStore(store: Store): store is ChildStore {
+	return `phase` in store.transactionMeta
+}