atom.io 0.0.0 → 0.2.0

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 }
+}

package/src/selector.ts

@@ -0,0 +1,132 @@
+import HAMT from "hamt_plus"
+import * 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 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>,
+  store?: Store
+): SelectorToken<T>
+export function selector<T>(
+  options: ReadonlySelectorOptions<T>,
+  store?: Store
+): ReadonlyValueToken<T>
+export function selector<T>(
+  options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
+  store: Store = IMPLICIT.STORE
+): 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` }
+}
+
+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 function selectorFamily<T, K extends Serializable>(
+  options: SelectorFamilyOptions<T, K>,
+  store?: Store
+): (key: K) => SelectorToken<T>
+export function selectorFamily<T, K extends Serializable>(
+  options: ReadonlySelectorFamilyOptions<T, K>,
+  store?: Store
+): (key: K) => ReadonlyValueToken<T>
+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
+    )
+  }
+}

package/src/transaction.ts

@@ -0,0 +1,53 @@
+import type { ReadonlyValueToken, StateToken } from "."
+import { getState, setState } from "."
+import type { Store } from "./internal"
+import { IMPLICIT } from "./internal"
+import {
+  abortTransaction,
+  finishTransaction,
+  startTransaction,
+} from "./internal/transaction-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 const transaction = <ƒ extends ƒn>(
+  options: TransactionOptions<ƒ>,
+  store: Store = IMPLICIT.STORE
+): ((...parameters: Parameters<ƒ>) => ReturnType<ƒ>) & { key: string } =>
+  Object.assign(
+    (...parameters: Parameters<ƒ>) => {
+      startTransaction(store)
+      try {
+        const result = options.do(
+          {
+            get: (token) => getState(token, store),
+            set: (token, value) => setState(token, value, store),
+          },
+          ...parameters
+        )
+        finishTransaction(store)
+        return result
+      } catch (thrown) {
+        abortTransaction(store)
+        store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
+        throw thrown
+      }
+    },
+    { key: options.key }
+  )