atom.io 0.4.1 → 0.6.0

package/src/internal/index.ts

@@ -5,9 +5,11 @@ export * from "./is-default"
 export * as META from "./meta"
 export * from "./operation"
 export * from "./selector-internal"
+export * from "./selector"
 export * from "./set"
 export * from "./store"
 export * from "./subscribe-internal"
 export * from "./time-travel-internal"
 export * from "./timeline-internal"
 export * from "./transaction-internal"
+export * from "./transaction"

package/src/internal/meta/meta-state.ts

@@ -7,7 +7,7 @@ export type StateTokenIndex<
   Token extends
     | AtomToken<unknown>
     | ReadonlySelectorToken<unknown>
-    | SelectorToken<unknown>
+    | SelectorToken<unknown>,
 > = Record<
   string,
   | Token

package/src/internal/operation.ts

@@ -34,7 +34,9 @@ export const openOperation = (token: StateToken<any>, store: Store): void => {
     time: Date.now(),
     token,
   }
-  store.config.logger?.info(`⭕ operation start from "${token.key}"`)
+  store.config.logger?.info(
+    `⭕ operation start from "${token.key}" in store "${store.config.name}"`
+  )
 }
 export const closeOperation = (store: Store): void => {
   const core = target(store)

package/src/internal/selector/create-read-write-selector.ts

@@ -0,0 +1,62 @@
+import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
+
+import { become } from "~/packages/anvl/src/function"
+
+import {
+  type Store,
+  type Selector,
+  type StoreCore,
+  registerSelector,
+  selector__INTERNAL,
+} from ".."
+import type { FamilyMetadata, SelectorToken } from "../.."
+import type { SelectorOptions } from "../../selector"
+import { cacheValue, markDone } from "../operation"
+
+export const createReadWriteSelector = <T>(
+  options: SelectorOptions<T>,
+  family: FamilyMetadata | undefined,
+  store: Store,
+  core: StoreCore
+): SelectorToken<T> => {
+  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
+  }
+
+  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,
+    install: (s: Store) => selector__INTERNAL(options, family, s),
+    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)
+  const token: SelectorToken<T> = {
+    key: options.key,
+    type: `selector`,
+    family,
+  }
+  store.subject.selectorCreation.next(token)
+  return token
+}

package/src/internal/selector/create-readonly-selector.ts

@@ -0,0 +1,52 @@
+import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
+
+import { registerSelector } from "./register-selector"
+import type {
+  FamilyMetadata,
+  ReadonlySelectorOptions,
+  ReadonlySelectorToken,
+  Store,
+} from "../.."
+import { cacheValue } from "../operation"
+import { selector__INTERNAL, type ReadonlySelector } from "../selector-internal"
+import type { StoreCore } from "../store"
+
+export const createReadonlySelector = <T>(
+  options: ReadonlySelectorOptions<T>,
+  family: FamilyMetadata | undefined,
+  store: Store,
+  core: StoreCore
+): ReadonlySelectorToken<T> => {
+  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
+
+  const { get } = registerSelector(options.key, store)
+  const getSelf = () => {
+    const value = options.get({ get })
+    cacheValue(options.key, value, store)
+    return value
+  }
+
+  const readonlySelector: ReadonlySelector<T> = {
+    ...options,
+    subject,
+    install: (s: Store) => selector__INTERNAL(options, family, s),
+    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)
+  const token: ReadonlySelectorToken<T> = {
+    key: options.key,
+    type: `readonly_selector`,
+    family,
+  }
+  store.subject.selectorCreation.next(token)
+  return token
+}

package/src/internal/selector/index.ts

@@ -0,0 +1,4 @@
+export * from "./lookup-selector-sources"
+export * from "./register-selector"
+export * from "./trace-selector-atoms"
+export * from "./update-selector-atoms"

package/src/internal/selector/lookup-selector-sources.ts

@@ -0,0 +1,16 @@
+import type { Store } from ".."
+import { target, lookup } from ".."
+import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "../.."
+
+export const lookupSelectorSources = (
+  key: string,
+  store: Store
+): (
+  | AtomToken<unknown>
+  | ReadonlySelectorToken<unknown>
+  | SelectorToken<unknown>
+)[] =>
+  target(store)
+    .selectorGraph.getRelations(key)
+    .filter(({ source }) => source !== key)
+    .map(({ source }) => lookup(source, store))

package/src/internal/selector/register-selector.ts

@@ -0,0 +1,57 @@
+import { updateSelectorAtoms } from "./update-selector-atoms"
+import type { Transactors } from "../../transaction"
+import { getState__INTERNAL, withdraw } from "../get"
+import { setState__INTERNAL } from "../set"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { target } from "../transaction-internal"
+
+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)
+    if (dependencyState === null) {
+      throw new Error(
+        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      )
+    }
+    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(
+        { from: dependency.key, to: selectorKey },
+        {
+          source: dependency.key,
+        }
+      )
+    }
+    updateSelectorAtoms(selectorKey, dependency, store)
+    return dependencyValue
+  },
+  set: (stateToken, newValue) => {
+    const state = withdraw(stateToken, store)
+    if (state === null) {
+      throw new Error(
+        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+      )
+    }
+    setState__INTERNAL(state, newValue, store)
+  },
+})

package/src/internal/selector/trace-selector-atoms.ts

@@ -0,0 +1,43 @@
+import { lookupSelectorSources } from "./lookup-selector-sources"
+import type { Store, AtomToken, ReadonlySelectorToken, StateToken } from "../.."
+
+export const traceSelectorAtoms = (
+  selectorKey: string,
+  dependency: ReadonlySelectorToken<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)
+  )
+}

package/src/internal/selector/update-selector-atoms.ts

@@ -0,0 +1,33 @@
+import { traceSelectorAtoms } from "./trace-selector-atoms"
+import type { Store } from ".."
+import { target } from ".."
+import type { ReadonlySelectorToken, StateToken } from "../.."
+
+export const updateSelectorAtoms = (
+  selectorKey: string,
+  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+  store: Store
+): void => {
+  const core = target(store)
+  if (dependency.type === `atom`) {
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: 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,
+      atomKey: root.key,
+    })
+  }
+}

package/src/internal/selector-internal.ts

@@ -1,34 +1,23 @@
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
-
-import { become } from "~/packages/anvl/src/function"
+import type * as Rx from "rxjs"
 
 import type { Store } from "."
-import {
-  target,
-  cacheValue,
-  markDone,
-  lookup,
-  IMPLICIT,
-  getState__INTERNAL,
-  setState__INTERNAL,
-  withdraw,
-} from "."
+import { target, IMPLICIT } from "."
+import { createReadWriteSelector } from "./selector/create-read-write-selector"
+import { createReadonlySelector } from "./selector/create-readonly-selector"
 import type {
-  AtomToken,
   FamilyMetadata,
   ReadonlySelectorOptions,
   ReadonlySelectorToken,
   SelectorOptions,
   SelectorToken,
-  StateToken,
 } from ".."
-import type { Transactors } from "../transaction"
 
 export type Selector<T> = {
   key: string
   type: `selector`
   family?: FamilyMetadata
+  install: (store: Store) => void
   subject: Rx.Subject<{ newValue: T; oldValue: T }>
   get: () => T
   set: (newValue: T | ((oldValue: T) => T)) => void
@@ -37,133 +26,11 @@ export type ReadonlySelector<T> = {
   key: string
   type: `readonly_selector`
   family?: FamilyMetadata
+  install: (store: Store) => void
   subject: Rx.Subject<{ newValue: T; oldValue: T }>
   get: () => T
 }
 
-export const lookupSelectorSources = (
-  key: string,
-  store: Store
-): (
-  | AtomToken<unknown>
-  | ReadonlySelectorToken<unknown>
-  | SelectorToken<unknown>
-)[] =>
-  target(store)
-    .selectorGraph.getRelations(key)
-    .filter(({ source }) => source !== key)
-    .map(({ source }) => lookup(source, store))
-
-export const traceSelectorAtoms = (
-  selectorKey: string,
-  dependency: ReadonlySelectorToken<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: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store
-): void => {
-  const core = target(store)
-  if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: 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,
-      atomKey: 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(
-        { from: dependency.key, to: selectorKey },
-        {
-          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,
@@ -180,70 +47,15 @@ export function selector__INTERNAL<T>(
   store: Store = IMPLICIT.STORE
 ): ReadonlySelectorToken<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)
-    const token: ReadonlySelectorToken<T> = {
-      key: options.key,
-      type: `readonly_selector`,
-      family,
-    }
-    store.subject.selectorCreation.next(token)
-    return token
-  }
-  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)
-  const token: SelectorToken<T> = {
-    key: options.key,
-    type: `selector`,
-    family,
+    return createReadonlySelector(options, family, store, core)
   }
-  store.subject.selectorCreation.next(token)
-  return token
+  return createReadWriteSelector(options, family, store, core)
 }

package/src/internal/set.ts

@@ -61,7 +61,7 @@ export const setAtomState = <T>(
   const newValue = become(next)(oldValue)
   store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
   cacheValue(atom.key, newValue, store)
-  if (isAtomDefault(atom.key)) {
+  if (isAtomDefault(atom.key, store)) {
     markAtomAsNotDefault(atom.key, store)
   }
   markDone(atom.key, store)

package/src/internal/store.ts

@@ -2,6 +2,7 @@ import type { Hamt } from "hamt_plus"
 import HAMT from "hamt_plus"
 import * as Rx from "rxjs"
 
+import type { ƒn } from "~/packages/anvl/src/function"
 import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
 
@@ -12,7 +13,7 @@ import type {
   Selector,
   TransactionStatus,
   Timeline,
-  TimelineData,
+  Transaction,
 } from "."
 import type {
   AtomToken,
@@ -20,9 +21,7 @@ import type {
   ReadonlySelectorToken,
   SelectorToken,
   TimelineToken,
-  Transaction,
   TransactionToken,
-  ƒn,
 } from ".."
 
 export type StoreCore = Pick<
@@ -47,9 +46,8 @@ export interface Store {
   selectorAtoms: Join<null, `selectorKey`, `atomKey`>
   selectorGraph: Join<{ source: string }>
   selectors: Hamt<Selector<any>, string>
-  timelines: Hamt<Timeline, string>
   timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-  timelineStore: Hamt<TimelineData, string>
+  timelines: Hamt<Timeline, string>
   transactions: Hamt<Transaction<any>, string>
   valueMap: Hamt<any, string>
 
@@ -71,46 +69,75 @@ export interface Store {
   }
 }
 
-export const createStore = (name: string): Store =>
-  ({
+export const createStore = (name: string, store: Store | null = null): Store => {
+  const copiedStore = {
+    ...(store ??
+      (() => ({
+        atomsThatAreDefault: new Set(),
+        selectorAtoms: new Join({ relationType: `n:n` })
+          .from(`selectorKey`)
+          .to(`atomKey`),
+        selectorGraph: new Join({ relationType: `n:n` }),
+        valueMap: HAMT.make<any, string>(),
+      }))()),
+
     atoms: HAMT.make<Atom<any>, string>(),
-    atomsThatAreDefault: new Set(),
     readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-    selectorAtoms: new Join({ relationType: `n:n` })
-      .from(`selectorKey`)
-      .to(`atomKey`),
-    selectorGraph: new Join({ relationType: `n:n` }),
     selectors: HAMT.make<Selector<any>, string>(),
+    transactions: HAMT.make<Transaction<any>, string>(),
     timelines: HAMT.make<Timeline, string>(),
+
     timelineAtoms: new Join({ relationType: `1:n` })
       .from(`timelineKey`)
       .to(`atomKey`),
-    timelineStore: HAMT.make<TimelineData, string>(),
-    transactions: HAMT.make<Transaction<any>, string>(),
-    valueMap: HAMT.make<any, string>(),
 
     subject: {
       atomCreation: new Rx.Subject(),
       selectorCreation: new Rx.Subject(),
       transactionCreation: new Rx.Subject(),
       timelineCreation: new Rx.Subject(),
+      ...store?.subject,
     },
 
     operation: {
       open: false,
+      ...store?.operation,
     },
     transactionStatus: {
       phase: `idle`,
+      ...store?.transactionStatus,
     },
     config: {
-      name,
       logger: {
         ...console,
         info: doNothing,
+        ...store?.config?.logger,
       },
       logger__INTERNAL: console,
+      ...store?.config,
+      name,
     },
-  } satisfies Store)
+  } satisfies Store
+
+  store?.atoms.forEach((atom) => {
+    const copiedAtom = { ...atom, subject: new Rx.Subject() } satisfies Atom<any>
+    copiedStore.atoms = HAMT.set(atom.key, copiedAtom, copiedStore.atoms)
+  })
+  store?.readonlySelectors.forEach((selector) => {
+    selector.install(copiedStore)
+  })
+  store?.selectors.forEach((selector) => {
+    selector.install(copiedStore)
+  })
+  store?.transactions.forEach((tx) => {
+    tx.install(copiedStore)
+  })
+  store?.timelines.forEach((timeline) => {
+    timeline.install(copiedStore)
+  })
+
+  return copiedStore
+}
 
 export const IMPLICIT = {
   STORE_INTERNAL: undefined as Store | undefined,