atom.io 0.5.0 → 0.6.0

package/src/internal/timeline-internal.ts

@@ -1,187 +1,66 @@
 import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
 
 import type { ƒn } from "~/packages/anvl/src/function"
 
-import type { KeyedStateUpdate, TransactionUpdate, Store } from "."
-import { target, IMPLICIT, withdraw } from "."
-import type { AtomToken, TimelineOptions, TimelineToken } from ".."
+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 Timeline = {
+export type TimelineAtomUpdate = StateUpdate<unknown> & {
   key: string
-  type: `timeline`
-  next: () => void
-  prev: () => void
-}
-
-export type TimelineAtomUpdate = KeyedStateUpdate<unknown> & {
   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)
-    if (state === null) {
-      throw new Error(
-        `Cannot subscribe to atom "${token.key}" because it has not been initialized in store "${store.config.name}"`
-      )
-    }
-    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 (currentTransaction === null) {
-          throw new Error(
-            `Transaction "${storeCurrentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${storeCurrentTransactionKey}".`
-          )
-        }
-        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)
@@ -193,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) {
@@ -207,7 +88,7 @@ export function timeline__INTERNAL(
           continue
         }
       }
-      subscribeToAtom(token)
+      addAtomToTimeline(token, options.atoms, tl, store)
     }
     core.timelineAtoms = core.timelineAtoms.set({
       atomKey: tokenOrFamily.key,
@@ -215,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)
+  }
+}

package/src/internal/transaction-internal.ts

@@ -4,155 +4,22 @@ import * as Rx from "rxjs"
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store, StoreCore } from "."
-import { deposit, withdraw, IMPLICIT } from "."
+import {
+  abortTransaction,
+  applyTransaction,
+  buildTransaction,
+  deposit,
+  IMPLICIT,
+} from "."
+import type { TransactionOptions, TransactionToken, TransactionUpdate } from ".."
 import { getState, setState } from ".."
-import type {
-  AtomToken,
-  StateUpdate,
-  Transaction,
-  TransactionOptions,
-  TransactionToken,
-} from ".."
 
-export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
-export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
-
-export type KeyedStateUpdate<T> = StateUpdate<T> & {
-  key: string
-}
-export type TransactionUpdate<ƒ extends ƒn> = {
+export type Transaction<ƒ extends ƒn> = {
   key: string
-  atomUpdates: KeyedStateUpdate<unknown>[]
-  params: Parameters<ƒ>
-  output: ReturnType<ƒ>
-}
-
-export type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
-  phase: `applying` | `building`
-  core: StoreCore
-}
-export type TransactionIdle = {
-  phase: `idle`
-}
-export type TransactionStatus<ƒ extends ƒn> =
-  | TransactionIdle
-  | TransactionUpdateInProgress<ƒ>
-
-export const buildTransaction = (
-  key: string,
-  params: any[],
-  store: Store
-): void => {
-  store.transactionStatus = {
-    key,
-    phase: `building`,
-    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`)
-}
-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`)
-}
-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)
-  }
-}
-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)
-  }
-}
-
-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`)
+  type: `transaction`
+  install: (store: Store) => void
+  subject: Rx.Subject<TransactionUpdate<ƒ>>
+  run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
 }
 
 export function transaction__INTERNAL<ƒ extends ƒn>(
@@ -180,6 +47,7 @@ export function transaction__INTERNAL<ƒ extends ƒn>(
         throw thrown
       }
     },
+    install: (store) => transaction__INTERNAL(options, store),
     subject: new Rx.Subject(),
   }
   const core = target(store)

package/src/react/index.ts

@@ -1,46 +1,2 @@
-import { useSyncExternalStore } from "react"
-
-import { subscribe, setState, __INTERNAL__, getState } from "atom.io"
-import type { ReadonlySelectorToken, StateToken } from "atom.io"
-
-import type { Modifier } from "~/packages/anvl/src/function"
-
-export type StoreHooks = {
-  useI: <T>(token: StateToken<T>) => (next: Modifier<T> | T) => void
-  useO: <T>(token: ReadonlySelectorToken<T> | StateToken<T>) => T
-  useIO: <T>(token: StateToken<T>) => [T, (next: Modifier<T> | T) => void]
-}
-
-export const composeStoreHooks = (
-  store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE
-): StoreHooks => {
-  function useI<T>(token: StateToken<T>): (next: Modifier<T> | T) => void {
-    const updateState = (next: Modifier<T> | T) => setState(token, next, store)
-    return updateState
-  }
-
-  function useO<T>(token: ReadonlySelectorToken<T> | StateToken<T>): T {
-    return useSyncExternalStore<T>(
-      (observe) => subscribe(token, observe, store),
-      () => getState(token, store)
-    )
-  }
-
-  function useIO<T>(token: StateToken<T>): [T, (next: Modifier<T> | T) => void] {
-    return [useO(token), useI(token)]
-  }
-
-  return { useI, useO, useIO }
-}
-
-export const { useI, useO, useIO } = composeStoreHooks()
-
-export function useStore<T>(
-  token: StateToken<T>
-): [T, (next: Modifier<T> | T) => void]
-export function useStore<T>(token: ReadonlySelectorToken<T>): T
-export function useStore<T>(
-  token: ReadonlySelectorToken<T> | StateToken<T>
-): T | [T, (next: Modifier<T> | T) => void] {
-  return token.type === `readonly_selector` ? useO(token) : useIO(token)
-}
+export * from "./store-context"
+export * from "./store-hooks"

package/src/react/store-context.tsx

@@ -0,0 +1,14 @@
+import * as React from "react"
+
+import * as AtomIO from "atom.io"
+
+export const StoreContext = React.createContext<AtomIO.Store>(
+  AtomIO.__INTERNAL__.IMPLICIT.STORE
+)
+
+export const StoreProvider: React.FC<{
+  children: React.ReactNode
+  store?: AtomIO.Store
+}> = ({ children, store = AtomIO.__INTERNAL__.IMPLICIT.STORE }) => (
+  <StoreContext.Provider value={store}>{children}</StoreContext.Provider>
+)