atom.io 0.3.0 → 0.4.0

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

@@ -0,0 +1,135 @@
+import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "../.."
+import { selector, atom } from "../.."
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+
+export type StateTokenIndex<
+  Token extends
+    | AtomToken<unknown>
+    | ReadonlySelectorToken<unknown>
+    | SelectorToken<unknown>
+> = Record<
+  string,
+  | Token
+  | {
+      key: string
+      familyMembers: Record<string, Token>
+    }
+>
+
+export type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>
+export type SelectorTokenIndex = StateTokenIndex<
+  ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+>
+
+export const attachMetaAtoms = (
+  store: Store = IMPLICIT.STORE
+): ReadonlySelectorToken<AtomTokenIndex> => {
+  const atomTokenIndexState__INTERNAL = atom<AtomTokenIndex>({
+    key: `👁‍🗨_atom_token_index__INTERNAL`,
+    default: () =>
+      [...store.atoms].reduce<AtomTokenIndex>((acc, [key]) => {
+        acc[key] = { key, type: `atom` }
+        return acc
+      }, {}),
+    effects: [
+      ({ setSelf }) => {
+        store.subject.atomCreation.subscribe((atomToken) => {
+          if (store.operation.open) {
+            return
+          }
+          setSelf((state) => {
+            const { key, family } = atomToken
+            if (family) {
+              const { key: familyKey, subKey } = family
+              const current = state[familyKey]
+              if (current === undefined || `familyMembers` in current) {
+                const familyKeyState = current || {
+                  key: familyKey,
+                  familyMembers: {},
+                }
+                return {
+                  ...state,
+                  [familyKey]: {
+                    ...familyKeyState,
+                    familyMembers: {
+                      ...familyKeyState.familyMembers,
+                      [subKey]: atomToken,
+                    },
+                  },
+                }
+              }
+            }
+            return {
+              ...state,
+              [key]: atomToken,
+            }
+          })
+        })
+      },
+    ],
+  })
+  return selector({
+    key: `👁‍🗨_atom_token_index`,
+    get: ({ get }) => get(atomTokenIndexState__INTERNAL),
+  })
+}
+
+export const attachMetaSelectors = (
+  store: Store = IMPLICIT.STORE
+): ReadonlySelectorToken<SelectorTokenIndex> => {
+  const readonlySelectorTokenIndexState__INTERNAL = atom<SelectorTokenIndex>({
+    key: `👁‍🗨_selector_token_index__INTERNAL`,
+    default: () =>
+      Object.assign(
+        [...store.readonlySelectors].reduce<SelectorTokenIndex>((acc, [key]) => {
+          acc[key] = { key, type: `readonly_selector` }
+          return acc
+        }, {}),
+        [...store.selectors].reduce<SelectorTokenIndex>((acc, [key]) => {
+          acc[key] = { key, type: `selector` }
+          return acc
+        }, {})
+      ),
+    effects: [
+      ({ setSelf }) => {
+        store.subject.selectorCreation.subscribe((selectorToken) => {
+          if (store.operation.open) {
+            return
+          }
+          setSelf((state) => {
+            const { key, family } = selectorToken
+            if (family) {
+              const { key: familyKey, subKey } = family
+              const current = state[familyKey]
+              if (current === undefined || `familyMembers` in current) {
+                const familyKeyState = current || {
+                  key: familyKey,
+                  familyMembers: {},
+                }
+                return {
+                  ...state,
+                  [familyKey]: {
+                    ...familyKeyState,
+                    familyMembers: {
+                      ...familyKeyState.familyMembers,
+                      [subKey]: selectorToken,
+                    },
+                  },
+                }
+              }
+            }
+            return {
+              ...state,
+              [key]: selectorToken,
+            }
+          })
+        })
+      },
+    ],
+  })
+  return selector({
+    key: `👁‍🗨_selector_token_index`,
+    get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
+  })
+}

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

@@ -0,0 +1 @@
+export {}

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

@@ -0,0 +1 @@
+export {}

package/src/internal/operation.ts

@@ -5,6 +5,7 @@ import type { Atom, ReadonlySelector, Selector } from "."
 import { target } from "."
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
+import type { StateToken } from ".."
 
 export type OperationProgress =
   | {
@@ -14,21 +15,31 @@ export type OperationProgress =
       open: true
       done: Set<string>
       prev: Hamt<any, string>
+      time: number
+      token: StateToken<any>
     }
 
-export const openOperation = (store: Store): void => {
+export const openOperation = (token: StateToken<any>, store: Store): void => {
   const core = target(store)
+  if (core.operation.open) {
+    store.config.logger?.error(
+      `❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`
+    )
+    throw Symbol(`violation`)
+  }
   core.operation = {
     open: true,
     done: new Set(),
     prev: store.valueMap,
+    time: Date.now(),
+    token,
   }
-  store.config.logger?.info(`⭕`, `operation start`)
+  store.config.logger?.info(`⭕ operation start from "${token.key}"`)
 }
 export const closeOperation = (store: Store): void => {
   const core = target(store)
   core.operation = { open: false }
-  store.config.logger?.info(`🔴`, `operation done`)
+  store.config.logger?.info(`🔴 operation done`)
 }
 
 export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {

package/src/internal/selector-internal.ts

@@ -18,7 +18,7 @@ import type {
   AtomToken,
   FamilyMetadata,
   ReadonlySelectorOptions,
-  ReadonlyValueToken,
+  ReadonlySelectorToken,
   SelectorOptions,
   SelectorToken,
   StateToken,
@@ -46,7 +46,7 @@ export const lookupSelectorSources = (
   store: Store
 ): (
   | AtomToken<unknown>
-  | ReadonlyValueToken<unknown>
+  | ReadonlySelectorToken<unknown>
   | SelectorToken<unknown>
 )[] =>
   target(store)
@@ -56,7 +56,7 @@ export const lookupSelectorSources = (
 
 export const traceSelectorAtoms = (
   selectorKey: string,
-  dependency: ReadonlyValueToken<unknown> | StateToken<unknown>,
+  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
   store: Store
 ): AtomToken<unknown>[] => {
   const roots: AtomToken<unknown>[] = []
@@ -97,12 +97,15 @@ export const traceAllSelectorAtoms = (
 
 export const updateSelectorAtoms = (
   selectorKey: string,
-  dependency: ReadonlyValueToken<unknown> | StateToken<unknown>,
+  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
   store: Store
 ): void => {
   const core = target(store)
   if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set(selectorKey, dependency.key)
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: dependency.key,
+    })
     store.config.logger?.info(
       `   || adding root for "${selectorKey}": ${dependency.key}`
     )
@@ -114,7 +117,10 @@ export const updateSelectorAtoms = (
     roots.map((r) => r.key)
   )
   for (const root of roots) {
-    core.selectorAtoms = core.selectorAtoms.set(selectorKey, root.key)
+    core.selectorAtoms = core.selectorAtoms.set({
+      selectorKey,
+      atomKey: root.key,
+    })
   }
 }
 
@@ -138,12 +144,16 @@ export const registerSelector = (
       )
     } else {
       store.config.logger?.info(
-        `🔌 registerSelector "${selectorKey}" <- "${dependency.key}" =`,
-        dependencyValue
+        `🔌 registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
+        dependencyValue,
+        `)`
+      )
+      core.selectorGraph = core.selectorGraph.set(
+        { from: dependency.key, to: selectorKey },
+        {
+          source: dependency.key,
+        }
       )
-      core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
-        source: dependency.key,
-      })
     }
     updateSelectorAtoms(selectorKey, dependency, store)
     return dependencyValue
@@ -163,12 +173,12 @@ export function selector__INTERNAL<T>(
   options: ReadonlySelectorOptions<T>,
   family?: FamilyMetadata,
   store?: Store
-): ReadonlyValueToken<T>
+): ReadonlySelectorToken<T>
 export function selector__INTERNAL<T>(
   options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
   family?: FamilyMetadata,
   store: Store = IMPLICIT.STORE
-): ReadonlyValueToken<T> | SelectorToken<T> {
+): ReadonlySelectorToken<T> | SelectorToken<T> {
   const core = target(store)
   if (HAMT.has(options.key, core.selectors)) {
     store.config.logger?.error(
@@ -199,7 +209,13 @@ export function selector__INTERNAL<T>(
     )
     const initialValue = getSelf()
     store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-    return { ...readonlySelector, type: `readonly_selector` }
+    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)
@@ -223,5 +239,11 @@ export function selector__INTERNAL<T>(
   core.selectors = HAMT.set(options.key, mySelector, core.selectors)
   const initialValue = getSelf()
   store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  return { ...mySelector, type: `selector` }
+  const token: SelectorToken<T> = {
+    key: options.key,
+    type: `selector`,
+    family,
+  }
+  store.subject.selectorCreation.next(token)
+  return token
 }

package/src/internal/store.ts

@@ -1,5 +1,6 @@
 import type { Hamt } from "hamt_plus"
 import HAMT from "hamt_plus"
+import * as Rx from "rxjs"
 
 import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
@@ -10,11 +11,19 @@ import type {
   ReadonlySelector,
   Selector,
   TransactionStatus,
-  Logger,
   Timeline,
   TimelineData,
 } from "."
-import type { Transaction, ƒn } from ".."
+import type {
+  AtomToken,
+  Logger,
+  ReadonlySelectorToken,
+  SelectorToken,
+  TimelineToken,
+  Transaction,
+  TransactionToken,
+  ƒn,
+} from ".."
 
 export type StoreCore = Pick<
   Store,
@@ -35,15 +44,24 @@ export interface Store {
   atoms: Hamt<Atom<any>, string>
   atomsThatAreDefault: Set<string>
   readonlySelectors: Hamt<ReadonlySelector<any>, string>
-  selectorAtoms: Join
+  selectorAtoms: Join<null, `selectorKey`, `atomKey`>
   selectorGraph: Join<{ source: string }>
   selectors: Hamt<Selector<any>, string>
   timelines: Hamt<Timeline, string>
-  timelineAtoms: Join
+  timelineAtoms: Join<null, `timelineKey`, `atomKey`>
   timelineStore: Hamt<TimelineData, string>
   transactions: Hamt<Transaction<any>, string>
   valueMap: Hamt<any, string>
 
+  subject: {
+    atomCreation: Rx.Subject<AtomToken<unknown>>
+    selectorCreation: Rx.Subject<
+      ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+    >
+    transactionCreation: Rx.Subject<TransactionToken<unknown>>
+    timelineCreation: Rx.Subject<TimelineToken>
+  }
+
   operation: OperationProgress
   transactionStatus: TransactionStatus<ƒn>
   config: {
@@ -58,15 +76,26 @@ 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` }),
+    selectorAtoms: new Join({ relationType: `n:n` })
+      .from(`selectorKey`)
+      .to(`atomKey`),
     selectorGraph: new Join({ relationType: `n:n` }),
     selectors: HAMT.make<Selector<any>, string>(),
     timelines: HAMT.make<Timeline, string>(),
-    timelineAtoms: new Join({ relationType: `1:n` }),
+    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(),
+    },
+
     operation: {
       open: false,
     },

package/src/internal/time-travel-internal.ts

@@ -0,0 +1,89 @@
+import type { Store } from "."
+import { IMPLICIT } from "."
+import { setState } from ".."
+import type { TimelineToken } from ".."
+
+export const redo__INTERNAL = (
+  token: TimelineToken,
+  store: Store = IMPLICIT.STORE
+): void => {
+  store.config.logger?.info(`⏩ redo "${token.key}"`)
+  const timelineData = store.timelineStore.get(token.key)
+  if (!timelineData) {
+    store.config.logger?.error(
+      `Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
+    )
+    return
+  }
+  if (timelineData.at === timelineData.history.length) {
+    store.config.logger?.warn(
+      `Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`
+    )
+    return
+  }
+  timelineData.timeTraveling = true
+  const update = timelineData.history[timelineData.at]
+  switch (update.type) {
+    case `atom_update`: {
+      const { key, newValue } = update
+      setState({ key, type: `atom` }, newValue)
+      break
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, newValue } = atomUpdate
+        setState({ key, type: `atom` }, newValue)
+      }
+      break
+    }
+  }
+  ++timelineData.at
+  timelineData.timeTraveling = false
+  store.config.logger?.info(
+    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  )
+}
+
+export const undo__INTERNAL = (
+  token: TimelineToken,
+  store: Store = IMPLICIT.STORE
+): void => {
+  store.config.logger?.info(`⏪ undo "${token.key}"`)
+  const timelineData = store.timelineStore.get(token.key)
+  if (!timelineData) {
+    store.config.logger?.error(
+      `Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
+    )
+    return
+  }
+  if (timelineData.at === 0) {
+    store.config.logger?.warn(
+      `Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`
+    )
+    return
+  }
+  timelineData.timeTraveling = true
+
+  --timelineData.at
+  const update = timelineData.history[timelineData.at]
+  switch (update.type) {
+    case `atom_update`: {
+      const { key, oldValue } = update
+      setState({ key, type: `atom` }, oldValue)
+      break
+    }
+    case `selector_update`:
+    case `transaction_update`: {
+      for (const atomUpdate of update.atomUpdates) {
+        const { key, oldValue } = atomUpdate
+        setState({ key, type: `atom` }, oldValue)
+      }
+      break
+    }
+  }
+  timelineData.timeTraveling = false
+  store.config.logger?.info(
+    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  )
+}