atom.io 0.4.1 → 0.6.0

package/src/internal/subscribe-internal.ts

@@ -1,10 +1,10 @@
+import type { Atom, ReadonlySelector, Selector, Store } from "."
 import {
   getState__INTERNAL,
   withdraw,
   recallState,
   traceAllSelectorAtoms,
 } from "."
-import type { Atom, ReadonlySelector, Selector, Store } from "."
 import type { StateUpdate } from ".."
 
 export const prepareUpdate = <T>(
@@ -59,6 +59,11 @@ export const subscribeToRootAtoms = <T>(
       ? 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 (`,

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

@@ -1,14 +1,14 @@
 import type { Store } from "."
 import { IMPLICIT } from "."
-import { setState } from ".."
 import type { TimelineToken } from ".."
+import { setState } from ".."
 
 export const redo__INTERNAL = (
   token: TimelineToken,
   store: Store = IMPLICIT.STORE
 ): void => {
   store.config.logger?.info(`⏩ redo "${token.key}"`)
-  const timelineData = store.timelineStore.get(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.`
@@ -26,14 +26,14 @@ export const redo__INTERNAL = (
   switch (update.type) {
     case `atom_update`: {
       const { key, newValue } = update
-      setState({ key, type: `atom` }, newValue)
+      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)
+        setState({ key, type: `atom` }, newValue, store)
       }
       break
     }
@@ -50,7 +50,7 @@ export const undo__INTERNAL = (
   store: Store = IMPLICIT.STORE
 ): void => {
   store.config.logger?.info(`⏪ undo "${token.key}"`)
-  const timelineData = store.timelineStore.get(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.`
@@ -70,14 +70,14 @@ export const undo__INTERNAL = (
   switch (update.type) {
     case `atom_update`: {
       const { key, oldValue } = update
-      setState({ key, type: `atom` }, oldValue)
+      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)
+        setState({ key, type: `atom` }, oldValue, store)
       }
       break
     }

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

@@ -0,0 +1,164 @@
+import { IMPLICIT, withdraw } from ".."
+import type {
+  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
+): 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
+
+    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)
+
+          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/index.ts

@@ -0,0 +1 @@
+export * from "./add-atom-to-timeline"

package/src/internal/timeline-internal.ts

@@ -1,175 +1,66 @@
 import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
 
-import type { KeyedStateUpdate, TransactionUpdate, Store } from "."
-import { target, IMPLICIT, withdraw } from "."
-import type { AtomToken, TimelineOptions, TimelineToken, ƒn } from ".."
+import type { ƒn } from "~/packages/anvl/src/function"
 
-export type Timeline = {
-  key: string
-  type: `timeline`
-  next: () => void
-  prev: () => void
-}
+import type { Store } from "."
+import { target, IMPLICIT } from "."
+import { addAtomToTimeline } from "./timeline/add-atom-to-timeline"
+import type {
+  StateUpdate,
+  TimelineOptions,
+  TimelineToken,
+  TimelineUpdate,
+  TransactionUpdate,
+} from ".."
 
-export type TimelineAtomUpdate = KeyedStateUpdate<unknown> & {
+export type TimelineAtomUpdate = StateUpdate<unknown> & {
+  key: string
   type: `atom_update`
+  timestamp: number
 }
 export type TimelineSelectorUpdate = {
   key: string
   type: `selector_update`
-  atomUpdates: TimelineAtomUpdate[]
+  timestamp: number
+  atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
 }
 export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+  key: string
   type: `transaction_update`
+  timestamp: number
 }
 
-export type TimelineData = {
+export type Timeline = {
+  key: string
   at: number
   timeTraveling: boolean
-  history: (
-    | TimelineAtomUpdate
-    | TimelineSelectorUpdate
-    | TimelineTransactionUpdate
-  )[]
+  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
+  store: Store = IMPLICIT.STORE,
+  data: Timeline | null = null
 ): TimelineToken {
-  const timelineData: TimelineData = {
+  const tl: Timeline = {
+    key: options.key,
     at: 0,
     timeTraveling: false,
-    history: [],
     selectorTime: null,
     transactionKey: null,
+    ...data,
+    history: data?.history.map((update) => ({ ...update })) ?? [],
+    install: (store) => timeline__INTERNAL(options, store, tl),
+    subject: new Rx.Subject(),
   }
 
-  const subscribeToAtom = (token: AtomToken<any>) => {
-    const state = withdraw(token, store)
-    state.subject.subscribe((update) => {
-      const storeCurrentSelectorKey =
-        store.operation.open && store.operation.token.type === `selector`
-          ? store.operation.token.key
-          : null
-      const storeCurrentSelectorTime =
-        store.operation.open && store.operation.token.type === `selector`
-          ? store.operation.time
-          : null
-
-      const storeCurrentTransactionKey =
-        store.transactionStatus.phase === `applying`
-          ? store.transactionStatus.key
-          : null
-      store.config.logger?.info(
-        `⏳ timeline "${options.key}" saw atom "${token.key}" go (`,
-        update.oldValue,
-        `->`,
-        update.newValue,
-        storeCurrentTransactionKey
-          ? `) in transaction "${storeCurrentTransactionKey}"`
-          : storeCurrentSelectorKey
-          ? `) in selector "${storeCurrentSelectorKey}"`
-          : `)`
-      )
-
-      if (
-        storeCurrentTransactionKey &&
-        store.transactionStatus.phase === `applying`
-      ) {
-        const currentTransaction = withdraw(
-          { key: storeCurrentTransactionKey, type: `transaction` },
-          store
-        )
-        if (timelineData.transactionKey !== storeCurrentTransactionKey) {
-          if (timelineData.transactionKey) {
-            store.config.logger?.error(
-              `Timeline "${options.key}" was unable to resolve transaction "${timelineData.transactionKey}. This is probably a bug.`
-            )
-          }
-          timelineData.transactionKey = storeCurrentTransactionKey
-          const subscription = currentTransaction.subject.subscribe((update) => {
-            if (timelineData.timeTraveling === false) {
-              if (timelineData.at !== timelineData.history.length) {
-                timelineData.history.splice(timelineData.at)
-              }
-              timelineData.history.push({
-                type: `transaction_update`,
-                ...update,
-                atomUpdates: update.atomUpdates.filter((atomUpdate) =>
-                  options.atoms.some((atom) => atom.key === atomUpdate.key)
-                ),
-              })
-            }
-            timelineData.at = timelineData.history.length
-            subscription.unsubscribe()
-            timelineData.transactionKey = null
-            store.config.logger?.info(
-              `⌛ timeline "${options.key}" got a transaction_update "${update.key}"`
-            )
-          })
-        }
-      } else if (storeCurrentSelectorKey) {
-        if (timelineData.timeTraveling === false) {
-          if (storeCurrentSelectorTime !== timelineData.selectorTime) {
-            const newSelectorUpdate: TimelineSelectorUpdate = {
-              type: `selector_update`,
-              key: storeCurrentSelectorKey,
-              atomUpdates: [],
-            }
-            newSelectorUpdate.atomUpdates.push({
-              key: token.key,
-              type: `atom_update`,
-              ...update,
-            })
-            if (timelineData.at !== timelineData.history.length) {
-              timelineData.history.splice(timelineData.at)
-            }
-            timelineData.history.push(newSelectorUpdate)
-
-            store.config.logger?.info(
-              `⌛ timeline "${options.key}" got a selector_update "${storeCurrentSelectorKey}" with`,
-              newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
-            )
-            timelineData.at = timelineData.history.length
-            timelineData.selectorTime = storeCurrentSelectorTime
-          } else {
-            const latestUpdate = timelineData.history.at(-1)
-            if (latestUpdate?.type === `selector_update`) {
-              latestUpdate.atomUpdates.push({
-                key: token.key,
-                type: `atom_update`,
-                ...update,
-              })
-              store.config.logger?.info(
-                `   ⌛ timeline "${options.key}" set selector_update "${storeCurrentSelectorKey}" to`,
-                latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key)
-              )
-            }
-          }
-        }
-      } else {
-        if (timelineData.timeTraveling === false) {
-          timelineData.selectorTime = null
-          if (timelineData.at !== timelineData.history.length) {
-            timelineData.history.splice(timelineData.at)
-          }
-          timelineData.history.push({
-            type: `atom_update`,
-            key: token.key,
-            oldValue: update.oldValue,
-            newValue: update.newValue,
-          })
-          store.config.logger?.info(
-            `⌛ timeline "${options.key}" got a state_update to "${token.key}"`
-          )
-          timelineData.at = timelineData.history.length
-        }
-      }
-    })
-  }
   const core = target(store)
   for (const tokenOrFamily of options.atoms) {
     const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
@@ -181,7 +72,9 @@ export function timeline__INTERNAL(
     }
     if (tokenOrFamily.type === `atom_family`) {
       const family = tokenOrFamily
-      family.subject.subscribe((token) => subscribeToAtom(token))
+      family.subject.subscribe((token) =>
+        addAtomToTimeline(token, options.atoms, tl, store)
+      )
     } else {
       const token = tokenOrFamily
       if (`family` in token && token.family) {
@@ -195,7 +88,7 @@ export function timeline__INTERNAL(
           continue
         }
       }
-      subscribeToAtom(token)
+      addAtomToTimeline(token, options.atoms, tl, store)
     }
     core.timelineAtoms = core.timelineAtoms.set({
       atomKey: tokenOrFamily.key,
@@ -203,7 +96,7 @@ export function timeline__INTERNAL(
     })
   }
 
-  store.timelineStore = HAMT.set(options.key, timelineData, store.timelineStore)
+  store.timelines = HAMT.set(options.key, tl, store.timelines)
   const token: TimelineToken = {
     key: options.key,
     type: `timeline`,

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

@@ -0,0 +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`)
+}

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

@@ -0,0 +1,54 @@
+import HAMT from "hamt_plus"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+
+import type { Store } from ".."
+import { withdraw } from ".."
+import type { AtomToken } from "../.."
+import { setState } from "../.."
+
+export const applyTransaction = <ƒ extends ƒn>(
+  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
+
+  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`)
+}

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

@@ -0,0 +1,33 @@
+import type { Store } from ".."
+
+export const buildTransaction = (
+  key: string,
+  params: any[],
+  store: Store
+): void => {
+  store.transactionStatus = {
+    key,
+    phase: `building`,
+    time: Date.now(),
+    core: {
+      atoms: store.atoms,
+      atomsThatAreDefault: store.atomsThatAreDefault,
+      operation: { open: false },
+      readonlySelectors: store.readonlySelectors,
+      timelines: store.timelines,
+      timelineAtoms: store.timelineAtoms,
+      transactions: store.transactions,
+      selectorAtoms: store.selectorAtoms,
+      selectorGraph: store.selectorGraph,
+      selectors: store.selectors,
+      valueMap: store.valueMap,
+    },
+    atomUpdates: [],
+    params,
+    output: undefined,
+  }
+  store.config.logger?.info(
+    `🛫`,
+    `transaction "${key}" started in store "${store.config.name}"`
+  )
+}

package/src/internal/transaction/index.ts

@@ -0,0 +1,25 @@
+import type { ƒn } from "~/packages/anvl/src/function"
+
+import type { StoreCore } from ".."
+import type { StateUpdate, TransactionUpdate } from "../.."
+
+export * from "./abort-transaction"
+export * from "./apply-transaction"
+export * from "./build-transaction"
+export * from "./redo-transaction"
+export * from "./undo-transaction"
+
+export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
+export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
+
+export type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
+  phase: `applying` | `building`
+  time: number
+  core: StoreCore
+}
+export type TransactionIdle = {
+  phase: `idle`
+}
+export type TransactionStatus<ƒ extends ƒn> =
+  | TransactionIdle
+  | TransactionUpdateInProgress<ƒ>

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

@@ -0,0 +1,23 @@
+import type { ƒn } from "~/packages/anvl/src/function"
+
+import type { Store } from ".."
+import { withdraw } from ".."
+import type { AtomToken, TransactionUpdate } from "../.."
+import { setState } from "../.."
+
+export const redoTransactionUpdate = <ƒ extends ƒn>(
+  update: TransactionUpdate<ƒ>,
+  store: Store
+): void => {
+  store.config.logger?.info(` ⏭ redo transaction "${update.key}" (redo)`)
+  for (const { key, newValue } of update.atomUpdates) {
+    const token: AtomToken<unknown> = { key, type: `atom` }
+    const state = withdraw(token, store)
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      )
+    }
+    setState(state, newValue, store)
+  }
+}

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

@@ -0,0 +1,23 @@
+import type { ƒn } from "~/packages/anvl/src/function"
+
+import type { Store } from ".."
+import { withdraw } from ".."
+import type { AtomToken, TransactionUpdate } from "../.."
+import { setState } from "../.."
+
+export const undoTransactionUpdate = <ƒ extends ƒn>(
+  update: TransactionUpdate<ƒ>,
+  store: Store
+): void => {
+  store.config.logger?.info(` ⏮ undo transaction "${update.key}" (undo)`)
+  for (const { key, oldValue } of update.atomUpdates) {
+    const token: AtomToken<unknown> = { key, type: `atom` }
+    const state = withdraw(token, store)
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      )
+    }
+    setState(state, oldValue, store)
+  }
+}