atom.io 0.1.0 → 0.3.0

package/src/internal/operation.ts

@@ -0,0 +1,132 @@
+import type { Hamt } from "hamt_plus"
+import HAMT from "hamt_plus"
+
+import type { Atom, ReadonlySelector, Selector } from "."
+import { target } from "."
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+
+export type OperationProgress =
+  | {
+      open: false
+    }
+  | {
+      open: true
+      done: Set<string>
+      prev: Hamt<any, string>
+    }
+
+export const openOperation = (store: Store): void => {
+  const core = target(store)
+  core.operation = {
+    open: true,
+    done: new Set(),
+    prev: store.valueMap,
+  }
+  store.config.logger?.info(`⭕`, `operation start`)
+}
+export const closeOperation = (store: Store): void => {
+  const core = target(store)
+  core.operation = { open: false }
+  store.config.logger?.info(`🔴`, `operation done`)
+}
+
+export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
+  const core = target(store)
+  if (!core.operation.open) {
+    store.config.logger?.warn(
+      `isDone called outside of an operation. This is probably a bug.`
+    )
+    return true
+  }
+  return core.operation.done.has(key)
+}
+export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
+  const core = target(store)
+  if (!core.operation.open) {
+    store.config.logger?.warn(
+      `markDone called outside of an operation. This is probably a bug.`
+    )
+    return
+  }
+  core.operation.done.add(key)
+}
+export const recallState = <T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+  store: Store = IMPLICIT.STORE
+): T => {
+  const core = target(store)
+  if (!core.operation.open) {
+    store.config.logger?.warn(
+      `recall called outside of an operation. This is probably a bug.`
+    )
+    return HAMT.get(state.key, core.valueMap)
+  }
+  return HAMT.get(state.key, core.operation.prev)
+}
+
+export const cacheValue = (
+  key: string,
+  value: unknown,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.valueMap = HAMT.set(key, value, core.valueMap)
+}
+
+export const evictCachedValue = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.valueMap = HAMT.remove(key, core.valueMap)
+}
+export const readCachedValue = <T>(
+  key: string,
+  store: Store = IMPLICIT.STORE
+): T => HAMT.get(key, target(store).valueMap)
+
+export const isValueCached = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): boolean => HAMT.has(key, target(store).valueMap)
+
+export const storeAtom = (
+  atom: Atom<any>,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.atoms = HAMT.set(atom.key, atom, core.atoms)
+}
+
+export const storeSelector = (
+  selector: Selector<any>,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.selectors = HAMT.set(selector.key, selector, core.selectors)
+}
+
+export const storeReadonlySelector = (
+  selector: ReadonlySelector<any>,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.readonlySelectors = HAMT.set(
+    selector.key,
+    selector,
+    core.readonlySelectors
+  )
+}
+
+export const hasKeyBeenUsed = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): boolean => {
+  const core = target(store)
+  return (
+    HAMT.has(key, core.atoms) ||
+    HAMT.has(key, core.selectors) ||
+    HAMT.has(key, core.readonlySelectors)
+  )
+}

package/src/internal/selector-internal.ts

@@ -0,0 +1,227 @@
+import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
+
+import { become } from "~/packages/anvl/src/function"
+
+import type { Store } from "."
+import {
+  target,
+  cacheValue,
+  markDone,
+  lookup,
+  IMPLICIT,
+  getState__INTERNAL,
+  setState__INTERNAL,
+  withdraw,
+} from "."
+import type {
+  AtomToken,
+  FamilyMetadata,
+  ReadonlySelectorOptions,
+  ReadonlyValueToken,
+  SelectorOptions,
+  SelectorToken,
+  StateToken,
+} from ".."
+import type { Transactors } from "../transaction"
+
+export type Selector<T> = {
+  key: string
+  type: `selector`
+  family?: FamilyMetadata
+  subject: Rx.Subject<{ newValue: T; oldValue: T }>
+  get: () => T
+  set: (newValue: T | ((oldValue: T) => T)) => void
+}
+export type ReadonlySelector<T> = {
+  key: string
+  type: `readonly_selector`
+  family?: FamilyMetadata
+  subject: Rx.Subject<{ newValue: T; oldValue: T }>
+  get: () => T
+}
+
+export const lookupSelectorSources = (
+  key: string,
+  store: Store
+): (
+  | AtomToken<unknown>
+  | ReadonlyValueToken<unknown>
+  | SelectorToken<unknown>
+)[] =>
+  target(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 => {
+  const core = target(store)
+  if (dependency.type === `atom`) {
+    core.selectorAtoms = core.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.map((r) => r.key)
+  )
+  for (const root of roots) {
+    core.selectorAtoms = core.selectorAtoms.set(selectorKey, 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)
+    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(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)
+  },
+})
+
+export function selector__INTERNAL<T>(
+  options: SelectorOptions<T>,
+  family?: FamilyMetadata,
+  store?: Store
+): SelectorToken<T>
+export function selector__INTERNAL<T>(
+  options: ReadonlySelectorOptions<T>,
+  family?: FamilyMetadata,
+  store?: Store
+): ReadonlyValueToken<T>
+export function selector__INTERNAL<T>(
+  options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
+  family?: FamilyMetadata,
+  store: Store = IMPLICIT.STORE
+): ReadonlyValueToken<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)
+    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)
+    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)
+  return { ...mySelector, type: `selector` }
+}

package/src/internal/set.ts

@@ -0,0 +1,102 @@
+import HAMT from "hamt_plus"
+
+import { become } from "~/packages/anvl/src/function"
+
+import type { Atom, Selector, Store } from "."
+import {
+  IMPLICIT,
+  cacheValue,
+  emitUpdate,
+  evictCachedValue,
+  getState__INTERNAL,
+  isAtomDefault,
+  isDone,
+  markAtomAsNotDefault,
+  markDone,
+  stowUpdate,
+  target,
+} from "."
+
+export const evictDownStream = <T>(
+  state: Atom<T>,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  const downstream = core.selectorAtoms.getRelations(state.key)
+  const downstreamKeys = downstream.map(({ id }) => id)
+  store.config.logger?.info(
+    `   || ${downstreamKeys.length} downstream:`,
+    downstreamKeys
+  )
+  if (core.operation.open) {
+    store.config.logger?.info(`   ||`, [...core.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, core.selectors) ??
+      HAMT.get(stateKey, core.readonlySelectors)
+    if (!state) {
+      store.config.logger?.info(
+        `   || ${stateKey} is an atom, and can't be downstream`
+      )
+      return
+    }
+    evictCachedValue(stateKey, store)
+    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)
+  cacheValue(atom.key, newValue, store)
+  if (isAtomDefault(atom.key)) {
+    markAtomAsNotDefault(atom.key, store)
+  }
+  markDone(atom.key, store)
+  store.config.logger?.info(
+    `   || evicting caches downstream from "${atom.key}"`
+  )
+  evictDownStream(atom, store)
+  const update = { oldValue, newValue }
+  if (store.transactionStatus.phase !== `building`) {
+    emitUpdate(atom, update, store)
+  } else {
+    stowUpdate(atom, update, store)
+  }
+}
+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,97 @@
+import type { Hamt } from "hamt_plus"
+import HAMT from "hamt_plus"
+
+import { doNothing } from "~/packages/anvl/src/function"
+import { Join } from "~/packages/anvl/src/join"
+
+import type {
+  Atom,
+  OperationProgress,
+  ReadonlySelector,
+  Selector,
+  TransactionStatus,
+  Logger,
+  Timeline,
+  TimelineData,
+} from "."
+import type { Transaction, ƒn } from ".."
+
+export type StoreCore = Pick<
+  Store,
+  | `atoms`
+  | `atomsThatAreDefault`
+  | `operation`
+  | `readonlySelectors`
+  | `selectorAtoms`
+  | `selectorGraph`
+  | `selectors`
+  | `timelineAtoms`
+  | `timelines`
+  | `transactions`
+  | `valueMap`
+>
+
+export interface Store {
+  atoms: Hamt<Atom<any>, string>
+  atomsThatAreDefault: Set<string>
+  readonlySelectors: Hamt<ReadonlySelector<any>, string>
+  selectorAtoms: Join
+  selectorGraph: Join<{ source: string }>
+  selectors: Hamt<Selector<any>, string>
+  timelines: Hamt<Timeline, string>
+  timelineAtoms: Join
+  timelineStore: Hamt<TimelineData, string>
+  transactions: Hamt<Transaction<any>, string>
+  valueMap: Hamt<any, string>
+
+  operation: OperationProgress
+  transactionStatus: TransactionStatus<ƒn>
+  config: {
+    name: string
+    logger: Logger | null
+    logger__INTERNAL: Logger
+  }
+}
+
+export const createStore = (name: string): Store =>
+  ({
+    atoms: HAMT.make<Atom<any>, string>(),
+    atomsThatAreDefault: new Set(),
+    readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
+    selectorAtoms: new Join({ relationType: `n:n` }),
+    selectorGraph: new Join({ relationType: `n:n` }),
+    selectors: HAMT.make<Selector<any>, string>(),
+    timelines: HAMT.make<Timeline, string>(),
+    timelineAtoms: new Join({ relationType: `1:n` }),
+    timelineStore: HAMT.make<TimelineData, string>(),
+    transactions: HAMT.make<Transaction<any>, string>(),
+    valueMap: HAMT.make<any, string>(),
+
+    operation: {
+      open: false,
+    },
+    transactionStatus: {
+      phase: `idle`,
+    },
+    config: {
+      name,
+      logger: {
+        ...console,
+        info: doNothing,
+      },
+      logger__INTERNAL: console,
+    },
+  } 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 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,77 @@
+import {
+  getState__INTERNAL,
+  withdraw,
+  recallState,
+  traceAllSelectorAtoms,
+} from "."
+import type { Atom, ReadonlySelector, Selector, Store } from "."
+import type { StateUpdate } from ".."
+
+export const prepareUpdate = <T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+  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
+      ? null
+      : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+          const atom = withdraw(atomToken, store)
+          return atom.subject.subscribe((atomChange) => {
+            store.config.logger?.info(
+              `📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
+              atomChange.oldValue,
+              `->`,
+              atomChange.newValue,
+              `)`
+            )
+            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
+}