atom.io 0.5.0 → 0.6.1

package/src/internal/selector-internal.ts

@@ -1,34 +1,23 @@
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
-
-import { become } from "~/packages/anvl/src/function"
+import type * as Rx from "rxjs"
 
 import type { Store } from "."
-import {
-  target,
-  cacheValue,
-  markDone,
-  lookup,
-  IMPLICIT,
-  getState__INTERNAL,
-  setState__INTERNAL,
-  withdraw,
-} from "."
+import { target, IMPLICIT } from "."
+import { createReadWriteSelector } from "./selector/create-read-write-selector"
+import { createReadonlySelector } from "./selector/create-readonly-selector"
 import type {
-  AtomToken,
   FamilyMetadata,
   ReadonlySelectorOptions,
   ReadonlySelectorToken,
   SelectorOptions,
   SelectorToken,
-  StateToken,
 } from ".."
-import type { Transactors } from "../transaction"
 
 export type Selector<T> = {
   key: string
   type: `selector`
   family?: FamilyMetadata
+  install: (store: Store) => void
   subject: Rx.Subject<{ newValue: T; oldValue: T }>
   get: () => T
   set: (newValue: T | ((oldValue: T) => T)) => void
@@ -37,143 +26,11 @@ export type ReadonlySelector<T> = {
   key: string
   type: `readonly_selector`
   family?: FamilyMetadata
+  install: (store: Store) => void
   subject: Rx.Subject<{ newValue: T; oldValue: T }>
   get: () => T
 }
 
-export const lookupSelectorSources = (
-  key: string,
-  store: Store
-): (
-  | AtomToken<unknown>
-  | ReadonlySelectorToken<unknown>
-  | SelectorToken<unknown>
-)[] =>
-  target(store)
-    .selectorGraph.getRelations(key)
-    .filter(({ source }) => source !== key)
-    .map(({ source }) => lookup(source, store))
-
-export const traceSelectorAtoms = (
-  selectorKey: string,
-  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store
-): AtomToken<unknown>[] => {
-  const roots: AtomToken<unknown>[] = []
-
-  const sources = lookupSelectorSources(dependency.key, store)
-  let depth = 0
-  while (sources.length > 0) {
-    /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-    const source = sources.shift()!
-    ++depth
-    if (depth > 999) {
-      throw new Error(
-        `Maximum selector dependency depth exceeded in selector "${selectorKey}".`
-      )
-    }
-
-    if (source.type !== `atom`) {
-      sources.push(...lookupSelectorSources(source.key, store))
-    } else {
-      roots.push(source)
-    }
-  }
-
-  return roots
-}
-
-export const traceAllSelectorAtoms = (
-  selectorKey: string,
-  store: Store
-): AtomToken<unknown>[] => {
-  const sources = lookupSelectorSources(selectorKey, store)
-  return sources.flatMap((source) =>
-    source.type === `atom`
-      ? source
-      : traceSelectorAtoms(selectorKey, source, store)
-  )
-}
-
-export const updateSelectorAtoms = (
-  selectorKey: string,
-  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store
-): void => {
-  const core = target(store)
-  if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: dependency.key,
-    })
-    store.config.logger?.info(
-      `   || adding root for "${selectorKey}": ${dependency.key}`
-    )
-    return
-  }
-  const roots = traceSelectorAtoms(selectorKey, dependency, store)
-  store.config.logger?.info(
-    `   || adding roots for "${selectorKey}":`,
-    roots.map((r) => r.key)
-  )
-  for (const root of roots) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: root.key,
-    })
-  }
-}
-
-export const registerSelector = (
-  selectorKey: string,
-  store: Store = IMPLICIT.STORE
-): Transactors => ({
-  get: (dependency) => {
-    const core = target(store)
-    const alreadyRegistered = core.selectorGraph
-      .getRelations(selectorKey)
-      .some(({ source }) => source === dependency.key)
-
-    const dependencyState = withdraw(dependency, store)
-    if (dependencyState === null) {
-      throw new Error(
-        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      )
-    }
-    const dependencyValue = getState__INTERNAL(dependencyState, store)
-
-    if (alreadyRegistered) {
-      store.config.logger?.info(
-        `   || ${selectorKey} <- ${dependency.key} =`,
-        dependencyValue
-      )
-    } else {
-      store.config.logger?.info(
-        `🔌 registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
-        dependencyValue,
-        `)`
-      )
-      core.selectorGraph = core.selectorGraph.set(
-        { from: dependency.key, to: selectorKey },
-        {
-          source: dependency.key,
-        }
-      )
-    }
-    updateSelectorAtoms(selectorKey, dependency, store)
-    return dependencyValue
-  },
-  set: (stateToken, newValue) => {
-    const state = withdraw(stateToken, store)
-    if (state === null) {
-      throw new Error(
-        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      )
-    }
-    setState__INTERNAL(state, newValue, store)
-  },
-})
-
 export function selector__INTERNAL<T>(
   options: SelectorOptions<T>,
   family?: FamilyMetadata,
@@ -190,70 +47,15 @@ export function selector__INTERNAL<T>(
   store: Store = IMPLICIT.STORE
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
   const core = target(store)
+
   if (HAMT.has(options.key, core.selectors)) {
     store.config.logger?.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 })
-    cacheValue(options.key, value, store)
-    return value
-  }
   if (!(`set` in options)) {
-    const readonlySelector: ReadonlySelector<T> = {
-      ...options,
-      subject,
-      get: getSelf,
-      type: `readonly_selector`,
-      ...(family && { family }),
-    }
-    core.readonlySelectors = HAMT.set(
-      options.key,
-      readonlySelector,
-      core.readonlySelectors
-    )
-    const initialValue = getSelf()
-    store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-    const token: ReadonlySelectorToken<T> = {
-      key: options.key,
-      type: `readonly_selector`,
-      family,
-    }
-    store.subject.selectorCreation.next(token)
-    return token
-  }
-  const setSelf = (next: T | ((oldValue: T) => T)): void => {
-    store.config.logger?.info(`   <- "${options.key}" became`, next)
-    const oldValue = getSelf()
-    const newValue = become(next)(oldValue)
-    cacheValue(options.key, newValue, store)
-    markDone(options.key, store)
-    if (store.transactionStatus.phase === `idle`) {
-      subject.next({ newValue, oldValue })
-    }
-    options.set({ get, set }, newValue)
-  }
-  const mySelector: Selector<T> = {
-    ...options,
-    subject,
-    get: getSelf,
-    set: setSelf,
-    type: `selector`,
-    ...(family && { family }),
-  }
-  core.selectors = HAMT.set(options.key, mySelector, core.selectors)
-  const initialValue = getSelf()
-  store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  const token: SelectorToken<T> = {
-    key: options.key,
-    type: `selector`,
-    family,
+    return createReadonlySelector(options, family, store, core)
   }
-  store.subject.selectorCreation.next(token)
-  return token
+  return createReadWriteSelector(options, family, store, core)
 }

package/src/internal/store.ts

@@ -13,7 +13,7 @@ import type {
   Selector,
   TransactionStatus,
   Timeline,
-  TimelineData,
+  Transaction,
 } from "."
 import type {
   AtomToken,
@@ -21,7 +21,6 @@ import type {
   ReadonlySelectorToken,
   SelectorToken,
   TimelineToken,
-  Transaction,
   TransactionToken,
 } from ".."
 
@@ -47,9 +46,8 @@ export interface Store {
   selectorAtoms: Join<null, `selectorKey`, `atomKey`>
   selectorGraph: Join<{ source: string }>
   selectors: Hamt<Selector<any>, string>
-  timelines: Hamt<Timeline, string>
   timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-  timelineStore: Hamt<TimelineData, string>
+  timelines: Hamt<Timeline, string>
   transactions: Hamt<Transaction<any>, string>
   valueMap: Hamt<any, string>
 
@@ -71,46 +69,75 @@ export interface Store {
   }
 }
 
-export const createStore = (name: string): Store =>
-  ({
+export const createStore = (name: string, store: Store | null = null): Store => {
+  const copiedStore = {
+    ...(store ??
+      (() => ({
+        atomsThatAreDefault: new Set(),
+        selectorAtoms: new Join({ relationType: `n:n` })
+          .from(`selectorKey`)
+          .to(`atomKey`),
+        selectorGraph: new Join({ relationType: `n:n` }),
+        valueMap: HAMT.make<any, string>(),
+      }))()),
+
     atoms: HAMT.make<Atom<any>, string>(),
-    atomsThatAreDefault: new Set(),
     readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-    selectorAtoms: new Join({ relationType: `n:n` })
-      .from(`selectorKey`)
-      .to(`atomKey`),
-    selectorGraph: new Join({ relationType: `n:n` }),
     selectors: HAMT.make<Selector<any>, string>(),
+    transactions: HAMT.make<Transaction<any>, string>(),
     timelines: HAMT.make<Timeline, string>(),
+
     timelineAtoms: new Join({ relationType: `1:n` })
       .from(`timelineKey`)
       .to(`atomKey`),
-    timelineStore: HAMT.make<TimelineData, string>(),
-    transactions: HAMT.make<Transaction<any>, string>(),
-    valueMap: HAMT.make<any, string>(),
 
     subject: {
       atomCreation: new Rx.Subject(),
       selectorCreation: new Rx.Subject(),
       transactionCreation: new Rx.Subject(),
       timelineCreation: new Rx.Subject(),
+      ...store?.subject,
     },
 
     operation: {
       open: false,
+      ...store?.operation,
     },
     transactionStatus: {
       phase: `idle`,
+      ...store?.transactionStatus,
     },
     config: {
-      name,
       logger: {
         ...console,
         info: doNothing,
+        ...store?.config?.logger,
       },
       logger__INTERNAL: console,
+      ...store?.config,
+      name,
     },
-  } satisfies Store)
+  } satisfies Store
+
+  store?.atoms.forEach((atom) => {
+    const copiedAtom = { ...atom, subject: new Rx.Subject() } satisfies Atom<any>
+    copiedStore.atoms = HAMT.set(atom.key, copiedAtom, copiedStore.atoms)
+  })
+  store?.readonlySelectors.forEach((selector) => {
+    selector.install(copiedStore)
+  })
+  store?.selectors.forEach((selector) => {
+    selector.install(copiedStore)
+  })
+  store?.transactions.forEach((tx) => {
+    tx.install(copiedStore)
+  })
+  store?.timelines.forEach((timeline) => {
+    timeline.install(copiedStore)
+  })
+
+  return copiedStore
+}
 
 export const IMPLICIT = {
   STORE_INTERNAL: undefined as Store | undefined,

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>(

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"