atom.io 0.11.0 → 0.12.0

package/internal/src/mutable/tracker-family.ts

@@ -4,7 +4,6 @@ import { parseJson } from "atom.io/json"
 
 import { createAtomFamily } from "../families"
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
@@ -24,7 +23,7 @@ export class FamilyTracker<
 
 	public constructor(
 		findMutableState: AtomFamily<Core, FamilyMemberKey>,
-		store: Store = IMPLICIT.STORE,
+		store: Store,
 	) {
 		this.findLatestUpdateState = createAtomFamily<
 			typeof this.Update | null,

package/internal/src/mutable/tracker.ts

@@ -3,7 +3,6 @@ import { getState, setState, subscribe, subscribeToTimeline } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
-import { IMPLICIT } from ".."
 import { createAtom, deleteAtom } from "../atom"
 import { target } from "../transaction"
 import type { Transceiver } from "./transceiver"
@@ -18,7 +17,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 
 	private initializeState(
 		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
-		store: Store = IMPLICIT.STORE,
+		store: Store,
 	): AtomToken<typeof this.Update | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
 		deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store)
@@ -46,7 +45,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	private observeCore(
 		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
 		latestUpdateState: AtomToken<typeof this.Update | null>,
-		store: Store = IMPLICIT.STORE,
+		store: Store,
 	): void {
 		const originalInnerValue = getState(mutableState, store)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
@@ -96,7 +95,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	private updateCore<Core extends Transceiver<any>>(
 		mutableState: MutableAtomToken<Core, Json.Serializable>,
 		latestUpdateState: AtomToken<typeof this.Update | null>,
-		store: Store = IMPLICIT.STORE,
+		store: Store,
 	): void {
 		subscribe(
 			latestUpdateState,
@@ -133,7 +132,10 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					latestUpdateState.key,
 					() => {
 						unsubscribe()
-						if (newValue) {
+						const mutable = getState(mutableState, store)
+						const updateNumber = mutable.getUpdateNumber(newValue)
+						const eventOffset = updateNumber - mutable.cacheUpdateNumber
+						if (newValue && eventOffset === 1) {
 							setState(
 								mutableState,
 								(transceiver) => (transceiver.do(newValue), transceiver),
@@ -153,7 +155,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 
 	public constructor(
 		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
-		store: Store = IMPLICIT.STORE,
+		store: Store,
 	) {
 		this.mutableState = mutableState
 		this.latestUpdateState = this.initializeState(mutableState, store)

package/internal/src/mutable/transceiver.ts

@@ -4,6 +4,8 @@ export interface Transceiver<Signal extends Json.Serializable> {
 	do: (update: Signal) => void
 	undo: (update: Signal) => void
 	subscribe: (key: string, fn: (update: Signal) => void) => () => void
+	cacheUpdateNumber: number
+	getUpdateNumber: (update: Signal) => number
 }
 
 export function isTransceiver(

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

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

package/internal/src/operation.ts

@@ -1,7 +1,6 @@
 import type { StateToken } from "atom.io"
 
 import type { Store } from "./store"
-import { IMPLICIT } from "./store"
 import { target } from "./transaction"
 
 export type OperationProgress =
@@ -62,7 +61,7 @@ export const closeOperation = (store: Store): void => {
 	store.subject.operationStatus.next(core.operation)
 }
 
-export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
+export const isDone = (key: string, store: Store): boolean => {
 	const core = target(store)
 	if (!core.operation.open) {
 		store.logger.warn(
@@ -75,7 +74,7 @@ export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
 	}
 	return core.operation.done.has(key)
 }
-export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
+export const markDone = (key: string, store: Store): void => {
 	const core = target(store)
 	if (!core.operation.open) {
 		store.logger.warn(

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

@@ -2,20 +2,27 @@ import type { Atom } from "./atom"
 import { isValueCached, readCachedValue } from "./caching"
 import type { ReadonlySelector, Selector } from "./selector"
 import type { Store } from "./store"
-import { IMPLICIT } from "./store"
 
-export const getState__INTERNAL = <T>(
+export const readOrComputeValue = <T>(
 	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): T => {
 	if (isValueCached(state.key, store)) {
 		store.logger.info(`📖`, state.type, state.key, `reading cached value`)
 		return readCachedValue(state.key, store)
 	}
 	if (state.type !== `atom`) {
-		store.logger.info(`🧮`, state.type, state.key, `calculating value`)
+		store.logger.info(`🧮`, state.type, state.key, `computing value`)
 		return state.get()
 	}
-	store.logger.error(`🐞`, `atom`, state.key, `could not find cached value`)
-	return state.default
+	const fallback =
+		state.default instanceof Function ? state.default() : state.default
+	store.logger.info(
+		`💁`,
+		`atom`,
+		state.key,
+		`could not find cached value; using default`,
+		fallback,
+	)
+	return state.default instanceof Function ? state.default() : state.default
 }

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

@@ -7,7 +7,6 @@ import type {
 } from "atom.io"
 
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
 import type { Subject } from "../subject"
 import { target } from "../transaction"
 import { createReadWriteSelector } from "./create-read-write-selector"
@@ -33,18 +32,18 @@ export type ReadonlySelector<T> = {
 
 export function createSelector<T>(
 	options: SelectorOptions<T>,
-	family?: FamilyMetadata,
-	store?: Store,
+	family: FamilyMetadata | undefined,
+	store: Store,
 ): SelectorToken<T>
 export function createSelector<T>(
 	options: ReadonlySelectorOptions<T>,
-	family?: FamilyMetadata,
-	store?: Store,
+	family: FamilyMetadata | undefined,
+	store: Store,
 ): ReadonlySelectorToken<T>
 export function createSelector<T>(
 	options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
-	family?: FamilyMetadata,
-	store: Store = IMPLICIT.STORE,
+	family: FamilyMetadata | undefined,
+	store: Store,
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
 	const core = target(store)
 	const existingWritable = core.selectors.get(options.key)

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

@@ -0,0 +1,37 @@
+import type { ReadonlySelectorToken, SelectorToken } from "atom.io"
+
+import type { Store } from ".."
+import { target } from ".."
+
+export function deleteSelector(
+	selectorToken: ReadonlySelectorToken<unknown> | SelectorToken<unknown>,
+	store: Store,
+): void {
+	const core = target(store)
+	const { key } = selectorToken
+	switch (selectorToken.type) {
+		case `selector`:
+			core.selectors.delete(key)
+			break
+		case `readonly_selector`:
+			core.readonlySelectors.delete(key)
+			break
+	}
+	core.valueMap.delete(key)
+	core.selectorAtoms.delete(key)
+	const downstreamTokens = core.selectorGraph
+		.getRelationEntries({ upstreamSelectorKey: key })
+		.filter(([_, { source }]) => source === key)
+		.map(
+			([downstreamSelectorKey]) =>
+				core.selectors.get(downstreamSelectorKey) ??
+				core.readonlySelectors.get(downstreamSelectorKey),
+		)
+	for (const downstreamToken of downstreamTokens) {
+		if (downstreamToken) {
+			deleteSelector(downstreamToken, store)
+		}
+	}
+	core.selectorGraph.delete(key)
+	store.logger.info(`🔥`, selectorToken.type, `${key}`, `deleted`)
+}

package/internal/src/selector/index.ts

@@ -1,5 +1,6 @@
+export * from "./create-selector"
+export * from "./delete-selector"
 export * from "./get-selector-dependency-keys"
 export * from "./register-selector"
-export * from "./create-selector"
 export * from "./trace-selector-atoms"
 export * from "./update-selector-atoms"

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

@@ -1,15 +1,15 @@
 import type { Transactors } from "atom.io"
 
-import { getState__INTERNAL } from "../get-state-internal"
-import { setState__INTERNAL } from "../set-state"
+import { readOrComputeValue } from "../read-or-compute-value"
+import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
-import { IMPLICIT, withdraw } from "../store"
-import { target } from "../transaction/transaction-internal"
+import { withdraw } from "../store"
+import { target } from "../transaction/create-transaction"
 import { updateSelectorAtoms } from "./update-selector-atoms"
 
 export const registerSelector = (
 	selectorKey: string,
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): Transactors => ({
 	get: (dependency) => {
 		const core = target(store)
@@ -23,7 +23,7 @@ export const registerSelector = (
 				`State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
 			)
 		}
-		const dependencyValue = getState__INTERNAL(dependencyState, store)
+		const dependencyValue = readOrComputeValue(dependencyState, store)
 
 		store.logger.info(
 			`🔌`,
@@ -55,6 +55,6 @@ export const registerSelector = (
 				`State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
 			)
 		}
-		setState__INTERNAL(state, newValue, store)
+		setAtomOrSelector(state, newValue, store)
 	},
 })

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

@@ -1,11 +1,12 @@
 import type { AtomFamily } from "atom.io"
 import type { Json, JsonInterface } from "atom.io/json"
-import { getState__INTERNAL } from ".."
+import { readOrComputeValue } from ".."
 import type { Store, StoreCore } from ".."
 import type { Atom } from "../atom"
 import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 
 export function copyMutableIfWithinTransaction<T>(
+	oldValue: T,
 	atom: Atom<T> | (Atom<T> & JsonInterface<T, Json.Serializable>),
 	store: Store,
 ): T {
@@ -37,7 +38,7 @@ export function copyMutableIfWithinTransaction<T>(
 			}
 		}
 	}
-	return getState__INTERNAL(atom, store)
+	return oldValue
 }
 
 export function copyMutableFamilyMemberWithinTransaction<T>(

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

@@ -9,9 +9,7 @@ export const emitUpdate = <T>(
 	update: StateUpdate<T>,
 	store: Store,
 ): void => {
-	const { key } = state
-	const { logger } = store
-	logger.info(
+	store.logger.info(
 		`📢`,
 		state.type,
 		state.key,

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

@@ -2,23 +2,21 @@ import type { Atom } from "../atom"
 import { evictCachedValue } from "../caching"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
 import { target } from "../transaction"
 
-export const evictDownStream = <T>(
-	atom: Atom<T>,
-	store: Store = IMPLICIT.STORE,
-): void => {
+export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
 	const core = target(store)
 	const downstreamKeys = core.selectorAtoms.getRelatedKeys(atom.key)
 	store.logger.info(
 		`🧹`,
 		atom.type,
 		atom.key,
-		`evicting ${downstreamKeys?.size ?? 0} states downstream:`,
-		downstreamKeys,
+		downstreamKeys
+			? `evicting ${downstreamKeys.size} states downstream:`
+			: `no downstream states`,
+		downstreamKeys ?? `to evict`,
 	)
-	if (downstreamKeys !== undefined) {
+	if (downstreamKeys) {
 		if (core.operation.open) {
 			store.logger.info(
 				`🧹`,

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

@@ -1,2 +1,2 @@
 export * from "./become"
-export * from "./set-state-internal"
+export * from "./set-atom-or-selector"

package/internal/src/set-state/{set-state-internal.ts → set-atom-or-selector.ts}

@@ -1,13 +1,12 @@
 import type { Atom } from "../atom"
 import type { Selector } from "../selector"
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
 import { setAtom } from "./set-atom"
 
-export const setState__INTERNAL = <T>(
+export const setAtomOrSelector = <T>(
 	state: Atom<T> | Selector<T>,
 	value: T | ((oldValue: T) => T),
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): void => {
 	if (state.type === `selector`) {
 		state.set(value)

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

@@ -1,10 +1,9 @@
 import type { Atom } from "../atom"
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
-import { getState__INTERNAL } from "../get-state-internal"
 import { markDone } from "../operation"
+import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
 import { become } from "./become"
 import { copyMutableIfWithinTransaction } from "./copy-mutable-in-transaction"
 import { emitUpdate } from "./emit-update"
@@ -14,13 +13,13 @@ import { stowUpdate } from "./stow-update"
 export const setAtom = <T>(
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): void => {
-	const oldValue = getState__INTERNAL(atom, store)
-	let newValue = copyMutableIfWithinTransaction(atom, store)
+	const oldValue = readOrComputeValue(atom, store)
+	let newValue = copyMutableIfWithinTransaction(oldValue, atom, store)
 	newValue = become(next)(newValue)
 	store.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
-	cacheValue(atom.key, newValue, atom.subject, store)
+	newValue = cacheValue(atom.key, newValue, atom.subject, store)
 	if (isAtomDefault(atom.key, store)) {
 		markAtomAsNotDefault(atom.key, store)
 	}

package/internal/src/store/store.ts

@@ -152,7 +152,7 @@ export const IMPLICIT = {
 	},
 }
 
-export const clearStore = (store: Store = IMPLICIT.STORE): void => {
+export const clearStore = (store: Store): void => {
 	const { config } = store
 	Object.assign(store, new Store(config.name))
 	store.config = config

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

@@ -36,13 +36,13 @@ export function withdrawNewFamilyMember<T>(
 		| StateToken<T>,
 	store: Store,
 ): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined {
-	store.logger.info(
-		`👪`,
-		token.type,
-		token.key,
-		`creating new family member in store "${store.config.name}"`,
-	)
 	if (token.family) {
+		store.logger.info(
+			`👪`,
+			token.type,
+			token.key,
+			`creating new family member in store "${store.config.name}"`,
+		)
 		const core = target(store)
 		const family = core.families.get(token.family.key)
 		if (family) {

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

@@ -1,12 +1,11 @@
 import type { Atom } from "../atom"
 import type { ReadonlySelector, Selector } from "../selector"
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
 import { target } from "../transaction"
 
 export const recallState = <T>(
 	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): T => {
 	const core = target(store)
 	if (!core.operation.open) {

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

@@ -1,4 +1,4 @@
-import { getState__INTERNAL } from "../get-state-internal"
+import { readOrComputeValue } from "../read-or-compute-value"
 import type { ReadonlySelector, Selector } from "../selector"
 import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
@@ -34,7 +34,7 @@ export const subscribeToRootAtoms = <T>(
 							)
 							const oldValue = recallState(state, store)
 							// ❌ this retrieves a stale cached value when applying a transaction on the server
-							const newValue = getState__INTERNAL(state, store)
+							const newValue = readOrComputeValue(state, store)
 							store.logger.info(
 								`✨`,
 								state.type,

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

@@ -1,18 +1,18 @@
 import type { AtomToken, TimelineUpdate } from "atom.io"
 
 import type { Store } from "../store"
-import { IMPLICIT, withdraw } from "../store"
+import { withdraw } from "../store"
 import { target } from "../transaction"
 import type {
 	Timeline,
 	TimelineAtomUpdate,
 	TimelineTransactionUpdate,
-} from "./timeline-internal"
+} from "./create-timeline"
 
 export const addAtomToTimeline = (
 	atomToken: AtomToken<any>,
 	tl: Timeline,
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): void => {
 	const atom = withdraw(atomToken, store)
 	if (atom === undefined) {
@@ -38,17 +38,6 @@ export const addAtomToTimeline = (
 				? store.transactionStatus.time
 				: null
 
-		// store.logger.info(
-		// 	`⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
-		// 	update.oldValue,
-		// 	`->`,
-		// 	update.newValue,
-		// 	currentTransactionKey
-		// 		? `) in transaction "${currentTransactionKey}"`
-		// 		: currentSelectorKey
-		// 		? `) in selector "${currentSelectorKey}"`
-		// 		: `)`,
-		// )
 		store.logger.info(
 			`⏳`,
 			`timeline`,
@@ -62,8 +51,8 @@ export const addAtomToTimeline = (
 			currentTransactionKey
 				? `in transaction "${currentTransactionKey}"`
 				: currentSelectorKey
-				? `in selector "${currentSelectorKey}"`
-				: ``,
+				  ? `in selector "${currentSelectorKey}"`
+				  : ``,
 		)
 
 		if (tl.timeTraveling === null) {

package/internal/src/timeline/{timeline-internal.ts → create-timeline.ts}

@@ -9,7 +9,6 @@ import type {
 } from "atom.io"
 
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
 import { Subject } from "../subject"
 import { target } from "../transaction"
 import { addAtomToTimeline } from "./add-atom-to-timeline"
@@ -51,10 +50,10 @@ export type Timeline = {
 	>
 }
 
-export function timeline__INTERNAL(
+export function createTimeline(
 	options: TimelineOptions,
-	store: Store = IMPLICIT.STORE,
-	data: Timeline | null = null,
+	store: Store,
+	data?: Timeline,
 ): TimelineToken {
 	const tl: Timeline = {
 		type: `timeline`,
@@ -65,7 +64,7 @@ export function timeline__INTERNAL(
 		transactionKey: null,
 		...data,
 		history: data?.history.map((update) => ({ ...update })) ?? [],
-		install: (store) => timeline__INTERNAL(options, store, tl),
+		install: (store) => createTimeline(options, store, tl),
 		subject: new Subject(),
 	}
 	if (options.shouldCapture) {

package/internal/src/timeline/index.ts

@@ -1,3 +1,3 @@
 export * from "./add-atom-to-timeline"
-export * from "./time-travel-internal"
-export * from "./timeline-internal"
+export * from "./create-timeline"
+export * from "./time-travel"

package/internal/src/timeline/time-travel.ts

@@ -0,0 +1,89 @@
+import type { TimelineToken } from "atom.io"
+import { setState } from "atom.io"
+
+import type { Store } from "../store"
+
+export const timeTravel = (
+	direction: `backward` | `forward`,
+	token: TimelineToken,
+	store: Store,
+): void => {
+	const action = direction === `forward` ? `redo` : `undo`
+	store.logger.info(
+		direction === `forward` ? `⏩` : `⏪`,
+		`timeline`,
+		token.key,
+		action,
+	)
+
+	const timelineData = store.timelines.get(token.key)
+	if (!timelineData) {
+		store.logger.error(
+			`🐞`,
+			`timeline`,
+			token.key,
+			`Failed to ${action}. This timeline has not been initialized.`,
+		)
+		return
+	}
+
+	if (
+		(direction === `forward` &&
+			timelineData.at === timelineData.history.length) ||
+		(direction === `backward` && timelineData.at === 0)
+	) {
+		store.logger.warn(
+			`💁`,
+			`timeline`,
+			token.key,
+			`Failed to ${action} at the ${
+				direction === `forward` ? `end` : `beginning`
+			} of timeline "${token.key}". There is nothing to ${action}.`,
+		)
+		return
+	}
+
+	timelineData.timeTraveling =
+		direction === `forward` ? `into_future` : `into_past`
+	if (direction === `backward`) {
+		--timelineData.at
+	}
+
+	const update = timelineData.history[timelineData.at]
+	const updateValues = (atomUpdate: any) => {
+		const { key, newValue, oldValue } = atomUpdate
+		const value = direction === `forward` ? newValue : oldValue
+		setState({ key, type: `atom` }, value, store)
+	}
+
+	switch (update.type) {
+		case `atom_update`: {
+			updateValues(update)
+			break
+		}
+		case `selector_update`:
+		case `transaction_update`: {
+			const updates =
+				direction === `forward`
+					? update.atomUpdates
+					: [...update.atomUpdates].reverse()
+			for (const atomUpdate of updates) {
+				updateValues(atomUpdate)
+			}
+			break
+		}
+	}
+
+	if (direction === `forward`) {
+		++timelineData.at
+	}
+
+	timelineData.subject.next(action)
+	timelineData.timeTraveling = null
+	store.logger.info(
+		`⏹️`,
+		`timeline`,
+		token.key,
+		`"${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
+	)
+}