atom.io 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Reactive state graph for React, Preact, and vanilla",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,7 +48,7 @@
   "dependencies": {
     "fp-ts": "2.14.0",
     "hamt_plus": "1.0.2",
-    "rxjs": "7.8.0"
+    "rxjs": "7.8.1"
   },
   "devDependencies": {
     "@testing-library/preact": "3.2.3",

package/src/index.ts

@@ -7,18 +7,17 @@ import {
   isAtomDefault,
   isSelectorDefault,
   withdraw,
-  setLogLevel,
-  useLogger,
 } from "./internal"
 import * as __INTERNAL__ from "./internal"
 import type { Store } from "./internal/store"
 
 export * from "./atom"
+export * from "./logger"
 export * from "./selector"
+export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
-export * from "./subscribe"
-export { __INTERNAL__, setLogLevel, useLogger }
+export { __INTERNAL__ }
 export type { Serializable } from "~/packages/anvl/src/json"
 
 export type AtomToken<_> = {
@@ -62,7 +61,14 @@ export const setState = <T, New extends T>(
   value: New | ((oldValue: T) => New),
   store: Store = IMPLICIT.STORE
 ): void => {
-  openOperation(store)
+  try {
+    openOperation(token, store)
+  } catch (thrown) {
+    if (!(typeof thrown === `symbol`)) {
+      throw thrown
+    }
+    return
+  }
   const state = withdraw(token, store)
   setState__INTERNAL(state, value, store)
   closeOperation(store)

package/src/internal/families-internal.ts

@@ -34,7 +34,7 @@ export function atomFamily__INTERNAL<T, K extends Serializable>(
     (key: K): AtomToken<T> => {
       const subKey = stringifyJson(key)
       const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}__${subKey}`
+      const fullKey = `${options.key}(${subKey})`
       const existing = withdraw({ key: fullKey, type: `atom` }, store)
       const token = existing
         ? deposit(existing)
@@ -71,7 +71,7 @@ export function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(
     (key: K): ReadonlyValueToken<T> => {
       const subKey = stringifyJson(key)
       const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}__${subKey}`
+      const fullKey = `${options.key}(${subKey})`
       const existing = core.readonlySelectors.get(fullKey)
       if (existing) {
         return deposit(existing)
@@ -117,7 +117,7 @@ export function selectorFamily__INTERNAL<T, K extends Serializable>(
     (key: K): SelectorToken<T> => {
       const subKey = stringifyJson(key)
       const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}__${subKey}`
+      const fullKey = `${options.key}(${subKey})`
       const existing = core.selectors.get(fullKey)
       if (existing) {
         return deposit(existing)

package/src/internal/get.ts

@@ -96,7 +96,7 @@ export const getState__INTERNAL = <T>(
     store.config.logger?.info(`>> read "${state.key}"`)
     return readCachedValue(state.key, store)
   }
-  if (`get` in state) {
+  if (state.type !== `atom`) {
     store.config.logger?.info(`-> calc "${state.key}"`)
     return computeSelectorState(state)
   }

package/src/internal/index.ts

@@ -2,7 +2,6 @@ export * from "./atom-internal"
 export * from "./families-internal"
 export * from "./get"
 export * from "./is-default"
-export * from "./logger"
 export * from "./operation"
 export * from "./selector-internal"
 export * from "./set"

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,32 @@ 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) {
+    console.warn(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

@@ -138,8 +138,9 @@ export const registerSelector = (
       )
     } else {
       store.config.logger?.info(
-        `🔌 registerSelector "${selectorKey}" <- "${dependency.key}" =`,
-        dependencyValue
+        `🔌 registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
+        dependencyValue,
+        `)`
       )
       core.selectorGraph = core.selectorGraph.set(selectorKey, dependency.key, {
         source: dependency.key,

package/src/internal/store.ts

@@ -10,11 +10,10 @@ import type {
   ReadonlySelector,
   Selector,
   TransactionStatus,
-  Logger,
   Timeline,
   TimelineData,
 } from "."
-import type { Transaction, ƒn } from ".."
+import type { Logger, Transaction, ƒn } from ".."
 
 export type StoreCore = Pick<
   Store,

package/src/internal/timeline-internal.ts

@@ -1,7 +1,9 @@
+/* eslint-disable max-lines */
+
 import HAMT from "hamt_plus"
 
 import type { KeyedStateUpdate, TransactionUpdate, Store } from "."
-import { IMPLICIT, withdraw } from "."
+import { target, IMPLICIT, withdraw } from "."
 import { setState } from ".."
 import type { AtomToken, TimelineOptions, TimelineToken, ƒn } from ".."
 
@@ -12,8 +14,13 @@ export type Timeline = {
   prev: () => void
 }
 
-export type TimelineStateUpdate = KeyedStateUpdate<unknown> & {
-  type: `state_update`
+export type TimelineAtomUpdate = KeyedStateUpdate<unknown> & {
+  type: `atom_update`
+}
+export type TimelineSelectorUpdate = {
+  key: string
+  type: `selector_update`
+  atomUpdates: TimelineAtomUpdate[]
 }
 export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
   type: `transaction_update`
@@ -22,13 +29,19 @@ export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 export type TimelineData = {
   at: number
   timeTraveling: boolean
-  history: (TimelineStateUpdate | TimelineTransactionUpdate)[]
+  history: (
+    | TimelineAtomUpdate
+    | TimelineSelectorUpdate
+    | TimelineTransactionUpdate
+  )[]
 }
 
 export function timeline__INTERNAL(
   options: TimelineOptions,
   store: Store = IMPLICIT.STORE
 ): TimelineToken {
+  let incompleteSelectorTime: number | null = null
+  // let selectorAtomUpdates: TimelineAtomUpdate[] = []
   let incompleteTransactionKey: string | null = null
   const timelineData: TimelineData = {
     at: 0,
@@ -39,6 +52,15 @@ export function timeline__INTERNAL(
   const subscribeToAtom = (token: AtomToken<any>) => {
     const state = withdraw(token, store)
     state.subject.subscribe((update) => {
+      const storeCurrentSelectorKey =
+        store.operation.open && store.operation.token.type === `selector`
+          ? store.operation.token.key
+          : null
+      const storeCurrentSelectorTime =
+        store.operation.open && store.operation.token.type === `selector`
+          ? store.operation.time
+          : null
+
       const storeCurrentTransactionKey =
         store.transactionStatus.phase === `applying`
           ? store.transactionStatus.key
@@ -70,6 +92,9 @@ export function timeline__INTERNAL(
           incompleteTransactionKey = storeCurrentTransactionKey
           const subscription = currentTransaction.subject.subscribe((update) => {
             if (timelineData.timeTraveling === false) {
+              if (timelineData.at !== timelineData.history.length) {
+                timelineData.history.splice(timelineData.at)
+              }
               timelineData.history.push({
                 type: `transaction_update`,
                 ...update,
@@ -82,39 +107,100 @@ export function timeline__INTERNAL(
             subscription.unsubscribe()
             incompleteTransactionKey = null
             store.config.logger?.info(
-              `⌛ timeline "${options.key}" pushed a transaction_update from "${update.key}"`
+              `⌛ timeline "${options.key}" got a transaction_update "${update.key}"`
             )
           })
         }
+      } else if (storeCurrentSelectorKey) {
+        if (timelineData.timeTraveling === false) {
+          if (storeCurrentSelectorTime !== incompleteSelectorTime) {
+            const newSelectorUpdate: TimelineSelectorUpdate = {
+              type: `selector_update`,
+              key: storeCurrentSelectorKey,
+              atomUpdates: [],
+            }
+            newSelectorUpdate.atomUpdates.push({
+              key: token.key,
+              type: `atom_update`,
+              ...update,
+            })
+            if (timelineData.at !== timelineData.history.length) {
+              timelineData.history.splice(timelineData.at)
+            }
+            timelineData.history.push(newSelectorUpdate)
+
+            store.config.logger?.info(
+              `⌛ timeline "${options.key}" got a selector_update "${storeCurrentSelectorKey}" with`,
+              newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key)
+            )
+            timelineData.at = timelineData.history.length
+            incompleteSelectorTime = storeCurrentSelectorTime
+          } else {
+            const latestUpdate = timelineData.history.at(-1)
+            if (latestUpdate?.type === `selector_update`) {
+              latestUpdate.atomUpdates.push({
+                key: token.key,
+                type: `atom_update`,
+                ...update,
+              })
+              store.config.logger?.info(
+                `   ⌛ timeline "${options.key}" set selector_update "${storeCurrentSelectorKey}" to`,
+                latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key)
+              )
+            }
+          }
+        }
       } else {
         if (timelineData.timeTraveling === false) {
+          incompleteSelectorTime = null
+          if (timelineData.at !== timelineData.history.length) {
+            timelineData.history.splice(timelineData.at)
+          }
           timelineData.history.push({
-            type: `state_update`,
+            type: `atom_update`,
             key: token.key,
             oldValue: update.oldValue,
             newValue: update.newValue,
           })
           store.config.logger?.info(
-            `⌛ timeline "${options.key}" pushed a state_update to "${token.key}"`
+            `⌛ timeline "${options.key}" got a state_update to "${token.key}"`
           )
           timelineData.at = timelineData.history.length
         }
       }
     })
   }
-
+  const core = target(store)
   for (const tokenOrFamily of options.atoms) {
+    const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
+    if (timelineKey) {
+      store.config.logger?.error(
+        `❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`
+      )
+      continue
+    }
     if (tokenOrFamily.type === `atom_family`) {
       const family = tokenOrFamily
       family.subject.subscribe((token) => subscribeToAtom(token))
     } else {
       const token = tokenOrFamily
+      if (`family` in token && token.family) {
+        const familyTimelineKey = core.timelineAtoms.getRelatedId(
+          token.family.key
+        )
+        if (familyTimelineKey) {
+          store.config.logger?.error(
+            `❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`
+          )
+          continue
+        }
+      }
       subscribeToAtom(token)
     }
+    core.timelineAtoms = core.timelineAtoms.set(tokenOrFamily.key, options.key)
   }
 
   store.timelineStore = HAMT.set(options.key, timelineData, store.timelineStore)
-
   return {
     key: options.key,
     type: `timeline`,
@@ -125,27 +211,29 @@ 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(
-      `Tried to redo on timeline "${token.key}" has not been initialized.`
+      `Failed to redo on timeline "${token.key}". This timeline has not been initialized.`
     )
     return
   }
   if (timelineData.at === timelineData.history.length) {
     store.config.logger?.warn(
-      `Tried to redo on timeline "${token.key}" but there is nothing to redo.`
+      `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 `state_update`: {
+    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
@@ -156,34 +244,40 @@ export const redo__INTERNAL = (
   }
   ++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(
-      `Tried to undo on timeline "${token.key}" has not been initialized.`
+      `Failed to undo on timeline "${token.key}". This timeline has not been initialized.`
     )
     return
   }
   if (timelineData.at === 0) {
     store.config.logger?.warn(
-      `Tried to undo on timeline "${token.key}" but there is nothing to undo.`
+      `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 `state_update`: {
+    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
@@ -193,4 +287,7 @@ export const undo__INTERNAL = (
     }
   }
   timelineData.timeTraveling = false
+  store.config.logger?.info(
+    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
+  )
 }

package/src/{internal/logger.ts → logger.ts}

@@ -1,7 +1,7 @@
 import { doNothing } from "~/packages/anvl/src/function"
 
-import type { Store } from "./store"
-import { IMPLICIT } from "./store"
+import type { Store } from "./internal/store"
+import { IMPLICIT } from "./internal/store"
 
 export type Logger = Pick<Console, `error` | `info` | `warn`>
 export const LOG_LEVELS: ReadonlyArray<keyof Logger> = [

package/src/selector.ts

@@ -4,12 +4,12 @@ import type { Serializable } from "~/packages/anvl/src/json"
 
 import type { ReadonlyValueToken, SelectorToken } from "."
 import { selectorFamily__INTERNAL, selector__INTERNAL } from "./internal"
-import type { ReadonlyTransactors, Transactors } from "./transaction"
+import type { Read, Write } from "./transaction"
 
 export type SelectorOptions<T> = {
   key: string
-  get: (readonlyTransactors: ReadonlyTransactors) => T
-  set: (transactors: Transactors, newValue: T) => void
+  get: Read<() => T>
+  set: Write<(newValue: T) => void>
 }
 export type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>
 
@@ -25,8 +25,8 @@ export function selector<T>(
 
 export type SelectorFamilyOptions<T, K extends Serializable> = {
   key: string
-  get: (key: K) => (readonlyTransactors: ReadonlyTransactors) => T
-  set: (key: K) => (transactors: Transactors, newValue: T) => void
+  get: (key: K) => Read<() => T>
+  set: (key: K) => Write<(newValue: T) => void>
 }
 export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<
   SelectorFamilyOptions<T, K>,

package/src/subscribe.ts

@@ -14,7 +14,7 @@ export const subscribe = <T>(
   const subscription = state.subject.subscribe(handleUpdate)
   store.config.logger?.info(`👀 subscribe to "${state.key}"`)
   const dependencySubscriptions =
-    `get` in state ? subscribeToRootAtoms(state, store) : null
+    state.type !== `atom` ? subscribeToRootAtoms(state, store) : null
 
   const unsubscribe =
     dependencySubscriptions === null

package/src/timeline.ts

@@ -1,10 +1,5 @@
-import HAMT from "hamt_plus"
-import type * as Rx from "rxjs"
-
-import type { AtomFamily, AtomToken, ƒn } from "."
-import { setState } from "."
-import type { Store, KeyedStateUpdate, TransactionUpdate } from "./internal"
-import { target, IMPLICIT, withdraw } from "./internal"
+import type { AtomFamily, AtomToken } from "."
+import { IMPLICIT } from "./internal"
 import {
   redo__INTERNAL,
   timeline__INTERNAL,

package/src/transaction.ts

@@ -12,14 +12,19 @@ export type Transactors = {
 }
 export type ReadonlyTransactors = Pick<Transactors, `get`>
 
-export type Action<ƒ extends ƒn> = (
+export type Read<ƒ extends ƒn> = (
+  transactors: ReadonlyTransactors,
+  ...parameters: Parameters<ƒ>
+) => ReturnType<ƒ>
+
+export type Write<ƒ extends ƒn> = (
   transactors: Transactors,
   ...parameters: Parameters<ƒ>
 ) => ReturnType<ƒ>
 
 export type TransactionOptions<ƒ extends ƒn> = {
   key: string
-  do: Action<ƒ>
+  do: Write<ƒ>
 }
 
 export type Transaction<ƒ extends ƒn> = {