atom.io 0.6.2 → 0.6.4

package/src/internal/subscribe-internal.ts

@@ -1,82 +1,82 @@
 import type { Atom, ReadonlySelector, Selector, Store } from "."
 import {
-  getState__INTERNAL,
-  withdraw,
-  recallState,
-  traceAllSelectorAtoms,
+	getState__INTERNAL,
+	withdraw,
+	recallState,
+	traceAllSelectorAtoms,
 } from "."
 import type { StateUpdate } from ".."
 
 export const prepareUpdate = <T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  store: Store
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	store: Store,
 ): StateUpdate<T> => {
-  const oldValue = recallState(state, store)
-  const newValue = getState__INTERNAL(state, store)
-  return { newValue, oldValue }
+	const oldValue = recallState(state, store)
+	const newValue = getState__INTERNAL(state, store)
+	return { newValue, oldValue }
 }
 
 export const stowUpdate = <T>(
-  state: Atom<T>,
-  update: StateUpdate<T>,
-  store: Store
+	state: Atom<T>,
+	update: StateUpdate<T>,
+	store: Store,
 ): void => {
-  const { key } = state
-  const { logger } = store.config
-  if (store.transactionStatus.phase !== `building`) {
-    store.config.logger?.warn(
-      `stowUpdate called outside of a transaction. This is probably a bug.`
-    )
-    return
-  }
-  store.transactionStatus.atomUpdates.push({ key, ...update })
-  logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
+	const { key } = state
+	const { logger } = store.config
+	if (store.transactionStatus.phase !== `building`) {
+		store.config.logger?.warn(
+			`stowUpdate called outside of a transaction. This is probably a bug.`,
+		)
+		return
+	}
+	store.transactionStatus.atomUpdates.push({ key, ...update })
+	logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
 }
 
 export const emitUpdate = <T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  update: StateUpdate<T>,
-  store: Store
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	update: StateUpdate<T>,
+	store: Store,
 ): void => {
-  const { key } = state
-  const { logger } = store.config
-  logger?.info(
-    `📢 ${state.type} "${key}" went (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `)`
-  )
-  state.subject.next(update)
+	const { key } = state
+	const { logger } = store.config
+	logger?.info(
+		`📢 ${state.type} "${key}" went (`,
+		update.oldValue,
+		`->`,
+		update.newValue,
+		`)`,
+	)
+	state.subject.next(update)
 }
 
 export const subscribeToRootAtoms = <T>(
-  state: ReadonlySelector<T> | Selector<T>,
-  store: Store
+	state: ReadonlySelector<T> | Selector<T>,
+	store: Store,
 ): { unsubscribe: () => void }[] | null => {
-  const dependencySubscriptions =
-    `default` in state
-      ? null
-      : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
-          const atom = withdraw(atomToken, store)
-          if (atom === null) {
-            throw new Error(
-              `Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
-            )
-          }
-          return atom.subject.subscribe((atomChange) => {
-            store.config.logger?.info(
-              `📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
-              atomChange.oldValue,
-              `->`,
-              atomChange.newValue,
-              `)`
-            )
-            const oldValue = recallState(state, store)
-            const newValue = getState__INTERNAL(state, store)
-            store.config.logger?.info(`   <- ${state.key} became`, newValue)
-            state.subject.next({ newValue, oldValue })
-          })
-        })
-  return dependencySubscriptions
+	const dependencySubscriptions =
+		`default` in state
+			? null
+			: traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+					const atom = withdraw(atomToken, store)
+					if (atom === null) {
+						throw new Error(
+							`Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
+						)
+					}
+					return atom.subject.subscribe((atomChange) => {
+						store.config.logger?.info(
+							`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
+							atomChange.oldValue,
+							`->`,
+							atomChange.newValue,
+							`)`,
+						)
+						const oldValue = recallState(state, store)
+						const newValue = getState__INTERNAL(state, store)
+						store.config.logger?.info(`   <- ${state.key} became`, newValue)
+						state.subject.next({ newValue, oldValue })
+					})
+			  })
+	return dependencySubscriptions
 }

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

@@ -4,86 +4,86 @@ import type { TimelineToken } from ".."
 import { setState } from ".."
 
 export const redo__INTERNAL = (
-  token: TimelineToken,
-  store: Store = IMPLICIT.STORE
+	token: TimelineToken,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  store.config.logger?.info(`⏩ redo "${token.key}"`)
-  const timelineData = store.timelines.get(token.key)
-  if (!timelineData) {
-    store.config.logger?.error(
-      `Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
-    )
-    return
-  }
-  if (timelineData.at === timelineData.history.length) {
-    store.config.logger?.warn(
-      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
-    )
-    return
-  }
-  timelineData.timeTraveling = true
-  const update = timelineData.history[timelineData.at]
-  switch (update.type) {
-    case `atom_update`: {
-      const { key, newValue } = update
-      setState({ key, type: `atom` }, newValue, store)
-      break
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of update.atomUpdates) {
-        const { key, newValue } = atomUpdate
-        setState({ key, type: `atom` }, newValue, store)
-      }
-      break
-    }
-  }
-  ++timelineData.at
-  timelineData.timeTraveling = false
-  store.config.logger?.info(
-    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  )
+	store.config.logger?.info(`⏩ redo "${token.key}"`)
+	const timelineData = store.timelines.get(token.key)
+	if (!timelineData) {
+		store.config.logger?.error(
+			`Failed to redo on timeline "${token.key}". This timeline has not been initialized.`,
+		)
+		return
+	}
+	if (timelineData.at === timelineData.history.length) {
+		store.config.logger?.warn(
+			`Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`,
+		)
+		return
+	}
+	timelineData.timeTraveling = true
+	const update = timelineData.history[timelineData.at]
+	switch (update.type) {
+		case `atom_update`: {
+			const { key, newValue } = update
+			setState({ key, type: `atom` }, newValue, store)
+			break
+		}
+		case `selector_update`:
+		case `transaction_update`: {
+			for (const atomUpdate of update.atomUpdates) {
+				const { key, newValue } = atomUpdate
+				setState({ key, type: `atom` }, newValue, store)
+			}
+			break
+		}
+	}
+	++timelineData.at
+	timelineData.timeTraveling = false
+	store.config.logger?.info(
+		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
+	)
 }
 
 export const undo__INTERNAL = (
-  token: TimelineToken,
-  store: Store = IMPLICIT.STORE
+	token: TimelineToken,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  store.config.logger?.info(`⏪ undo "${token.key}"`)
-  const timelineData = store.timelines.get(token.key)
-  if (!timelineData) {
-    store.config.logger?.error(
-      `Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
-    )
-    return
-  }
-  if (timelineData.at === 0) {
-    store.config.logger?.warn(
-      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
-    )
-    return
-  }
-  timelineData.timeTraveling = true
+	store.config.logger?.info(`⏪ undo "${token.key}"`)
+	const timelineData = store.timelines.get(token.key)
+	if (!timelineData) {
+		store.config.logger?.error(
+			`Failed to undo on timeline "${token.key}". This timeline has not been initialized.`,
+		)
+		return
+	}
+	if (timelineData.at === 0) {
+		store.config.logger?.warn(
+			`Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`,
+		)
+		return
+	}
+	timelineData.timeTraveling = true
 
-  --timelineData.at
-  const update = timelineData.history[timelineData.at]
-  switch (update.type) {
-    case `atom_update`: {
-      const { key, oldValue } = update
-      setState({ key, type: `atom` }, oldValue, store)
-      break
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of update.atomUpdates) {
-        const { key, oldValue } = atomUpdate
-        setState({ key, type: `atom` }, oldValue, store)
-      }
-      break
-    }
-  }
-  timelineData.timeTraveling = false
-  store.config.logger?.info(
-    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  )
+	--timelineData.at
+	const update = timelineData.history[timelineData.at]
+	switch (update.type) {
+		case `atom_update`: {
+			const { key, oldValue } = update
+			setState({ key, type: `atom` }, oldValue, store)
+			break
+		}
+		case `selector_update`:
+		case `transaction_update`: {
+			for (const atomUpdate of update.atomUpdates) {
+				const { key, oldValue } = atomUpdate
+				setState({ key, type: `atom` }, oldValue, store)
+			}
+			break
+		}
+	}
+	timelineData.timeTraveling = false
+	store.config.logger?.info(
+		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
+	)
 }

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

@@ -1,164 +1,169 @@
 import { IMPLICIT, withdraw } from ".."
 import type {
-  TimelineSelectorUpdate,
-  Timeline,
-  Store,
-  TimelineTransactionUpdate,
-  TimelineAtomUpdate,
+	TimelineSelectorUpdate,
+	Timeline,
+	Store,
+	TimelineTransactionUpdate,
+	TimelineAtomUpdate,
 } from ".."
 import type { AtomFamily, AtomToken, TimelineUpdate } from "../.."
 
 export const addAtomToTimeline = (
-  atomToken: AtomToken<any>,
-  atoms: (AtomFamily<any> | AtomToken<any>)[],
-  tl: Timeline,
-  store: Store = IMPLICIT.STORE
+	atomToken: AtomToken<any>,
+	atoms: (AtomFamily<any> | AtomToken<any>)[],
+	tl: Timeline,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const atom = withdraw(atomToken, store)
-  if (atom === null) {
-    throw new Error(
-      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
-    )
-  }
-  atom.subject.subscribe((update) => {
-    const currentSelectorKey =
-      store.operation.open && store.operation.token.type === `selector`
-        ? store.operation.token.key
-        : null
-    const currentSelectorTime =
-      store.operation.open && store.operation.token.type === `selector`
-        ? store.operation.time
-        : null
-    const currentTransactionKey =
-      store.transactionStatus.phase === `applying`
-        ? store.transactionStatus.key
-        : null
-    const currentTransactionTime =
-      store.transactionStatus.phase === `applying`
-        ? store.transactionStatus.time
-        : null
+	const atom = withdraw(atomToken, store)
+	if (atom === null) {
+		throw new Error(
+			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
+		)
+	}
+	atom.subject.subscribe((update) => {
+		const currentSelectorKey =
+			store.operation.open && store.operation.token.type === `selector`
+				? store.operation.token.key
+				: null
+		const currentSelectorTime =
+			store.operation.open && store.operation.token.type === `selector`
+				? store.operation.time
+				: null
+		const currentTransactionKey =
+			store.transactionStatus.phase === `applying`
+				? store.transactionStatus.key
+				: null
+		const currentTransactionTime =
+			store.transactionStatus.phase === `applying`
+				? store.transactionStatus.time
+				: null
 
-    store.config.logger?.info(
-      `⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
-      update.oldValue,
-      `->`,
-      update.newValue,
-      currentTransactionKey
-        ? `) in transaction "${currentTransactionKey}"`
-        : currentSelectorKey
-        ? `) in selector "${currentSelectorKey}"`
-        : `)`
-    )
+		store.config.logger?.info(
+			`⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
+			update.oldValue,
+			`->`,
+			update.newValue,
+			currentTransactionKey
+				? `) in transaction "${currentTransactionKey}"`
+				: currentSelectorKey
+				? `) in selector "${currentSelectorKey}"`
+				: `)`,
+		)
 
-    if (tl.timeTraveling === false) {
-      if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
-        const mostRecentUpdate: TimelineUpdate = tl.history.at(-1)!
-        if (mostRecentUpdate.type === `selector_update`) {
-          tl.subject.next(mostRecentUpdate)
-        }
-      }
-      if (
-        currentTransactionKey &&
-        store.transactionStatus.phase === `applying`
-      ) {
-        const currentTransaction = withdraw(
-          { key: currentTransactionKey, type: `transaction` },
-          store
-        )
-        if (currentTransaction === null) {
-          throw new Error(
-            `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
-          )
-        }
-        if (tl.transactionKey !== currentTransactionKey) {
-          if (tl.transactionKey) {
-            store.config.logger?.error(
-              `Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`
-            )
-          }
-          tl.transactionKey = currentTransactionKey
-          const subscription = currentTransaction.subject.subscribe((update) => {
-            if (tl.timeTraveling === false && currentTransactionTime) {
-              if (tl.at !== tl.history.length) {
-                tl.history.splice(tl.at)
-              }
-              const timelineTransactionUpdate: TimelineTransactionUpdate = {
-                type: `transaction_update`,
-                timestamp: currentTransactionTime,
-                ...update,
-                atomUpdates: update.atomUpdates.filter((atomUpdate) =>
-                  atoms.some((atom) => atom.key === atomUpdate.key)
-                ),
-              }
-              tl.history.push(timelineTransactionUpdate)
-              tl.subject.next(timelineTransactionUpdate)
-            }
-            tl.at = tl.history.length
-            subscription.unsubscribe()
-            tl.transactionKey = null
-            store.config.logger?.info(
-              `⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`
-            )
-          })
-        }
-      } else if (currentSelectorKey && currentSelectorTime) {
-        if (currentSelectorTime !== tl.selectorTime) {
-          const newSelectorUpdate: TimelineSelectorUpdate = {
-            type: `selector_update`,
-            timestamp: currentSelectorTime,
-            key: currentSelectorKey,
-            atomUpdates: [],
-          }
-          newSelectorUpdate.atomUpdates.push({
-            key: atom.key,
-            type: `atom_update`,
-            ...update,
-          })
-          if (tl.at !== tl.history.length) {
-            tl.history.splice(tl.at)
-          }
-          tl.history.push(newSelectorUpdate)
+		if (tl.timeTraveling === false) {
+			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
+				const mostRecentUpdate: TimelineUpdate | undefined = tl.history.at(-1)
+				if (mostRecentUpdate === undefined) {
+					throw new Error(
+						`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
+					)
+				}
+				if (mostRecentUpdate.type === `selector_update`) {
+					tl.subject.next(mostRecentUpdate)
+				}
+			}
+			if (
+				currentTransactionKey &&
+				store.transactionStatus.phase === `applying`
+			) {
+				const currentTransaction = withdraw(
+					{ key: currentTransactionKey, type: `transaction` },
+					store,
+				)
+				if (currentTransaction === null) {
+					throw new Error(
+						`Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`,
+					)
+				}
+				if (tl.transactionKey !== currentTransactionKey) {
+					if (tl.transactionKey) {
+						store.config.logger?.error(
+							`Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`,
+						)
+					}
+					tl.transactionKey = currentTransactionKey
+					const subscription = currentTransaction.subject.subscribe((update) => {
+						if (tl.timeTraveling === false && currentTransactionTime) {
+							if (tl.at !== tl.history.length) {
+								tl.history.splice(tl.at)
+							}
+							const timelineTransactionUpdate: TimelineTransactionUpdate = {
+								type: `transaction_update`,
+								timestamp: currentTransactionTime,
+								...update,
+								atomUpdates: update.atomUpdates.filter((atomUpdate) =>
+									atoms.some((atom) => atom.key === atomUpdate.key),
+								),
+							}
+							tl.history.push(timelineTransactionUpdate)
+							tl.subject.next(timelineTransactionUpdate)
+						}
+						tl.at = tl.history.length
+						subscription.unsubscribe()
+						tl.transactionKey = null
+						store.config.logger?.info(
+							`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
+						)
+					})
+				}
+			} else if (currentSelectorKey && currentSelectorTime) {
+				if (currentSelectorTime !== tl.selectorTime) {
+					const newSelectorUpdate: TimelineSelectorUpdate = {
+						type: `selector_update`,
+						timestamp: currentSelectorTime,
+						key: currentSelectorKey,
+						atomUpdates: [],
+					}
+					newSelectorUpdate.atomUpdates.push({
+						key: atom.key,
+						type: `atom_update`,
+						...update,
+					})
+					if (tl.at !== tl.history.length) {
+						tl.history.splice(tl.at)
+					}
+					tl.history.push(newSelectorUpdate)
 
-          store.config.logger?.info(
-            `⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
-            newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-          )
-          tl.at = tl.history.length
-          tl.selectorTime = currentSelectorTime
-        } else {
-          const latestUpdate = tl.history.at(-1)
-          if (latestUpdate?.type === `selector_update`) {
-            latestUpdate.atomUpdates.push({
-              key: atom.key,
-              type: `atom_update`,
-              ...update,
-            })
-            store.config.logger?.info(
-              `   ⌛ timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
-              latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key)
-            )
-          }
-        }
-      } else {
-        const timestamp = Date.now()
-        tl.selectorTime = null
-        if (tl.at !== tl.history.length) {
-          tl.history.splice(tl.at)
-        }
-        const atomUpdate: TimelineAtomUpdate = {
-          type: `atom_update`,
-          timestamp,
-          key: atom.key,
-          oldValue: update.oldValue,
-          newValue: update.newValue,
-        }
-        tl.history.push(atomUpdate)
-        tl.subject.next(atomUpdate)
-        store.config.logger?.info(
-          `⌛ timeline "${tl.key}" got a state_update to "${atom.key}"`
-        )
-        tl.at = tl.history.length
-      }
-    }
-  })
+					store.config.logger?.info(
+						`⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
+						newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
+					)
+					tl.at = tl.history.length
+					tl.selectorTime = currentSelectorTime
+				} else {
+					const latestUpdate = tl.history.at(-1)
+					if (latestUpdate?.type === `selector_update`) {
+						latestUpdate.atomUpdates.push({
+							key: atom.key,
+							type: `atom_update`,
+							...update,
+						})
+						store.config.logger?.info(
+							`   ⌛ timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
+							latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
+						)
+					}
+				}
+			} else {
+				const timestamp = Date.now()
+				tl.selectorTime = null
+				if (tl.at !== tl.history.length) {
+					tl.history.splice(tl.at)
+				}
+				const atomUpdate: TimelineAtomUpdate = {
+					type: `atom_update`,
+					timestamp,
+					key: atom.key,
+					oldValue: update.oldValue,
+					newValue: update.newValue,
+				}
+				tl.history.push(atomUpdate)
+				tl.subject.next(atomUpdate)
+				store.config.logger?.info(
+					`⌛ timeline "${tl.key}" got a state_update to "${atom.key}"`,
+				)
+				tl.at = tl.history.length
+			}
+		}
+	})
 }