atom.io 0.2.0 → 0.3.0

package/src/internal/index.ts

@@ -1,23 +1,12 @@
-import type * as Rx from "rxjs"
-
+export * from "./atom-internal"
+export * from "./families-internal"
 export * from "./get"
-export * from "./set"
 export * from "./is-default"
+export * from "./logger"
+export * from "./operation"
 export * from "./selector-internal"
+export * from "./set"
 export * from "./store"
 export * from "./subscribe-internal"
-export * from "./operation"
+export * from "./timeline-internal"
 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

@@ -1,13 +1,29 @@
-import HAMT from "hamt_plus"
-
 import type { Store } from "."
-import { IMPLICIT, traceAllSelectorAtoms } from "."
+import { target, IMPLICIT, traceAllSelectorAtoms } from "."
 
 export const isAtomDefault = (
   key: string,
   store: Store = IMPLICIT.STORE
 ): boolean => {
-  return HAMT.get(key, store.atomsAreDefault)
+  const core = target(store)
+  return core.atomsThatAreDefault.has(key)
+}
+
+export const markAtomAsDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key)
+}
+
+export const markAtomAsNotDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.atomsThatAreDefault = new Set(target(store).atomsThatAreDefault)
+  core.atomsThatAreDefault.delete(key)
 }
 
 export const isSelectorDefault = (

package/src/internal/logger.ts

@@ -0,0 +1,46 @@
+import { doNothing } from "~/packages/anvl/src/function"
+
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+
+export type Logger = Pick<Console, `error` | `info` | `warn`>
+export const LOG_LEVELS: ReadonlyArray<keyof Logger> = [
+  `info`,
+  `warn`,
+  `error`,
+] as const
+
+export const setLogLevel = (
+  preferredLevel: `error` | `info` | `warn` | null,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const { logger__INTERNAL } = store.config
+  if (preferredLevel === null) {
+    store.config.logger = null
+  } else {
+    store.config.logger = { ...console }
+    LOG_LEVELS.forEach((logLevel) => {
+      if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+        store.config.logger![logLevel] = doNothing
+      } else {
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+        store.config.logger![logLevel] = logger__INTERNAL[logLevel]
+      }
+    })
+  }
+}
+
+export const useLogger = (
+  logger: Logger,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const currentLogLevel =
+    store.config.logger === null
+      ? null
+      : LOG_LEVELS.find(
+          (logLevel) => store.config.logger?.[logLevel] !== doNothing
+        ) ?? null
+  store.config.logger__INTERNAL = { ...logger }
+  setLogLevel(currentLogLevel, store)
+}

package/src/internal/operation.ts

@@ -1,49 +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 const startAction = (store: Store): void => {
-  store.operation = {
+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 finishAction = (store: Store): void => {
-  store.operation = { open: false }
+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 => {
-  if (!store.operation.open) {
+  const core = target(store)
+  if (!core.operation.open) {
     store.config.logger?.warn(
-      `isDone called outside of an action. This is probably a bug.`
+      `isDone called outside of an operation. This is probably a bug.`
     )
     return true
   }
-  return store.operation.done.has(key)
+  return core.operation.done.has(key)
 }
 export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
-  if (!store.operation.open) {
+  const core = target(store)
+  if (!core.operation.open) {
     store.config.logger?.warn(
-      `markDone called outside of an action. This is probably a bug.`
+      `markDone called outside of an operation. This is probably a bug.`
     )
     return
   }
-  store.operation.done.add(key)
+  core.operation.done.add(key)
 }
 export const recallState = <T>(
   state: Atom<T> | ReadonlySelector<T> | Selector<T>,
   store: Store = IMPLICIT.STORE
 ): T => {
-  if (!store.operation.open) {
+  const core = target(store)
+  if (!core.operation.open) {
     store.config.logger?.warn(
-      `recall called outside of an action. This is probably a bug.`
+      `recall called outside of an operation. This is probably a bug.`
     )
-    return HAMT.get(state.key, store.valueMap)
+    return HAMT.get(state.key, core.valueMap)
   }
-  return HAMT.get(state.key, store.operation.prev)
+  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

@@ -1,5 +1,13 @@
+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,
@@ -8,12 +16,31 @@ import {
 } 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
@@ -22,8 +49,8 @@ export const lookupSelectorSources = (
   | ReadonlyValueToken<unknown>
   | SelectorToken<unknown>
 )[] =>
-  store.selectorGraph
-    .getRelations(key)
+  target(store)
+    .selectorGraph.getRelations(key)
     .filter(({ source }) => source !== key)
     .map(({ source }) => lookup(source, store))
 
@@ -73,17 +100,21 @@ export const updateSelectorAtoms = (
   dependency: ReadonlyValueToken<unknown> | StateToken<unknown>,
   store: Store
 ): void => {
+  const core = target(store)
   if (dependency.type === `atom`) {
-    store.selectorAtoms = store.selectorAtoms.set(selectorKey, dependency.key)
+    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)
+  store.config.logger?.info(
+    `   || adding roots for "${selectorKey}":`,
+    roots.map((r) => r.key)
+  )
   for (const root of roots) {
-    store.selectorAtoms = store.selectorAtoms.set(selectorKey, root.key)
+    core.selectorAtoms = core.selectorAtoms.set(selectorKey, root.key)
   }
 }
 
@@ -92,7 +123,8 @@ export const registerSelector = (
   store: Store = IMPLICIT.STORE
 ): Transactors => ({
   get: (dependency) => {
-    const alreadyRegistered = store.selectorGraph
+    const core = target(store)
+    const alreadyRegistered = core.selectorGraph
       .getRelations(selectorKey)
       .some(({ source }) => source === dependency.key)
 
@@ -109,13 +141,9 @@ export const registerSelector = (
         `🔌 registerSelector "${selectorKey}" <- "${dependency.key}" =`,
         dependencyValue
       )
-      store.selectorGraph = store.selectorGraph.set(
-        selectorKey,
-        dependency.key,
-        {
-          source: dependency.key,
-        }
-      )
+      core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
+        source: dependency.key,
+      })
     }
     updateSelectorAtoms(selectorKey, dependency, store)
     return dependencyValue
@@ -125,3 +153,75 @@ export const registerSelector = (
     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

@@ -2,25 +2,34 @@ 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"
+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 downstream = store.selectorAtoms.getRelations(state.key)
+  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 (store.operation.open) {
-    store.config.logger?.info(`   ||`, [...store.operation.done], `already done`)
+  if (core.operation.open) {
+    store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
   }
   downstream.forEach(({ id: stateKey }) => {
     if (isDone(stateKey, store)) {
@@ -28,15 +37,15 @@ export const evictDownStream = <T>(
       return
     }
     const state =
-      HAMT.get(stateKey, store.selectors) ??
-      HAMT.get(stateKey, store.readonlySelectors)
+      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
     }
-    store.valueMap = HAMT.remove(stateKey, store.valueMap)
+    evictCachedValue(stateKey, store)
     store.config.logger?.info(`   xx evicted "${stateKey}"`)
 
     markDone(stateKey, store)
@@ -50,17 +59,22 @@ export const setAtomState = <T>(
 ): 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)
+  store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
+  cacheValue(atom.key, newValue, store)
   if (isAtomDefault(atom.key)) {
-    store.atomsAreDefault = HAMT.set(atom.key, false, store.atomsAreDefault)
+    markAtomAsNotDefault(atom.key, store)
   }
   markDone(atom.key, store)
   store.config.logger?.info(
     `   || evicting caches downstream from "${atom.key}"`
   )
   evictDownStream(atom, store)
-  atom.subject.next({ newValue, oldValue })
+  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>,
@@ -70,7 +84,7 @@ export const setSelectorState = <T>(
   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(`<< setting selector "${selector.key}" to`, newValue)
   store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
 
   selector.set(newValue)

package/src/internal/store.ts

@@ -1,66 +1,85 @@
 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, ReadonlySelector, Selector } from "."
+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 {
-  valueMap: Hamt<any, string>
-  selectorGraph: Join<{ source: string }>
-  selectorAtoms: Join
   atoms: Hamt<Atom<any>, string>
-  atomsAreDefault: Hamt<boolean, string>
-  selectors: Hamt<Selector<any>, string>
+  atomsThatAreDefault: Set<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`
-        >
-      }
+  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: Pick<Console, `error` | `info` | `warn`> | null
+    logger: Logger | null
+    logger__INTERNAL: Logger
   }
 }
 
 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>(),
+    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,
     },
-    transaction: {
-      open: false,
+    transactionStatus: {
+      phase: `idle`,
     },
     config: {
       name,
-      logger: null,
+      logger: {
+        ...console,
+        info: doNothing,
+      },
+      logger__INTERNAL: console,
     },
   } satisfies Store)
 
@@ -70,12 +89,6 @@ export const IMPLICIT = {
     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