atom.io 0.1.0 → 0.2.0

package/src/internal/get.ts

@@ -0,0 +1,109 @@
+import { pipe } from "fp-ts/function"
+import HAMT from "hamt_plus"
+
+import type { Atom, ReadonlySelector, Selector } from "."
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+import type {
+  AtomToken,
+  ReadonlyValueToken,
+  SelectorToken,
+  StateToken,
+} from ".."
+
+export const getCachedState = <T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+  store: Store = IMPLICIT.STORE
+): T => {
+  const path = []
+  if (`default` in state) {
+    const atomKey = state.key
+    store.selectorAtoms = pipe(store.selectorAtoms, (oldValue) => {
+      let newValue = oldValue
+      for (const selectorKey of path) {
+        newValue = newValue.set(selectorKey, atomKey)
+      }
+      return newValue
+    })
+  }
+  const value = HAMT.get(state.key, store.valueMap)
+  return value
+}
+
+export const getSelectorState = <T>(
+  selector: ReadonlySelector<T> | Selector<T>
+): T => selector.get()
+
+export function lookup(
+  key: string,
+  store: Store
+): AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown> {
+  const type = HAMT.has(key, store.atoms)
+    ? `atom`
+    : HAMT.has(key, store.selectors)
+    ? `selector`
+    : `readonly_selector`
+  return { key, type }
+}
+
+export function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>
+export function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>
+export function withdraw<T>(
+  token: StateToken<T>,
+  store: Store
+): Atom<T> | Selector<T>
+export function withdraw<T>(
+  token: ReadonlyValueToken<T>,
+  store: Store
+): ReadonlySelector<T>
+export function withdraw<T>(
+  token: ReadonlyValueToken<T> | StateToken<T>,
+  store: Store
+): Atom<T> | ReadonlySelector<T> | Selector<T>
+export function withdraw<T>(
+  token: ReadonlyValueToken<T> | StateToken<T>,
+  store: Store
+): Atom<T> | ReadonlySelector<T> | Selector<T> {
+  return (
+    HAMT.get(token.key, store.atoms) ??
+    HAMT.get(token.key, store.selectors) ??
+    HAMT.get(token.key, store.readonlySelectors)
+  )
+}
+
+export function deposit<T>(state: Atom<T>): AtomToken<T>
+export function deposit<T>(state: Selector<T>): SelectorToken<T>
+export function deposit<T>(state: Atom<T> | Selector<T>): StateToken<T>
+export function deposit<T>(state: ReadonlySelector<T>): ReadonlyValueToken<T>
+export function deposit<T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>
+): ReadonlyValueToken<T> | StateToken<T>
+export function deposit<T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>
+): ReadonlyValueToken<T> | StateToken<T> {
+  if (`get` in state) {
+    if (`set` in state) {
+      return { key: state.key, type: `selector` }
+    }
+    return { key: state.key, type: `readonly_selector` }
+  }
+  return { key: state.key, type: `atom` }
+}
+
+export const getState__INTERNAL = <T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+  store: Store = IMPLICIT.STORE
+): T => {
+  if (HAMT.has(state.key, store.valueMap)) {
+    store.config.logger?.info(`>> read "${state.key}"`)
+    return getCachedState(state, store)
+  }
+  if (`get` in state) {
+    store.config.logger?.info(`-> calc "${state.key}"`)
+    return getSelectorState(state)
+  }
+  store.config.logger?.error(
+    `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
+  )
+  return state.default
+}

package/src/internal/index.ts

@@ -0,0 +1,23 @@
+import type * as Rx from "rxjs"
+
+export * from "./get"
+export * from "./set"
+export * from "./is-default"
+export * from "./selector-internal"
+export * from "./store"
+export * from "./subscribe-internal"
+export * from "./operation"
+export * from "./transaction-internal"
+
+export type Atom<T> = {
+  key: string
+  subject: Rx.Subject<{ newValue: T; oldValue: T }>
+  default: T
+}
+export type Selector<T> = {
+  key: string
+  subject: Rx.Subject<{ newValue: T; oldValue: T }>
+  get: () => T
+  set: (newValue: T | ((oldValue: T) => T)) => void
+}
+export type ReadonlySelector<T> = Omit<Selector<T>, `set`>

package/src/internal/is-default.ts

@@ -0,0 +1,19 @@
+import HAMT from "hamt_plus"
+
+import type { Store } from "."
+import { IMPLICIT, traceAllSelectorAtoms } from "."
+
+export const isAtomDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): boolean => {
+  return HAMT.get(key, store.atomsAreDefault)
+}
+
+export const isSelectorDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): boolean => {
+  const roots = traceAllSelectorAtoms(key, store)
+  return roots.every((root) => isAtomDefault(root.key, store))
+}

package/src/internal/operation.ts

@@ -0,0 +1,49 @@
+import HAMT from "hamt_plus"
+
+import type { Atom, ReadonlySelector, Selector } from "."
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+
+export const startAction = (store: Store): void => {
+  store.operation = {
+    open: true,
+    done: new Set(),
+    prev: store.valueMap,
+  }
+  store.config.logger?.info(`⭕`, `operation start`)
+}
+export const finishAction = (store: Store): void => {
+  store.operation = { open: false }
+  store.config.logger?.info(`🔴`, `operation done`)
+}
+
+export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
+  if (!store.operation.open) {
+    store.config.logger?.warn(
+      `isDone called outside of an action. This is probably a bug.`
+    )
+    return true
+  }
+  return store.operation.done.has(key)
+}
+export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
+  if (!store.operation.open) {
+    store.config.logger?.warn(
+      `markDone called outside of an action. This is probably a bug.`
+    )
+    return
+  }
+  store.operation.done.add(key)
+}
+export const recallState = <T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+  store: Store = IMPLICIT.STORE
+): T => {
+  if (!store.operation.open) {
+    store.config.logger?.warn(
+      `recall called outside of an action. This is probably a bug.`
+    )
+    return HAMT.get(state.key, store.valueMap)
+  }
+  return HAMT.get(state.key, store.operation.prev)
+}

package/src/internal/selector-internal.ts

@@ -0,0 +1,127 @@
+import type { Store } from "."
+import {
+  lookup,
+  IMPLICIT,
+  getState__INTERNAL,
+  setState__INTERNAL,
+  withdraw,
+} from "."
+import type {
+  AtomToken,
+  ReadonlyValueToken,
+  SelectorToken,
+  StateToken,
+} from ".."
+import type { Transactors } from "../transaction"
+
+export const lookupSelectorSources = (
+  key: string,
+  store: Store
+): (
+  | AtomToken<unknown>
+  | ReadonlyValueToken<unknown>
+  | SelectorToken<unknown>
+)[] =>
+  store.selectorGraph
+    .getRelations(key)
+    .filter(({ source }) => source !== key)
+    .map(({ source }) => lookup(source, store))
+
+export const traceSelectorAtoms = (
+  selectorKey: string,
+  dependency: ReadonlyValueToken<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: ReadonlyValueToken<unknown> | StateToken<unknown>,
+  store: Store
+): void => {
+  if (dependency.type === `atom`) {
+    store.selectorAtoms = store.selectorAtoms.set(selectorKey, 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)
+  for (const root of roots) {
+    store.selectorAtoms = store.selectorAtoms.set(selectorKey, root.key)
+  }
+}
+
+export const registerSelector = (
+  selectorKey: string,
+  store: Store = IMPLICIT.STORE
+): Transactors => ({
+  get: (dependency) => {
+    const alreadyRegistered = store.selectorGraph
+      .getRelations(selectorKey)
+      .some(({ source }) => source === dependency.key)
+
+    const dependencyState = withdraw(dependency, store)
+    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
+      )
+      store.selectorGraph = store.selectorGraph.set(
+        selectorKey,
+        dependency.key,
+        {
+          source: dependency.key,
+        }
+      )
+    }
+    updateSelectorAtoms(selectorKey, dependency, store)
+    return dependencyValue
+  },
+  set: (stateToken, newValue) => {
+    const state = withdraw(stateToken, store)
+    setState__INTERNAL(state, newValue, store)
+  },
+})

package/src/internal/set.ts

@@ -0,0 +1,88 @@
+import HAMT from "hamt_plus"
+
+import { become } from "~/packages/anvl/src/function"
+
+import type { Atom, Selector } from "."
+import { isAtomDefault } from "."
+import { getState__INTERNAL } from "./get"
+import { isDone, markDone } from "./operation"
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+
+export const evictDownStream = <T>(
+  state: Atom<T>,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const downstream = store.selectorAtoms.getRelations(state.key)
+  const downstreamKeys = downstream.map(({ id }) => id)
+  store.config.logger?.info(
+    `   || ${downstreamKeys.length} downstream:`,
+    downstreamKeys
+  )
+  if (store.operation.open) {
+    store.config.logger?.info(`   ||`, [...store.operation.done], `already done`)
+  }
+  downstream.forEach(({ id: stateKey }) => {
+    if (isDone(stateKey, store)) {
+      store.config.logger?.info(`   || ${stateKey} already done`)
+      return
+    }
+    const state =
+      HAMT.get(stateKey, store.selectors) ??
+      HAMT.get(stateKey, store.readonlySelectors)
+    if (!state) {
+      store.config.logger?.info(
+        `   || ${stateKey} is an atom, and can't be downstream`
+      )
+      return
+    }
+    store.valueMap = HAMT.remove(stateKey, store.valueMap)
+    store.config.logger?.info(`   xx evicted "${stateKey}"`)
+
+    markDone(stateKey, store)
+  })
+}
+
+export const setAtomState = <T>(
+  atom: Atom<T>,
+  next: T | ((oldValue: T) => T),
+  store: Store = IMPLICIT.STORE
+): void => {
+  const oldValue = getState__INTERNAL(atom, store)
+  const newValue = become(next)(oldValue)
+  store.config.logger?.info(`-> setting atom "${atom.key}" to`, newValue)
+  store.valueMap = HAMT.set(atom.key, newValue, store.valueMap)
+  if (isAtomDefault(atom.key)) {
+    store.atomsAreDefault = HAMT.set(atom.key, false, store.atomsAreDefault)
+  }
+  markDone(atom.key, store)
+  store.config.logger?.info(
+    `   || evicting caches downstream from "${atom.key}"`
+  )
+  evictDownStream(atom, store)
+  atom.subject.next({ newValue, oldValue })
+}
+export const setSelectorState = <T>(
+  selector: Selector<T>,
+  next: T | ((oldValue: T) => T),
+  store: Store = IMPLICIT.STORE
+): void => {
+  const oldValue = getState__INTERNAL(selector, store)
+  const newValue = become(next)(oldValue)
+
+  store.config.logger?.info(`-> setting selector "${selector.key}" to`, newValue)
+  store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
+
+  selector.set(newValue)
+}
+export const setState__INTERNAL = <T>(
+  state: Atom<T> | Selector<T>,
+  value: T | ((oldValue: T) => T),
+  store: Store = IMPLICIT.STORE
+): void => {
+  if (`set` in state) {
+    setSelectorState(state, value, store)
+  } else {
+    setAtomState(state, value, store)
+  }
+}

package/src/internal/store.ts

@@ -0,0 +1,84 @@
+import type { Hamt } from "hamt_plus"
+import HAMT from "hamt_plus"
+
+import { Join } from "~/packages/anvl/src/join"
+
+import type { Atom, ReadonlySelector, Selector } from "."
+
+export interface Store {
+  valueMap: Hamt<any, string>
+  selectorGraph: Join<{ source: string }>
+  selectorAtoms: Join
+  atoms: Hamt<Atom<any>, string>
+  atomsAreDefault: Hamt<boolean, string>
+  selectors: Hamt<Selector<any>, string>
+  readonlySelectors: Hamt<ReadonlySelector<any>, string>
+  operation:
+    | {
+        open: false
+      }
+    | {
+        open: true
+        done: Set<string>
+        prev: Hamt<any, string>
+      }
+  transaction:
+    | {
+        open: false
+      }
+    | {
+        open: true
+        prev: Pick<
+          Store,
+          | `atoms`
+          | `readonlySelectors`
+          | `selectorGraph`
+          | `selectors`
+          | `valueMap`
+        >
+      }
+  config: {
+    name: string
+    logger: Pick<Console, `error` | `info` | `warn`> | null
+  }
+}
+
+export const createStore = (name: string): Store =>
+  ({
+    valueMap: HAMT.make<any, string>(),
+    selectorGraph: new Join({ relationType: `n:n` }),
+    selectorAtoms: new Join({ relationType: `n:n` }),
+    atoms: HAMT.make<Atom<any>, string>(),
+    atomsAreDefault: HAMT.make<boolean, string>(),
+    selectors: HAMT.make<Selector<any>, string>(),
+    readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
+    operation: {
+      open: false,
+    },
+    transaction: {
+      open: false,
+    },
+    config: {
+      name,
+      logger: null,
+    },
+  } satisfies Store)
+
+export const IMPLICIT = {
+  STORE_INTERNAL: undefined as Store | undefined,
+  get STORE(): Store {
+    return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
+  },
+}
+export const configure = (
+  config: Partial<Store[`config`]>,
+  store: Store = IMPLICIT.STORE
+): void => {
+  Object.assign(store.config, config)
+}
+
+export const clearStore = (store: Store = IMPLICIT.STORE): void => {
+  const { config } = store
+  Object.assign(store, createStore(config.name))
+  store.config = config
+}

package/src/internal/subscribe-internal.ts

@@ -0,0 +1,33 @@
+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 ".."
+
+export const subscribeToRootAtoms = <T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+  store: Store = IMPLICIT.STORE
+): { unsubscribe: () => void }[] | null => {
+  const dependencySubscriptions =
+    `default` in state
+      ? null
+      : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+          const atom = withdraw(atomToken, store)
+          return atom.subject.subscribe((atomChange) => {
+            store.config.logger?.info(
+              `📢 atom changed: "${atomToken.key}" (`,
+              atomChange.oldValue,
+              `->`,
+              atomChange.newValue,
+              `) re-evaluating "${state.key}"`
+            )
+            const oldValue = recallState(state, store)
+            const newValue = getState__INTERNAL(state, store)
+            store.config.logger?.info(`   <- ${state.key} became`, newValue)
+            state.subject.next({ newValue, oldValue })
+          })
+        })
+  return dependencySubscriptions
+}

package/src/internal/transaction-internal.ts

@@ -0,0 +1,34 @@
+import type { Store } from "./store"
+
+export const finishTransaction = (store: Store): void => {
+  store.transaction = { open: false }
+  store.config.logger?.info(`🛬`, `transaction done`)
+}
+export const startTransaction = (store: Store): void => {
+  store.transaction = {
+    open: true,
+    prev: {
+      atoms: store.atoms,
+      readonlySelectors: store.readonlySelectors,
+      selectorGraph: store.selectorGraph,
+      selectors: store.selectors,
+      valueMap: store.valueMap,
+    },
+  }
+  store.config.logger?.info(`🛫`, `transaction start`)
+}
+export const abortTransaction = (store: Store): void => {
+  if (!store.transaction.open) {
+    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.config.logger?.info(`🪂`, `transaction fail`)
+}

package/src/react/index.ts

@@ -0,0 +1,65 @@
+import type Preact from "preact/hooks"
+
+import type React from "react"
+
+import type { Modifier } from "~/packages/anvl/src/function"
+
+import type { ReadonlyValueToken, StateToken } from ".."
+import { subscribe, setState, __INTERNAL__ } from ".."
+import { withdraw } from "../internal"
+
+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 = 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
+    }, [current, dispatch])
+
+    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 }
+}