atom.io 0.2.0 → 0.3.0

package/src/internal/subscribe-internal.ts

@@ -1,14 +1,58 @@
-import type { Atom, ReadonlySelector, Selector } from "."
-import { getState__INTERNAL, withdraw } from "./get"
-import { recallState } from "./operation"
-import { traceAllSelectorAtoms } from "./selector-internal"
-import type { Store } from "./store"
-import { IMPLICIT } from "./store"
-import { __INTERNAL__ } from ".."
+import {
+  getState__INTERNAL,
+  withdraw,
+  recallState,
+  traceAllSelectorAtoms,
+} from "."
+import type { Atom, ReadonlySelector, Selector, Store } from "."
+import type { StateUpdate } from ".."
 
-export const subscribeToRootAtoms = <T>(
+export const prepareUpdate = <T>(
   state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  store: Store = IMPLICIT.STORE
+  store: Store
+): StateUpdate<T> => {
+  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
+): 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, `)`)
+}
+
+export const emitUpdate = <T>(
+  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)
+}
+
+export const subscribeToRootAtoms = <T>(
+  state: ReadonlySelector<T> | Selector<T>,
+  store: Store
 ): { unsubscribe: () => void }[] | null => {
   const dependencySubscriptions =
     `default` in state
@@ -17,11 +61,11 @@ export const subscribeToRootAtoms = <T>(
           const atom = withdraw(atomToken, store)
           return atom.subject.subscribe((atomChange) => {
             store.config.logger?.info(
-              `📢 atom changed: "${atomToken.key}" (`,
+              `📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
               atomChange.oldValue,
               `->`,
               atomChange.newValue,
-              `) re-evaluating "${state.key}"`
+              `)`
             )
             const oldValue = recallState(state, store)
             const newValue = getState__INTERNAL(state, store)

package/src/internal/timeline-internal.ts

@@ -0,0 +1,196 @@
+import HAMT from "hamt_plus"
+
+import type { KeyedStateUpdate, TransactionUpdate, Store } from "."
+import { IMPLICIT, withdraw } from "."
+import { setState } from ".."
+import type { AtomToken, TimelineOptions, TimelineToken, ƒn } from ".."
+
+export type Timeline = {
+  key: string
+  type: `timeline`
+  next: () => void
+  prev: () => void
+}
+
+export type TimelineStateUpdate = KeyedStateUpdate<unknown> & {
+  type: `state_update`
+}
+export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+  type: `transaction_update`
+}
+
+export type TimelineData = {
+  at: number
+  timeTraveling: boolean
+  history: (TimelineStateUpdate | TimelineTransactionUpdate)[]
+}
+
+export function timeline__INTERNAL(
+  options: TimelineOptions,
+  store: Store = IMPLICIT.STORE
+): TimelineToken {
+  let incompleteTransactionKey: string | null = null
+  const timelineData: TimelineData = {
+    at: 0,
+    timeTraveling: false,
+    history: [],
+  }
+
+  const subscribeToAtom = (token: AtomToken<any>) => {
+    const state = withdraw(token, store)
+    state.subject.subscribe((update) => {
+      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 "${storeCurrentTransactionKey}"`
+          : `) independently`
+      )
+
+      if (
+        storeCurrentTransactionKey &&
+        store.transactionStatus.phase === `applying`
+      ) {
+        const currentTransaction = withdraw(
+          { key: storeCurrentTransactionKey, type: `transaction` },
+          store
+        )
+        if (incompleteTransactionKey !== storeCurrentTransactionKey) {
+          if (incompleteTransactionKey) {
+            store.config.logger?.error(
+              `Timeline "${options.key}" was unable to resolve transaction "${incompleteTransactionKey}. This is probably a bug.`
+            )
+          }
+          incompleteTransactionKey = storeCurrentTransactionKey
+          const subscription = currentTransaction.subject.subscribe((update) => {
+            if (timelineData.timeTraveling === false) {
+              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()
+            incompleteTransactionKey = null
+            store.config.logger?.info(
+              `⌛ timeline "${options.key}" pushed a transaction_update from "${update.key}"`
+            )
+          })
+        }
+      } else {
+        if (timelineData.timeTraveling === false) {
+          timelineData.history.push({
+            type: `state_update`,
+            key: token.key,
+            oldValue: update.oldValue,
+            newValue: update.newValue,
+          })
+          store.config.logger?.info(
+            `⌛ timeline "${options.key}" pushed a state_update to "${token.key}"`
+          )
+          timelineData.at = timelineData.history.length
+        }
+      }
+    })
+  }
+
+  for (const tokenOrFamily of options.atoms) {
+    if (tokenOrFamily.type === `atom_family`) {
+      const family = tokenOrFamily
+      family.subject.subscribe((token) => subscribeToAtom(token))
+    } else {
+      const token = tokenOrFamily
+      subscribeToAtom(token)
+    }
+  }
+
+  store.timelineStore = HAMT.set(options.key, timelineData, store.timelineStore)
+
+  return {
+    key: options.key,
+    type: `timeline`,
+  }
+}
+
+export const redo__INTERNAL = (
+  token: TimelineToken,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const timelineData = store.timelineStore.get(token.key)
+  if (!timelineData) {
+    store.config.logger?.error(
+      `Tried to redo on timeline "${token.key}" has not been initialized.`
+    )
+    return
+  }
+  if (timelineData.at === timelineData.history.length) {
+    store.config.logger?.warn(
+      `Tried to redo on timeline "${token.key}" but there is nothing to redo.`
+    )
+    return
+  }
+  timelineData.timeTraveling = true
+  const update = timelineData.history[timelineData.at]
+  switch (update.type) {
+    case `state_update`: {
+      const { key, newValue } = update
+      setState({ key, type: `atom` }, newValue)
+      break
+    }
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, newValue } = atomUpdate
+        setState({ key, type: `atom` }, newValue)
+      }
+      break
+    }
+  }
+  ++timelineData.at
+  timelineData.timeTraveling = false
+}
+
+export const undo__INTERNAL = (
+  token: TimelineToken,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const timelineData = store.timelineStore.get(token.key)
+  if (!timelineData) {
+    store.config.logger?.error(
+      `Tried to undo on timeline "${token.key}" has not been initialized.`
+    )
+    return
+  }
+  if (timelineData.at === 0) {
+    store.config.logger?.warn(
+      `Tried to undo on timeline "${token.key}" but there is nothing to undo.`
+    )
+    return
+  }
+  timelineData.timeTraveling = true
+  --timelineData.at
+  const update = timelineData.history[timelineData.at]
+  switch (update.type) {
+    case `state_update`: {
+      const { key, oldValue } = update
+      setState({ key, type: `atom` }, oldValue)
+      break
+    }
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, oldValue } = atomUpdate
+        setState({ key, type: `atom` }, oldValue)
+      }
+      break
+    }
+  }
+  timelineData.timeTraveling = false
+}

package/src/internal/transaction-internal.ts

@@ -1,34 +1,175 @@
-import type { Store } from "./store"
+import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
 
-export const finishTransaction = (store: Store): void => {
-  store.transaction = { open: false }
-  store.config.logger?.info(`🛬`, `transaction done`)
+import type { Store, StoreCore } from "."
+import { deposit, withdraw, IMPLICIT } from "."
+import { getState, setState } from ".."
+import type {
+  AtomToken,
+  StateUpdate,
+  Transaction,
+  TransactionOptions,
+  TransactionToken,
+  ƒn,
+} 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> = {
+  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 const startTransaction = (store: Store): void => {
-  store.transaction = {
-    open: true,
-    prev: {
+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}" (init)`
+  )
+  store.transactionStatus.phase = `applying`
+  store.transactionStatus.output = output
+  const { atomUpdates } = store.transactionStatus
+  for (const { key, oldValue, newValue } of atomUpdates) {
+    const token: AtomToken<unknown> = { key, type: `atom` }
+    const state = withdraw(token, store)
+    setState(state, newValue, store)
+  }
+  const myTransaction = withdraw<ƒ>(
+    { key: store.transactionStatus.key, type: `transaction` },
+    store
+  )
+  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, newValue } of update.atomUpdates) {
+    const token: AtomToken<unknown> = { key, type: `atom` }
+    const state = withdraw(token, 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, oldValue, newValue } of update.atomUpdates) {
+    const token: AtomToken<unknown> = { key, type: `atom` }
+    const state = withdraw(token, store)
+    setState(state, newValue, store)
   }
-  store.config.logger?.info(`🛫`, `transaction start`)
 }
+
 export const abortTransaction = (store: Store): void => {
-  if (!store.transaction.open) {
+  if (store.transactionStatus.phase === `idle`) {
     store.config.logger?.warn(
       `abortTransaction called outside of a transaction. This is probably a bug.`
     )
     return
   }
-  store.atoms = store.transaction.prev.atoms
-  store.readonlySelectors = store.transaction.prev.readonlySelectors
-  store.selectorGraph = store.transaction.prev.selectorGraph
-  store.selectors = store.transaction.prev.selectors
-  store.valueMap = store.transaction.prev.valueMap
-  store.transaction = { open: false }
+  store.transactionStatus = { phase: `idle` }
   store.config.logger?.info(`🪂`, `transaction fail`)
 }
+
+export function transaction__INTERNAL<ƒ extends ƒn>(
+  options: TransactionOptions<ƒ>,
+  store: Store = IMPLICIT.STORE
+): TransactionToken<ƒ> {
+  const newTransaction: Transaction<ƒ> = {
+    key: options.key,
+    type: `transaction`,
+    run: (...params: Parameters<ƒ>) => {
+      buildTransaction(options.key, params, store)
+      try {
+        const output = options.do(
+          {
+            get: (token) => getState(token, store),
+            set: (token, value) => setState(token, value, store),
+          },
+          ...params
+        )
+        applyTransaction(output, store)
+        return output
+      } catch (thrown) {
+        abortTransaction(store)
+        store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
+        throw thrown
+      }
+    },
+    subject: new Rx.Subject(),
+  }
+  const core = target(store)
+  core.transactions = HAMT.set(
+    newTransaction.key,
+    newTransaction,
+    core.transactions
+  )
+  const token = deposit(newTransaction)
+  return token
+}
+
+export const target = (store: Store = IMPLICIT.STORE): StoreCore =>
+  store.transactionStatus.phase === `building`
+    ? store.transactionStatus.core
+    : store

package/src/react/index.ts

@@ -2,11 +2,10 @@ import type Preact from "preact/hooks"
 
 import type React from "react"
 
-import type { Modifier } from "~/packages/anvl/src/function"
+import { subscribe, setState, __INTERNAL__ } from "atom.io"
+import type { ReadonlyValueToken, StateToken } from "atom.io"
 
-import type { ReadonlyValueToken, StateToken } from ".."
-import { subscribe, setState, __INTERNAL__ } from ".."
-import { withdraw } from "../internal"
+import type { Modifier } from "~/packages/anvl/src/function"
 
 export type AtomStoreReactConfig = {
   useState: typeof Preact.useState | typeof React.useState
@@ -26,7 +25,7 @@ export const composeStoreHooks = ({
   }
 
   function useO<T>(token: ReadonlyValueToken<T> | StateToken<T>): T {
-    const state = withdraw(token, store)
+    const state = __INTERNAL__.withdraw(token, store)
     const initialValue = __INTERNAL__.getState__INTERNAL(state, store)
     const [current, dispatch] = useState(initialValue)
     useEffect(() => {
@@ -40,7 +39,7 @@ export const composeStoreHooks = ({
         store
       )
       return unsubscribe
-    }, [current, dispatch])
+    }, [])
 
     return current
   }

package/src/selector.ts

@@ -1,13 +1,9 @@
-import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
+import type * as Rx from "rxjs"
 
-import { become } from "~/packages/anvl/src/function"
 import type { Serializable } from "~/packages/anvl/src/json"
-import { stringifyJson } from "~/packages/anvl/src/json"
 
 import type { ReadonlyValueToken, SelectorToken } from "."
-import type { Selector, Store } from "./internal"
-import { IMPLICIT, markDone, deposit, registerSelector } from "./internal"
+import { selectorFamily__INTERNAL, selector__INTERNAL } from "./internal"
 import type { ReadonlyTransactors, Transactors } from "./transaction"
 
 export type SelectorOptions<T> = {
@@ -17,67 +13,14 @@ export type SelectorOptions<T> = {
 }
 export type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>
 
+export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
 export function selector<T>(
-  options: SelectorOptions<T>,
-  store?: Store
-): SelectorToken<T>
-export function selector<T>(
-  options: ReadonlySelectorOptions<T>,
-  store?: Store
+  options: ReadonlySelectorOptions<T>
 ): ReadonlyValueToken<T>
 export function selector<T>(
-  options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
-  store: Store = IMPLICIT.STORE
+  options: ReadonlySelectorOptions<T> | SelectorOptions<T>
 ): ReadonlyValueToken<T> | SelectorToken<T> {
-  if (HAMT.has(options.key, store.selectors)) {
-    throw new Error(`Key "${options.key}" already exists in the store.`)
-  }
-
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
-
-  const { get, set } = registerSelector(options.key, store)
-  const getSelf = () => {
-    const value = options.get({ get })
-    store.valueMap = HAMT.set(options.key, value, store.valueMap)
-    return value
-  }
-
-  if (!(`set` in options)) {
-    const readonlySelector = {
-      ...options,
-      subject,
-      get: getSelf,
-    }
-    store.readonlySelectors = HAMT.set(
-      options.key,
-      readonlySelector,
-      store.readonlySelectors
-    )
-    const initialValue = getSelf()
-    store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-    return { ...readonlySelector, type: `readonly_selector` }
-  }
-
-  const setSelf = (next: T | ((oldValue: T) => T)): void => {
-    store.config.logger?.info(`   <- "${options.key}" became`, next)
-    const oldValue = getSelf()
-    const newValue = become(next)(oldValue)
-    store.valueMap = HAMT.set(options.key, newValue, store.valueMap)
-    markDone(options.key, store)
-    subject.next({ newValue, oldValue })
-    options.set({ get, set }, newValue)
-  }
-
-  const mySelector: Selector<T> = {
-    ...options,
-    subject,
-    get: getSelf,
-    set: setSelf,
-  }
-  store.selectors = HAMT.set(options.key, mySelector, store.selectors)
-  const initialValue = getSelf()
-  store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  return { ...mySelector, type: `selector` }
+  return selector__INTERNAL(options)
 }
 
 export type SelectorFamilyOptions<T, K extends Serializable> = {
@@ -90,43 +33,30 @@ export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<
   `set`
 >
 
+export type SelectorFamily<T, K extends Serializable = Serializable> = ((
+  key: K
+) => SelectorToken<T>) & {
+  key: string
+  type: `selector_family`
+  subject: Rx.Subject<SelectorToken<T>>
+}
+
+export type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((
+  key: K
+) => ReadonlyValueToken<T>) & {
+  key: string
+  type: `readonly_selector_family`
+  subject: Rx.Subject<ReadonlyValueToken<T>>
+}
+
 export function selectorFamily<T, K extends Serializable>(
-  options: SelectorFamilyOptions<T, K>,
-  store?: Store
-): (key: K) => SelectorToken<T>
+  options: SelectorFamilyOptions<T, K>
+): SelectorFamily<T, K>
 export function selectorFamily<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K>,
-  store?: Store
-): (key: K) => ReadonlyValueToken<T>
+  options: ReadonlySelectorFamilyOptions<T, K>
+): ReadonlySelectorFamily<T, K>
 export function selectorFamily<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
-  store: Store = IMPLICIT.STORE
-): (key: K) => ReadonlyValueToken<T> | SelectorToken<T> {
-  return (key: K): ReadonlyValueToken<T> | SelectorToken<T> => {
-    const fullKey = `${options.key}__${stringifyJson(key)}`
-    const existing =
-      store.selectors.get(fullKey) ?? store.readonlySelectors.get(fullKey)
-    if (existing) {
-      return deposit(existing)
-    }
-    const readonlySelectorOptions: ReadonlySelectorOptions<T> = {
-      key: fullKey,
-      get: options.get(key),
-    }
-    if (!(`set` in options)) {
-      return selector<T>(
-        {
-          ...readonlySelectorOptions,
-        },
-        store
-      )
-    }
-    return selector<T>(
-      {
-        ...readonlySelectorOptions,
-        set: options.set(key),
-      },
-      store
-    )
-  }
+  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>
+): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
+  return selectorFamily__INTERNAL(options)
 }