atom.io 0.6.2 → 0.6.3

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
+			}
+		}
+	})
 }

package/src/internal/timeline-internal.ts

@@ -7,100 +7,100 @@ import type { Store } from "."
 import { target, IMPLICIT } from "."
 import { addAtomToTimeline } from "./timeline/add-atom-to-timeline"
 import type {
-  StateUpdate,
-  TimelineOptions,
-  TimelineToken,
-  TimelineUpdate,
-  TransactionUpdate,
+	StateUpdate,
+	TimelineOptions,
+	TimelineToken,
+	TimelineUpdate,
+	TransactionUpdate,
 } from ".."
 
 export type TimelineAtomUpdate = StateUpdate<unknown> & {
-  key: string
-  type: `atom_update`
-  timestamp: number
+	key: string
+	type: `atom_update`
+	timestamp: number
 }
 export type TimelineSelectorUpdate = {
-  key: string
-  type: `selector_update`
-  timestamp: number
-  atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
+	key: string
+	type: `selector_update`
+	timestamp: number
+	atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
 }
 export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
-  key: string
-  type: `transaction_update`
-  timestamp: number
+	key: string
+	type: `transaction_update`
+	timestamp: number
 }
 
 export type Timeline = {
-  key: string
-  at: number
-  timeTraveling: boolean
-  history: TimelineUpdate[]
-  selectorTime: number | null
-  transactionKey: string | null
-  install: (store: Store) => void
-  subject: Rx.Subject<
-    TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate
-  >
+	key: string
+	at: number
+	timeTraveling: boolean
+	history: TimelineUpdate[]
+	selectorTime: number | null
+	transactionKey: string | null
+	install: (store: Store) => void
+	subject: Rx.Subject<
+		TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate
+	>
 }
 
 export function timeline__INTERNAL(
-  options: TimelineOptions,
-  store: Store = IMPLICIT.STORE,
-  data: Timeline | null = null
+	options: TimelineOptions,
+	store: Store = IMPLICIT.STORE,
+	data: Timeline | null = null,
 ): TimelineToken {
-  const tl: Timeline = {
-    key: options.key,
-    at: 0,
-    timeTraveling: false,
-    selectorTime: null,
-    transactionKey: null,
-    ...data,
-    history: data?.history.map((update) => ({ ...update })) ?? [],
-    install: (store) => timeline__INTERNAL(options, store, tl),
-    subject: new Rx.Subject(),
-  }
+	const tl: Timeline = {
+		key: options.key,
+		at: 0,
+		timeTraveling: false,
+		selectorTime: null,
+		transactionKey: null,
+		...data,
+		history: data?.history.map((update) => ({ ...update })) ?? [],
+		install: (store) => timeline__INTERNAL(options, store, tl),
+		subject: new Rx.Subject(),
+	}
 
-  const core = target(store)
-  for (const tokenOrFamily of options.atoms) {
-    const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
-    if (timelineKey) {
-      store.config.logger?.error(
-        `❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`
-      )
-      continue
-    }
-    if (tokenOrFamily.type === `atom_family`) {
-      const family = tokenOrFamily
-      family.subject.subscribe((token) =>
-        addAtomToTimeline(token, options.atoms, tl, store)
-      )
-    } else {
-      const token = tokenOrFamily
-      if (`family` in token && token.family) {
-        const familyTimelineKey = core.timelineAtoms.getRelatedId(
-          token.family.key
-        )
-        if (familyTimelineKey) {
-          store.config.logger?.error(
-            `❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`
-          )
-          continue
-        }
-      }
-      addAtomToTimeline(token, options.atoms, tl, store)
-    }
-    core.timelineAtoms = core.timelineAtoms.set({
-      atomKey: tokenOrFamily.key,
-      timelineKey: options.key,
-    })
-  }
+	const core = target(store)
+	for (const tokenOrFamily of options.atoms) {
+		const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
+		if (timelineKey) {
+			store.config.logger?.error(
+				`❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`,
+			)
+			continue
+		}
+		if (tokenOrFamily.type === `atom_family`) {
+			const family = tokenOrFamily
+			family.subject.subscribe((token) =>
+				addAtomToTimeline(token, options.atoms, tl, store),
+			)
+		} else {
+			const token = tokenOrFamily
+			if (`family` in token && token.family) {
+				const familyTimelineKey = core.timelineAtoms.getRelatedId(
+					token.family.key,
+				)
+				if (familyTimelineKey) {
+					store.config.logger?.error(
+						`❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`,
+					)
+					continue
+				}
+			}
+			addAtomToTimeline(token, options.atoms, tl, store)
+		}
+		core.timelineAtoms = core.timelineAtoms.set({
+			atomKey: tokenOrFamily.key,
+			timelineKey: options.key,
+		})
+	}
 
-  store.timelines = HAMT.set(options.key, tl, store.timelines)
-  const token: TimelineToken = {
-    key: options.key,
-    type: `timeline`,
-  }
-  store.subject.timelineCreation.next(token)
-  return token
+	store.timelines = HAMT.set(options.key, tl, store.timelines)
+	const token: TimelineToken = {
+		key: options.key,
+		type: `timeline`,
+	}
+	store.subject.timelineCreation.next(token)
+	return token
 }

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

@@ -1,12 +1,12 @@
 import type { Store } from ".."
 
 export const abortTransaction = (store: Store): void => {
-  if (store.transactionStatus.phase === `idle`) {
-    store.config.logger?.warn(
-      `abortTransaction called outside of a transaction. This is probably a bug.`
-    )
-    return
-  }
-  store.transactionStatus = { phase: `idle` }
-  store.config.logger?.info(`🪂`, `transaction fail`)
+	if (store.transactionStatus.phase === `idle`) {
+		store.config.logger?.warn(
+			`abortTransaction called outside of a transaction. This is probably a bug.`,
+		)
+		return
+	}
+	store.transactionStatus = { phase: `idle` }
+	store.config.logger?.info(`🪂`, `transaction fail`)
 }

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

@@ -8,47 +8,47 @@ import type { AtomToken } from "../.."
 import { setState } from "../.."
 
 export const applyTransaction = <ƒ extends ƒn>(
-  output: ReturnType<ƒ>,
-  store: Store
+	output: ReturnType<ƒ>,
+	store: Store,
 ): void => {
-  if (store.transactionStatus.phase !== `building`) {
-    store.config.logger?.warn(
-      `abortTransaction called outside of a transaction. This is probably a bug.`
-    )
-    return
-  }
-  store.config.logger?.info(
-    `🛃 apply transaction "${store.transactionStatus.key}"`
-  )
-  store.transactionStatus.phase = `applying`
-  store.transactionStatus.output = output
-  const { atomUpdates } = store.transactionStatus
+	if (store.transactionStatus.phase !== `building`) {
+		store.config.logger?.warn(
+			`abortTransaction called outside of a transaction. This is probably a bug.`,
+		)
+		return
+	}
+	store.config.logger?.info(
+		`🛃 apply transaction "${store.transactionStatus.key}"`,
+	)
+	store.transactionStatus.phase = `applying`
+	store.transactionStatus.output = output
+	const { atomUpdates } = store.transactionStatus
 
-  for (const { key, newValue } of atomUpdates) {
-    const token: AtomToken<unknown> = { key, type: `atom` }
-    if (!HAMT.has(token.key, store.valueMap)) {
-      const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
-      store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
-      store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
-      store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
-    }
-    setState(token, newValue, store)
-  }
-  const myTransaction = withdraw<ƒ>(
-    { key: store.transactionStatus.key, type: `transaction` },
-    store
-  )
-  if (myTransaction === null) {
-    throw new Error(
-      `Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`
-    )
-  }
-  myTransaction.subject.next({
-    key: store.transactionStatus.key,
-    atomUpdates,
-    output,
-    params: store.transactionStatus.params as Parameters<ƒ>,
-  })
-  store.transactionStatus = { phase: `idle` }
-  store.config.logger?.info(`🛬`, `transaction done`)
+	for (const { key, newValue } of atomUpdates) {
+		const token: AtomToken<unknown> = { key, type: `atom` }
+		if (!HAMT.has(token.key, store.valueMap)) {
+			const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
+			store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
+			store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
+			store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
+		}
+		setState(token, newValue, store)
+	}
+	const myTransaction = withdraw<ƒ>(
+		{ key: store.transactionStatus.key, type: `transaction` },
+		store,
+	)
+	if (myTransaction === null) {
+		throw new Error(
+			`Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`,
+		)
+	}
+	myTransaction.subject.next({
+		key: store.transactionStatus.key,
+		atomUpdates,
+		output,
+		params: store.transactionStatus.params as Parameters<ƒ>,
+	})
+	store.transactionStatus = { phase: `idle` }
+	store.config.logger?.info(`🛬`, `transaction done`)
 }