atom.io 0.6.2 → 0.6.3

package/src/internal/store.ts

@@ -7,147 +7,147 @@ import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
 
 import type {
-  Atom,
-  OperationProgress,
-  ReadonlySelector,
-  Selector,
-  TransactionStatus,
-  Timeline,
-  Transaction,
+	Atom,
+	OperationProgress,
+	ReadonlySelector,
+	Selector,
+	TransactionStatus,
+	Timeline,
+	Transaction,
 } from "."
 import type {
-  AtomToken,
-  Logger,
-  ReadonlySelectorToken,
-  SelectorToken,
-  TimelineToken,
-  TransactionToken,
+	AtomToken,
+	Logger,
+	ReadonlySelectorToken,
+	SelectorToken,
+	TimelineToken,
+	TransactionToken,
 } from ".."
 
 export type StoreCore = Pick<
-  Store,
-  | `atoms`
-  | `atomsThatAreDefault`
-  | `operation`
-  | `readonlySelectors`
-  | `selectorAtoms`
-  | `selectorGraph`
-  | `selectors`
-  | `timelineAtoms`
-  | `timelines`
-  | `transactions`
-  | `valueMap`
+	Store,
+	| `atoms`
+	| `atomsThatAreDefault`
+	| `operation`
+	| `readonlySelectors`
+	| `selectorAtoms`
+	| `selectorGraph`
+	| `selectors`
+	| `timelineAtoms`
+	| `timelines`
+	| `transactions`
+	| `valueMap`
 >
 
 export interface Store {
-  atoms: Hamt<Atom<any>, string>
-  atomsThatAreDefault: Set<string>
-  readonlySelectors: Hamt<ReadonlySelector<any>, string>
-  selectorAtoms: Join<null, `selectorKey`, `atomKey`>
-  selectorGraph: Join<{ source: string }>
-  selectors: Hamt<Selector<any>, string>
-  timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-  timelines: Hamt<Timeline, string>
-  transactions: Hamt<Transaction<any>, string>
-  valueMap: Hamt<any, string>
+	atoms: Hamt<Atom<any>, string>
+	atomsThatAreDefault: Set<string>
+	readonlySelectors: Hamt<ReadonlySelector<any>, string>
+	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
+	selectorGraph: Join<{ source: string }>
+	selectors: Hamt<Selector<any>, string>
+	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
+	timelines: Hamt<Timeline, 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>
-  }
+	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: {
-    name: string
-    logger: Logger | null
-    logger__INTERNAL: Logger
-  }
+	operation: OperationProgress
+	transactionStatus: TransactionStatus<ƒn>
+	config: {
+		name: string
+		logger: Logger | null
+		logger__INTERNAL: Logger
+	}
 }
 
 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>(),
-      }))()),
+	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>(),
-    readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-    selectors: HAMT.make<Selector<any>, string>(),
-    transactions: HAMT.make<Transaction<any>, string>(),
-    timelines: HAMT.make<Timeline, string>(),
+		atoms: HAMT.make<Atom<any>, string>(),
+		readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
+		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`),
+		timelineAtoms: new Join({ relationType: `1:n` })
+			.from(`timelineKey`)
+			.to(`atomKey`),
 
-    subject: {
-      atomCreation: new Rx.Subject(),
-      selectorCreation: new Rx.Subject(),
-      transactionCreation: new Rx.Subject(),
-      timelineCreation: new Rx.Subject(),
-      ...store?.subject,
-    },
+		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: {
-      logger: {
-        ...console,
-        info: doNothing,
-        ...store?.config?.logger,
-      },
-      logger__INTERNAL: console,
-      ...store?.config,
-      name,
-    },
-  } satisfies Store
+		operation: {
+			open: false,
+			...store?.operation,
+		},
+		transactionStatus: {
+			phase: `idle`,
+			...store?.transactionStatus,
+		},
+		config: {
+			logger: {
+				...console,
+				info: doNothing,
+				...store?.config?.logger,
+			},
+			logger__INTERNAL: console,
+			...store?.config,
+			name,
+		},
+	} 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)
-  })
+	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
+	return copiedStore
 }
 
 export const IMPLICIT = {
-  STORE_INTERNAL: undefined as Store | undefined,
-  get STORE(): Store {
-    return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
-  },
+	STORE_INTERNAL: undefined as Store | undefined,
+	get STORE(): Store {
+		return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
+	},
 }
 
 export const clearStore = (store: Store = IMPLICIT.STORE): void => {
-  const { config } = store
-  Object.assign(store, createStore(config.name))
-  store.config = config
+	const { config } = store
+	Object.assign(store, createStore(config.name))
+	store.config = config
 }

package/src/internal/subscribe-internal.ts

@@ -1,82 +1,82 @@
 import type { Atom, ReadonlySelector, Selector, Store } from "."
 import {
-  getState__INTERNAL,
-  withdraw,
-  recallState,
-  traceAllSelectorAtoms,
+	getState__INTERNAL,
+	withdraw,
+	recallState,
+	traceAllSelectorAtoms,
 } from "."
 import type { StateUpdate } from ".."
 
 export const prepareUpdate = <T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  store: Store
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	store: Store,
 ): StateUpdate<T> => {
-  const oldValue = recallState(state, store)
-  const newValue = getState__INTERNAL(state, store)
-  return { newValue, oldValue }
+	const oldValue = recallState(state, store)
+	const newValue = getState__INTERNAL(state, store)
+	return { newValue, oldValue }
 }
 
 export const stowUpdate = <T>(
-  state: Atom<T>,
-  update: StateUpdate<T>,
-  store: Store
+	state: Atom<T>,
+	update: StateUpdate<T>,
+	store: Store,
 ): void => {
-  const { key } = state
-  const { logger } = store.config
-  if (store.transactionStatus.phase !== `building`) {
-    store.config.logger?.warn(
-      `stowUpdate called outside of a transaction. This is probably a bug.`
-    )
-    return
-  }
-  store.transactionStatus.atomUpdates.push({ key, ...update })
-  logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
+	const { key } = state
+	const { logger } = store.config
+	if (store.transactionStatus.phase !== `building`) {
+		store.config.logger?.warn(
+			`stowUpdate called outside of a transaction. This is probably a bug.`,
+		)
+		return
+	}
+	store.transactionStatus.atomUpdates.push({ key, ...update })
+	logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
 }
 
 export const emitUpdate = <T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  update: StateUpdate<T>,
-  store: Store
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	update: StateUpdate<T>,
+	store: Store,
 ): void => {
-  const { key } = state
-  const { logger } = store.config
-  logger?.info(
-    `📢 ${state.type} "${key}" went (`,
-    update.oldValue,
-    `->`,
-    update.newValue,
-    `)`
-  )
-  state.subject.next(update)
+	const { key } = state
+	const { logger } = store.config
+	logger?.info(
+		`📢 ${state.type} "${key}" went (`,
+		update.oldValue,
+		`->`,
+		update.newValue,
+		`)`,
+	)
+	state.subject.next(update)
 }
 
 export const subscribeToRootAtoms = <T>(
-  state: ReadonlySelector<T> | Selector<T>,
-  store: Store
+	state: ReadonlySelector<T> | Selector<T>,
+	store: Store,
 ): { unsubscribe: () => void }[] | null => {
-  const dependencySubscriptions =
-    `default` in state
-      ? null
-      : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
-          const atom = withdraw(atomToken, store)
-          if (atom === null) {
-            throw new Error(
-              `Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
-            )
-          }
-          return atom.subject.subscribe((atomChange) => {
-            store.config.logger?.info(
-              `📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
-              atomChange.oldValue,
-              `->`,
-              atomChange.newValue,
-              `)`
-            )
-            const oldValue = recallState(state, store)
-            const newValue = getState__INTERNAL(state, store)
-            store.config.logger?.info(`   <- ${state.key} became`, newValue)
-            state.subject.next({ newValue, oldValue })
-          })
-        })
-  return dependencySubscriptions
+	const dependencySubscriptions =
+		`default` in state
+			? null
+			: traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+					const atom = withdraw(atomToken, store)
+					if (atom === null) {
+						throw new Error(
+							`Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
+						)
+					}
+					return atom.subject.subscribe((atomChange) => {
+						store.config.logger?.info(
+							`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
+							atomChange.oldValue,
+							`->`,
+							atomChange.newValue,
+							`)`,
+						)
+						const oldValue = recallState(state, store)
+						const newValue = getState__INTERNAL(state, store)
+						store.config.logger?.info(`   <- ${state.key} became`, newValue)
+						state.subject.next({ newValue, oldValue })
+					})
+			  })
+	return dependencySubscriptions
 }

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

@@ -4,86 +4,86 @@ import type { TimelineToken } from ".."
 import { setState } from ".."
 
 export const redo__INTERNAL = (
-  token: TimelineToken,
-  store: Store = IMPLICIT.STORE
+	token: TimelineToken,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  store.config.logger?.info(`⏩ redo "${token.key}"`)
-  const timelineData = store.timelines.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, store)
-      break
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of update.atomUpdates) {
-        const { key, newValue } = atomUpdate
-        setState({ key, type: `atom` }, newValue, store)
-      }
-      break
-    }
-  }
-  ++timelineData.at
-  timelineData.timeTraveling = false
-  store.config.logger?.info(
-    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  )
+	store.config.logger?.info(`⏩ redo "${token.key}"`)
+	const timelineData = store.timelines.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, store)
+			break
+		}
+		case `selector_update`:
+		case `transaction_update`: {
+			for (const atomUpdate of update.atomUpdates) {
+				const { key, newValue } = atomUpdate
+				setState({ key, type: `atom` }, newValue, store)
+			}
+			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
+	token: TimelineToken,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  store.config.logger?.info(`⏪ undo "${token.key}"`)
-  const timelineData = store.timelines.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
+	store.config.logger?.info(`⏪ undo "${token.key}"`)
+	const timelineData = store.timelines.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, store)
-      break
-    }
-    case `selector_update`:
-    case `transaction_update`: {
-      for (const atomUpdate of update.atomUpdates) {
-        const { key, oldValue } = atomUpdate
-        setState({ key, type: `atom` }, oldValue, store)
-      }
-      break
-    }
-  }
-  timelineData.timeTraveling = false
-  store.config.logger?.info(
-    `⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`
-  )
+	--timelineData.at
+	const update = timelineData.history[timelineData.at]
+	switch (update.type) {
+		case `atom_update`: {
+			const { key, oldValue } = update
+			setState({ key, type: `atom` }, oldValue, store)
+			break
+		}
+		case `selector_update`:
+		case `transaction_update`: {
+			for (const atomUpdate of update.atomUpdates) {
+				const { key, oldValue } = atomUpdate
+				setState({ key, type: `atom` }, oldValue, store)
+			}
+			break
+		}
+	}
+	timelineData.timeTraveling = false
+	store.config.logger?.info(
+		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
+	)
 }