atom.io 0.2.0 → 0.3.1

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,293 @@
+/* eslint-disable max-lines */
+
+import HAMT from "hamt_plus"
+
+import type { KeyedStateUpdate, TransactionUpdate, Store } from "."
+import { target, 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 TimelineAtomUpdate = KeyedStateUpdate<unknown> & {
+  type: `atom_update`
+}
+export type TimelineSelectorUpdate = {
+  key: string
+  type: `selector_update`
+  atomUpdates: TimelineAtomUpdate[]
+}
+export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+  type: `transaction_update`
+}
+
+export type TimelineData = {
+  at: number
+  timeTraveling: boolean
+  history: (
+    | TimelineAtomUpdate
+    | TimelineSelectorUpdate
+    | TimelineTransactionUpdate
+  )[]
+}
+
+export function timeline__INTERNAL(
+  options: TimelineOptions,
+  store: Store = IMPLICIT.STORE
+): TimelineToken {
+  let incompleteSelectorTime: number | null = null
+  // let selectorAtomUpdates: TimelineAtomUpdate[] = []
+  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 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 "${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) {
+              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()
+            incompleteTransactionKey = null
+            store.config.logger?.info(
+              `⌛ timeline "${options.key}" got a transaction_update "${update.key}"`
+            )
+          })
+        }
+      } else if (storeCurrentSelectorKey) {
+        if (timelineData.timeTraveling === false) {
+          if (storeCurrentSelectorTime !== incompleteSelectorTime) {
+            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
+            incompleteSelectorTime = 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) {
+          incompleteSelectorTime = 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)
+    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) => subscribeToAtom(token))
+    } 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
+        }
+      }
+      subscribeToAtom(token)
+    }
+    core.timelineAtoms = core.timelineAtoms.set(tokenOrFamily.key, options.key)
+  }
+
+  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 => {
+  store.config.logger?.info(`⏩ redo "${token.key}"`)
+  const timelineData = store.timelineStore.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)
+      break
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, newValue } = atomUpdate
+        setState({ key, type: `atom` }, newValue)
+      }
+      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
+): void => {
+  store.config.logger?.info(`⏪ undo "${token.key}"`)
+  const timelineData = store.timelineStore.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)
+      break
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, oldValue } = atomUpdate
+        setState({ key, type: `atom` }, oldValue)
+      }
+      break
+    }
+  }
+  timelineData.timeTraveling = false
+  store.config.logger?.info(
+    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  )
+}

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/logger.ts

@@ -0,0 +1,46 @@
+import { doNothing } from "~/packages/anvl/src/function"
+
+import type { Store } from "./internal/store"
+import { IMPLICIT } from "./internal/store"
+
+export type Logger = Pick<Console, `error` | `info` | `warn`>
+export const LOG_LEVELS: ReadonlyArray<keyof Logger> = [
+  `info`,
+  `warn`,
+  `error`,
+] as const
+
+export const setLogLevel = (
+  preferredLevel: `error` | `info` | `warn` | null,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const { logger__INTERNAL } = store.config
+  if (preferredLevel === null) {
+    store.config.logger = null
+  } else {
+    store.config.logger = { ...console }
+    LOG_LEVELS.forEach((logLevel) => {
+      if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+        store.config.logger![logLevel] = doNothing
+      } else {
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+        store.config.logger![logLevel] = logger__INTERNAL[logLevel]
+      }
+    })
+  }
+}
+
+export const useLogger = (
+  logger: Logger,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const currentLogLevel =
+    store.config.logger === null
+      ? null
+      : LOG_LEVELS.find(
+          (logLevel) => store.config.logger?.[logLevel] !== doNothing
+        ) ?? null
+  store.config.logger__INTERNAL = { ...logger }
+  setLogLevel(currentLogLevel, 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
   }