atom.io 0.4.0 → 0.5.0

package/src/silo.ts

@@ -0,0 +1,45 @@
+import { type timeline, getState, setState, subscribe } from "."
+import type { atom, atomFamily } from "./atom"
+import {
+  type Store,
+  atomFamily__INTERNAL,
+  atom__INTERNAL,
+  createStore,
+  selectorFamily__INTERNAL,
+  selector__INTERNAL,
+  timeline__INTERNAL,
+  transaction__INTERNAL,
+} from "./internal"
+import type { selector, selectorFamily } from "./selector"
+import type { transaction } from "./transaction"
+
+export type Silo = ReturnType<typeof silo>
+
+export const silo = (
+  name: string
+): {
+  store: Store
+  atom: typeof atom
+  atomFamily: typeof atomFamily
+  selector: typeof selector
+  selectorFamily: typeof selectorFamily
+  transaction: typeof transaction
+  timeline: typeof timeline
+  getState: typeof getState
+  setState: typeof setState
+  subscribe: typeof subscribe
+} => {
+  const store = createStore(name)
+  return {
+    store,
+    atom: (options) => atom__INTERNAL(options, undefined, store),
+    atomFamily: (options) => atomFamily__INTERNAL(options, store),
+    selector: (options) => selector__INTERNAL(options, undefined, store) as any,
+    selectorFamily: (options) => selectorFamily__INTERNAL(options, store) as any,
+    transaction: (options) => transaction__INTERNAL(options, store),
+    timeline: (options) => timeline__INTERNAL(options, store),
+    getState: (token) => getState(token, store),
+    setState: (token, newValue) => setState(token, newValue, store),
+    subscribe: (token, handler) => subscribe(token, handler, store),
+  }
+}

package/src/subscribe.ts

@@ -1,4 +1,6 @@
-import type { ReadonlySelectorToken, StateToken, TransactionToken, ƒn } from "."
+import type { ƒn } from "~/packages/anvl/src/function"
+
+import type { ReadonlySelectorToken, StateToken, TransactionToken } from "."
 import type { Store, TransactionUpdate } from "./internal"
 import { IMPLICIT, subscribeToRootAtoms, withdraw } from "./internal"
 
@@ -11,6 +13,11 @@ export const subscribe = <T>(
   store: Store = IMPLICIT.STORE
 ): (() => void) => {
   const state = withdraw<T>(token, store)
+  if (state === null) {
+    throw new Error(
+      `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
+    )
+  }
   const subscription = state.subject.subscribe(handleUpdate)
   store.config.logger?.info(`👀 subscribe to "${state.key}"`)
   const dependencySubscriptions =
@@ -45,6 +52,11 @@ export const subscribeToTransaction = <ƒ extends ƒn>(
   store = IMPLICIT.STORE
 ): (() => void) => {
   const tx = withdraw(token, store)
+  if (tx === null) {
+    throw new Error(
+      `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
+    )
+  }
   store.config.logger?.info(`👀 subscribe to transaction "${token.key}"`)
   const subscription = tx.subject.subscribe(handleUpdate)
   const unsubscribe = () => {

package/src/transaction.ts

@@ -1,11 +1,11 @@
 import type * as Rx from "rxjs"
 
+import type { ƒn } from "~/packages/anvl/src/function"
+
 import type { ReadonlySelectorToken, StateToken, TransactionToken } from "."
 import type { Store, TransactionUpdate } from "./internal"
 import { IMPLICIT, transaction__INTERNAL, withdraw } from "./internal"
 
-export type ƒn = (...parameters: any[]) => any
-
 export type Transactors = {
   get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S
   set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void
@@ -33,6 +33,8 @@ export type Transaction<ƒ extends ƒn> = {
   run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
   subject: Rx.Subject<TransactionUpdate<ƒ>>
 }
+export type TransactionIO<Token extends TransactionToken<any>> =
+  Token extends TransactionToken<infer ƒ> ? ƒ : never
 
 export function transaction<ƒ extends ƒn>(
   options: TransactionOptions<ƒ>
@@ -42,5 +44,12 @@ export function transaction<ƒ extends ƒn>(
 
 export const runTransaction =
   <ƒ extends ƒn>(token: TransactionToken<ƒ>, store: Store = IMPLICIT.STORE) =>
-  (...parameters: Parameters<ƒ>): ReturnType<ƒ> =>
-    withdraw(token, store).run(...parameters)
+  (...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
+    const tx = withdraw(token, store)
+    if (tx) {
+      return tx.run(...parameters)
+    }
+    throw new Error(
+      `Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`
+    )
+  }