atom.io 0.1.0 → 0.3.0

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

@@ -0,0 +1,175 @@
+import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
+
+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 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)
+  }
+}
+
+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`)
+}
+
+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

@@ -0,0 +1,64 @@
+import type Preact from "preact/hooks"
+
+import type React from "react"
+
+import { subscribe, setState, __INTERNAL__ } from "atom.io"
+import type { ReadonlyValueToken, StateToken } from "atom.io"
+
+import type { Modifier } from "~/packages/anvl/src/function"
+
+export type AtomStoreReactConfig = {
+  useState: typeof Preact.useState | typeof React.useState
+  useEffect: typeof Preact.useEffect | typeof React.useEffect
+  store?: __INTERNAL__.Store
+}
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+export const composeStoreHooks = ({
+  useState,
+  useEffect,
+  store = __INTERNAL__.IMPLICIT.STORE,
+}: AtomStoreReactConfig) => {
+  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: ReadonlyValueToken<T> | StateToken<T>): T {
+    const state = __INTERNAL__.withdraw(token, store)
+    const initialValue = __INTERNAL__.getState__INTERNAL(state, store)
+    const [current, dispatch] = useState(initialValue)
+    useEffect(() => {
+      const unsubscribe = subscribe(
+        token,
+        ({ newValue, oldValue }) => {
+          if (oldValue !== newValue) {
+            dispatch(newValue)
+          }
+        },
+        store
+      )
+      return unsubscribe
+    }, [])
+
+    return current
+  }
+
+  function useIO<T>(token: StateToken<T>): [T, (next: Modifier<T> | T) => void] {
+    return [useO(token), useI(token)]
+  }
+
+  function useStore<T>(
+    token: StateToken<T>
+  ): [T, (next: Modifier<T> | T) => void]
+  function useStore<T>(token: ReadonlyValueToken<T>): T
+  function useStore<T>(
+    token: ReadonlyValueToken<T> | StateToken<T>
+  ): T | [T, (next: Modifier<T> | T) => void] {
+    if (token.type === `readonly_selector`) {
+      return useO(token)
+    }
+    return useIO(token)
+  }
+  return { useI, useO, useIO, useStore }
+}

package/src/selector.ts

@@ -0,0 +1,62 @@
+import type * as Rx from "rxjs"
+
+import type { Serializable } from "~/packages/anvl/src/json"
+
+import type { ReadonlyValueToken, SelectorToken } from "."
+import { selectorFamily__INTERNAL, selector__INTERNAL } from "./internal"
+import type { ReadonlyTransactors, Transactors } from "./transaction"
+
+export type SelectorOptions<T> = {
+  key: string
+  get: (readonlyTransactors: ReadonlyTransactors) => T
+  set: (transactors: Transactors, newValue: T) => void
+}
+export type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>
+
+export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
+export function selector<T>(
+  options: ReadonlySelectorOptions<T>
+): ReadonlyValueToken<T>
+export function selector<T>(
+  options: ReadonlySelectorOptions<T> | SelectorOptions<T>
+): ReadonlyValueToken<T> | SelectorToken<T> {
+  return selector__INTERNAL(options)
+}
+
+export type SelectorFamilyOptions<T, K extends Serializable> = {
+  key: string
+  get: (key: K) => (readonlyTransactors: ReadonlyTransactors) => T
+  set: (key: K) => (transactors: Transactors, newValue: T) => void
+}
+export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<
+  SelectorFamilyOptions<T, K>,
+  `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>
+): SelectorFamily<T, K>
+export function selectorFamily<T, K extends Serializable>(
+  options: ReadonlySelectorFamilyOptions<T, K>
+): ReadonlySelectorFamily<T, K>
+export function selectorFamily<T, K extends Serializable>(
+  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>
+): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
+  return selectorFamily__INTERNAL(options)
+}

package/src/subscribe.ts

@@ -0,0 +1,55 @@
+import type { ReadonlyValueToken, StateToken, TransactionToken, ƒn } from "."
+import type { Store, TransactionUpdate } from "./internal"
+import { IMPLICIT, subscribeToRootAtoms, withdraw } from "./internal"
+
+export type StateUpdate<T> = { newValue: T; oldValue: T }
+export type UpdateHandler<T> = (update: StateUpdate<T>) => void
+
+export const subscribe = <T>(
+  token: ReadonlyValueToken<T> | StateToken<T>,
+  handleUpdate: UpdateHandler<T>,
+  store: Store = IMPLICIT.STORE
+): (() => void) => {
+  const state = withdraw<T>(token, store)
+  const subscription = state.subject.subscribe(handleUpdate)
+  store.config.logger?.info(`👀 subscribe to "${state.key}"`)
+  const dependencySubscriptions =
+    `get` in state ? subscribeToRootAtoms(state, store) : null
+
+  const unsubscribe =
+    dependencySubscriptions === null
+      ? () => {
+          store.config.logger?.info(`🙈 unsubscribe from "${state.key}"`)
+          subscription.unsubscribe()
+        }
+      : () => {
+          store.config.logger?.info(
+            `🙈 unsubscribe from "${state.key}" and its dependencies`
+          )
+          subscription.unsubscribe()
+          for (const dependencySubscription of dependencySubscriptions) {
+            dependencySubscription.unsubscribe()
+          }
+        }
+
+  return unsubscribe
+}
+
+export type TransactionUpdateHandler<ƒ extends ƒn> = (
+  data: TransactionUpdate<ƒ>
+) => void
+
+export const subscribeToTransaction = <ƒ extends ƒn>(
+  token: TransactionToken<ƒ>,
+  handleUpdate: TransactionUpdateHandler<ƒ>,
+  store = IMPLICIT.STORE
+): (() => void) => {
+  const tx = withdraw(token, store)
+  store.config.logger?.info(`👀 subscribe to transaction "${token.key}"`)
+  const subscription = tx.subject.subscribe(handleUpdate)
+  const unsubscribe = () => {
+    store.config.logger?.info(`🙈 unsubscribe from transaction "${token.key}"`)
+    subscription.unsubscribe()
+  }
+  return unsubscribe
+}

package/src/timeline.ts

@@ -0,0 +1,34 @@
+import HAMT from "hamt_plus"
+import type * as Rx from "rxjs"
+
+import type { AtomFamily, AtomToken, ƒn } from "."
+import { setState } from "."
+import type { Store, KeyedStateUpdate, TransactionUpdate } from "./internal"
+import { target, IMPLICIT, withdraw } from "./internal"
+import {
+  redo__INTERNAL,
+  timeline__INTERNAL,
+  undo__INTERNAL,
+} from "./internal/timeline-internal"
+
+export type TimelineToken = {
+  key: string
+  type: `timeline`
+}
+
+export type TimelineOptions = {
+  key: string
+  atoms: (AtomFamily<any> | AtomToken<any>)[]
+}
+
+export const timeline = (options: TimelineOptions): TimelineToken => {
+  return timeline__INTERNAL(options)
+}
+
+export const redo = (token: TimelineToken): void => {
+  return redo__INTERNAL(token, IMPLICIT.STORE)
+}
+
+export const undo = (token: TimelineToken): void => {
+  return undo__INTERNAL(token, IMPLICIT.STORE)
+}

package/src/transaction.ts

@@ -0,0 +1,41 @@
+import type * as Rx from "rxjs"
+
+import type { ReadonlyValueToken, StateToken, TransactionToken } from "."
+import type { Store, TransactionUpdate } from "./internal"
+import { IMPLICIT, transaction__INTERNAL, withdraw } from "./internal"
+
+export type ƒn = (...parameters: any[]) => any
+
+export type Transactors = {
+  get: <S>(state: ReadonlyValueToken<S> | StateToken<S>) => S
+  set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void
+}
+export type ReadonlyTransactors = Pick<Transactors, `get`>
+
+export type Action<ƒ extends ƒn> = (
+  transactors: Transactors,
+  ...parameters: Parameters<ƒ>
+) => ReturnType<ƒ>
+
+export type TransactionOptions<ƒ extends ƒn> = {
+  key: string
+  do: Action<ƒ>
+}
+
+export type Transaction<ƒ extends ƒn> = {
+  key: string
+  type: `transaction`
+  run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
+  subject: Rx.Subject<TransactionUpdate<ƒ>>
+}
+
+export function transaction<ƒ extends ƒn>(
+  options: TransactionOptions<ƒ>
+): TransactionToken<ƒ> {
+  return transaction__INTERNAL(options)
+}
+
+export const runTransaction =
+  <ƒ extends ƒn>(token: TransactionToken<ƒ>, store: Store = IMPLICIT.STORE) =>
+  (...parameters: Parameters<ƒ>): ReturnType<ƒ> =>
+    withdraw(token, store).run(...parameters)