atom.io 0.6.2 → 0.6.3

package/src/internal/transaction/build-transaction.ts

@@ -1,33 +1,33 @@
 import type { Store } from ".."
 
 export const buildTransaction = (
-  key: string,
-  params: any[],
-  store: Store
+	key: string,
+	params: any[],
+	store: Store,
 ): void => {
-  store.transactionStatus = {
-    key,
-    phase: `building`,
-    time: Date.now(),
-    core: {
-      atoms: store.atoms,
-      atomsThatAreDefault: store.atomsThatAreDefault,
-      operation: { open: false },
-      readonlySelectors: store.readonlySelectors,
-      timelines: store.timelines,
-      timelineAtoms: store.timelineAtoms,
-      transactions: store.transactions,
-      selectorAtoms: store.selectorAtoms,
-      selectorGraph: store.selectorGraph,
-      selectors: store.selectors,
-      valueMap: store.valueMap,
-    },
-    atomUpdates: [],
-    params,
-    output: undefined,
-  }
-  store.config.logger?.info(
-    `🛫`,
-    `transaction "${key}" started in store "${store.config.name}"`
-  )
+	store.transactionStatus = {
+		key,
+		phase: `building`,
+		time: Date.now(),
+		core: {
+			atoms: store.atoms,
+			atomsThatAreDefault: store.atomsThatAreDefault,
+			operation: { open: false },
+			readonlySelectors: store.readonlySelectors,
+			timelines: store.timelines,
+			timelineAtoms: store.timelineAtoms,
+			transactions: store.transactions,
+			selectorAtoms: store.selectorAtoms,
+			selectorGraph: store.selectorGraph,
+			selectors: store.selectors,
+			valueMap: store.valueMap,
+		},
+		atomUpdates: [],
+		params,
+		output: undefined,
+	}
+	store.config.logger?.info(
+		`🛫`,
+		`transaction "${key}" started in store "${store.config.name}"`,
+	)
 }

package/src/internal/transaction/index.ts

@@ -10,16 +10,16 @@ export * from "./redo-transaction"
 export * from "./undo-transaction"
 
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
-export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
+export type TransactionPhase = typeof TRANSACTION_PHASES[number]
 
 export type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
-  phase: `applying` | `building`
-  time: number
-  core: StoreCore
+	phase: `applying` | `building`
+	time: number
+	core: StoreCore
 }
 export type TransactionIdle = {
-  phase: `idle`
+	phase: `idle`
 }
 export type TransactionStatus<ƒ extends ƒn> =
-  | TransactionIdle
-  | TransactionUpdateInProgress<ƒ>
+	| TransactionIdle
+	| TransactionUpdateInProgress<ƒ>

package/src/internal/transaction/redo-transaction.ts

@@ -6,18 +6,18 @@ import type { AtomToken, TransactionUpdate } from "../.."
 import { setState } from "../.."
 
 export const redoTransactionUpdate = <ƒ extends ƒn>(
-  update: TransactionUpdate<ƒ>,
-  store: Store
+	update: TransactionUpdate<ƒ>,
+	store: Store,
 ): void => {
-  store.config.logger?.info(` ⏭ redo transaction "${update.key}" (redo)`)
-  for (const { key, newValue } of update.atomUpdates) {
-    const token: AtomToken<unknown> = { key, type: `atom` }
-    const state = withdraw(token, store)
-    if (state === null) {
-      throw new Error(
-        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
-      )
-    }
-    setState(state, newValue, store)
-  }
+	store.config.logger?.info(` ⏭ redo transaction "${update.key}" (redo)`)
+	for (const { key, newValue } of update.atomUpdates) {
+		const token: AtomToken<unknown> = { key, type: `atom` }
+		const state = withdraw(token, store)
+		if (state === null) {
+			throw new Error(
+				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
+			)
+		}
+		setState(state, newValue, store)
+	}
 }

package/src/internal/transaction/undo-transaction.ts

@@ -6,18 +6,18 @@ import type { AtomToken, TransactionUpdate } from "../.."
 import { setState } from "../.."
 
 export const undoTransactionUpdate = <ƒ extends ƒn>(
-  update: TransactionUpdate<ƒ>,
-  store: Store
+	update: TransactionUpdate<ƒ>,
+	store: Store,
 ): void => {
-  store.config.logger?.info(` ⏮ undo transaction "${update.key}" (undo)`)
-  for (const { key, oldValue } of update.atomUpdates) {
-    const token: AtomToken<unknown> = { key, type: `atom` }
-    const state = withdraw(token, store)
-    if (state === null) {
-      throw new Error(
-        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
-      )
-    }
-    setState(state, oldValue, store)
-  }
+	store.config.logger?.info(` ⏮ undo transaction "${update.key}" (undo)`)
+	for (const { key, oldValue } of update.atomUpdates) {
+		const token: AtomToken<unknown> = { key, type: `atom` }
+		const state = withdraw(token, store)
+		if (state === null) {
+			throw new Error(
+				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
+			)
+		}
+		setState(state, oldValue, store)
+	}
 }

package/src/internal/transaction-internal.ts

@@ -5,63 +5,63 @@ import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store, StoreCore } from "."
 import {
-  abortTransaction,
-  applyTransaction,
-  buildTransaction,
-  deposit,
-  IMPLICIT,
+	abortTransaction,
+	applyTransaction,
+	buildTransaction,
+	deposit,
+	IMPLICIT,
 } from "."
 import type { TransactionOptions, TransactionToken, TransactionUpdate } from ".."
 import { getState, setState } from ".."
 
 export type Transaction<ƒ extends ƒn> = {
-  key: string
-  type: `transaction`
-  install: (store: Store) => void
-  subject: Rx.Subject<TransactionUpdate<ƒ>>
-  run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
+	key: string
+	type: `transaction`
+	install: (store: Store) => void
+	subject: Rx.Subject<TransactionUpdate<ƒ>>
+	run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
 }
 
 export function transaction__INTERNAL<ƒ extends ƒn>(
-  options: TransactionOptions<ƒ>,
-  store: Store = IMPLICIT.STORE
+	options: TransactionOptions<ƒ>,
+	store: Store = IMPLICIT.STORE,
 ): TransactionToken<ƒ> {
-  const newTransaction: Transaction<ƒ> = {
-    key: options.key,
-    type: `transaction`,
-    run: (...params: Parameters<ƒ>) => {
-      buildTransaction(options.key, params, store)
-      try {
-        const output = options.do(
-          {
-            get: (token) => getState(token, store),
-            set: (token, value) => setState(token, value, store),
-          },
-          ...params
-        )
-        applyTransaction(output, store)
-        return output
-      } catch (thrown) {
-        abortTransaction(store)
-        store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
-        throw thrown
-      }
-    },
-    install: (store) => transaction__INTERNAL(options, store),
-    subject: new Rx.Subject(),
-  }
-  const core = target(store)
-  core.transactions = HAMT.set(
-    newTransaction.key,
-    newTransaction,
-    core.transactions
-  )
-  const token = deposit(newTransaction)
-  store.subject.transactionCreation.next(token)
-  return token
+	const newTransaction: Transaction<ƒ> = {
+		key: options.key,
+		type: `transaction`,
+		run: (...params: Parameters<ƒ>) => {
+			buildTransaction(options.key, params, store)
+			try {
+				const output = options.do(
+					{
+						get: (token) => getState(token, store),
+						set: (token, value) => setState(token, value, store),
+					},
+					...params,
+				)
+				applyTransaction(output, store)
+				return output
+			} catch (thrown) {
+				abortTransaction(store)
+				store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
+				throw thrown
+			}
+		},
+		install: (store) => transaction__INTERNAL(options, store),
+		subject: new Rx.Subject(),
+	}
+	const core = target(store)
+	core.transactions = HAMT.set(
+		newTransaction.key,
+		newTransaction,
+		core.transactions,
+	)
+	const token = deposit(newTransaction)
+	store.subject.transactionCreation.next(token)
+	return token
 }
 
 export const target = (store: Store = IMPLICIT.STORE): StoreCore =>
-  store.transactionStatus.phase === `building`
-    ? store.transactionStatus.core
-    : store
+	store.transactionStatus.phase === `building`
+		? store.transactionStatus.core
+		: store

package/src/json/select-json.ts

@@ -3,16 +3,16 @@ import * as AtomIO from "atom.io"
 import type { Json, JsonInterface } from "~/packages/anvl/src/json"
 
 export const selectJson = <T, J extends Json>(
-  atom: AtomIO.AtomToken<T>,
-  transform: JsonInterface<T, J>,
-  store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE
+	atom: AtomIO.AtomToken<T>,
+	transform: JsonInterface<T, J>,
+	store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE,
 ): AtomIO.SelectorToken<J> =>
-  AtomIO.__INTERNAL__.selector__INTERNAL(
-    {
-      key: `${atom.key}JSON`,
-      get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => set(atom, transform.fromJson(newValue)),
-    },
-    undefined,
-    store
-  )
+	AtomIO.__INTERNAL__.selector__INTERNAL(
+		{
+			key: `${atom.key}JSON`,
+			get: ({ get }) => transform.toJson(get(atom)),
+			set: ({ set }, newValue) => set(atom, transform.fromJson(newValue)),
+		},
+		undefined,
+		store,
+	)

package/src/logger.ts

@@ -5,42 +5,42 @@ import { IMPLICIT } from "./internal/store"
 
 export type Logger = Pick<Console, `error` | `info` | `warn`>
 export const LOG_LEVELS: ReadonlyArray<keyof Logger> = [
-  `info`,
-  `warn`,
-  `error`,
+	`info`,
+	`warn`,
+	`error`,
 ] as const
 
 export const setLogLevel = (
-  preferredLevel: `error` | `info` | `warn` | null,
-  store: Store = IMPLICIT.STORE
+	preferredLevel: `error` | `info` | `warn` | null,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const { logger__INTERNAL } = store.config
-  if (preferredLevel === null) {
-    store.config.logger = null
-  } else {
-    store.config.logger = { ...console }
-    LOG_LEVELS.forEach((logLevel) => {
-      if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
-        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-        store.config.logger![logLevel] = doNothing
-      } else {
-        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-        store.config.logger![logLevel] = logger__INTERNAL[logLevel]
-      }
-    })
-  }
+	const { logger__INTERNAL } = store.config
+	if (preferredLevel === null) {
+		store.config.logger = null
+	} else {
+		store.config.logger = { ...console }
+		LOG_LEVELS.forEach((logLevel) => {
+			if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
+				// rome-ignore lint/style/noNonNullAssertion: we just set it
+				store.config.logger![logLevel] = doNothing
+			} else {
+				// rome-ignore lint/style/noNonNullAssertion: we just set it
+				store.config.logger![logLevel] = logger__INTERNAL[logLevel]
+			}
+		})
+	}
 }
 
 export const useLogger = (
-  logger: Logger,
-  store: Store = IMPLICIT.STORE
+	logger: Logger,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const currentLogLevel =
-    store.config.logger === null
-      ? null
-      : LOG_LEVELS.find(
-          (logLevel) => store.config.logger?.[logLevel] !== doNothing
-        ) ?? null
-  store.config.logger__INTERNAL = { ...logger }
-  setLogLevel(currentLogLevel, store)
+	const currentLogLevel =
+		store.config.logger === null
+			? null
+			: LOG_LEVELS.find(
+					(logLevel) => store.config.logger?.[logLevel] !== doNothing,
+			  ) ?? null
+	store.config.logger__INTERNAL = { ...logger }
+	setLogLevel(currentLogLevel, store)
 }

package/src/react/store-context.tsx

@@ -3,12 +3,12 @@ import * as React from "react"
 import * as AtomIO from "atom.io"
 
 export const StoreContext = React.createContext<AtomIO.Store>(
-  AtomIO.__INTERNAL__.IMPLICIT.STORE
+	AtomIO.__INTERNAL__.IMPLICIT.STORE,
 )
 
 export const StoreProvider: React.FC<{
-  children: React.ReactNode
-  store?: AtomIO.Store
+	children: React.ReactNode
+	store?: AtomIO.Store
 }> = ({ children, store = AtomIO.__INTERNAL__.IMPLICIT.STORE }) => (
-  <StoreContext.Provider value={store}>{children}</StoreContext.Provider>
+	<StoreContext.Provider value={store}>{children}</StoreContext.Provider>
 )

package/src/react/store-hooks.ts

@@ -7,42 +7,42 @@ import type { Modifier } from "~/packages/anvl/src/function"
 import { StoreContext } from "./store-context"
 
 export type StoreHooks = {
-  useI: <T>(token: AtomIO.StateToken<T>) => (next: Modifier<T> | T) => void
-  useO: <T>(token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>) => T
-  useIO: <T>(token: AtomIO.StateToken<T>) => [T, (next: Modifier<T> | T) => void]
+	useI: <T>(token: AtomIO.StateToken<T>) => (next: Modifier<T> | T) => void
+	useO: <T>(token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>) => T
+	useIO: <T>(token: AtomIO.StateToken<T>) => [T, (next: Modifier<T> | T) => void]
 }
 export const storeHooks: StoreHooks = { useI, useO, useIO }
 
 export function useI<T>(
-  token: AtomIO.StateToken<T>
+	token: AtomIO.StateToken<T>,
 ): (next: Modifier<T> | T) => void {
-  const store = React.useContext(StoreContext)
-  const update = (next: Modifier<T> | T) => AtomIO.setState(token, next, store)
-  return update
+	const store = React.useContext(StoreContext)
+	const update = (next: Modifier<T> | T) => AtomIO.setState(token, next, store)
+	return update
 }
 
 export function useO<T>(
-  token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>
+	token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>,
 ): T {
-  const store = React.useContext(StoreContext)
-  return React.useSyncExternalStore<T>(
-    (observe) => AtomIO.subscribe(token, observe, store),
-    () => AtomIO.getState(token, store)
-  )
+	const store = React.useContext(StoreContext)
+	return React.useSyncExternalStore<T>(
+		(observe) => AtomIO.subscribe(token, observe, store),
+		() => AtomIO.getState(token, store),
+	)
 }
 
 export function useIO<T>(
-  token: AtomIO.StateToken<T>
+	token: AtomIO.StateToken<T>,
 ): [T, (next: Modifier<T> | T) => void] {
-  return [useO(token), useI(token)]
+	return [useO(token), useI(token)]
 }
 
 export function useStore<T>(
-  token: AtomIO.StateToken<T>
+	token: AtomIO.StateToken<T>,
 ): [T, (next: Modifier<T> | T) => void]
 export function useStore<T>(token: AtomIO.ReadonlySelectorToken<T>): T
 export function useStore<T>(
-  token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>
+	token: AtomIO.ReadonlySelectorToken<T> | AtomIO.StateToken<T>,
 ): T | [T, (next: Modifier<T> | T) => void] {
-  return token.type === `readonly_selector` ? useO(token) : useIO(token)
+	return token.type === `readonly_selector` ? useO(token) : useIO(token)
 }

package/src/react-devtools/AtomIODevtools.tsx

@@ -12,96 +12,97 @@ import { lazyLocalStorageEffect } from "../web-effects"
 import "./devtools.scss"
 
 const { atomTokenIndexState, selectorTokenIndexState } =
-  __INTERNAL__.META.attachMetaState()
+	__INTERNAL__.META.attachMetaState()
 
 const devtoolsAreOpenState = atom<boolean>({
-  key: `👁‍🗨_devtools_are_open`,
-  default: true,
-  effects: [lazyLocalStorageEffect(`👁‍🗨_devtools_are_open`)],
+	key: `👁‍🗨_devtools_are_open`,
+	default: true,
+	effects: [lazyLocalStorageEffect(`👁‍🗨_devtools_are_open`)],
 })
 
 export const composeDevtools = (storeHooks: StoreHooks): FC => {
-  const Devtools: FC = () => {
-    const constraintsRef = useRef(null)
+	const Devtools: FC = () => {
+		const constraintsRef = useRef(null)
 
-    const [devtoolsAreOpen, setDevtoolsAreOpen] =
-      storeHooks.useIO(devtoolsAreOpenState)
+		const [devtoolsAreOpen, setDevtoolsAreOpen] =
+			storeHooks.useIO(devtoolsAreOpenState)
 
-    const mouseHasMoved = useRef(false)
+		const mouseHasMoved = useRef(false)
 
-    return (
-      <>
-        <motion.span
-          ref={constraintsRef}
-          className="atom_io_devtools_zone"
-          style={{
-            position: `fixed`,
-            top: 0,
-            left: 0,
-            right: 0,
-            bottom: 0,
-            pointerEvents: `none`,
-          }}
-        />
-        <motion.main
-          drag
-          dragConstraints={constraintsRef}
-          className="atom_io_devtools"
-          transition={spring}
-          style={
-            devtoolsAreOpen
-              ? {}
-              : {
-                  backgroundColor: `#0000`,
-                  borderColor: `#0000`,
-                  maxHeight: 28,
-                  maxWidth: 33,
-                }
-          }
-        >
-          {devtoolsAreOpen ? (
-            <>
-              <motion.header>
-                <h1>atom.io</h1>
-              </motion.header>
-              <motion.main>
-                <LayoutGroup>
-                  <section>
-                    <h2>atoms</h2>
-                    <TokenList
-                      storeHooks={storeHooks}
-                      tokenIndex={atomTokenIndexState}
-                    />
-                  </section>
-                  <section>
-                    <h2>selectors</h2>
-                    <TokenList
-                      storeHooks={storeHooks}
-                      tokenIndex={selectorTokenIndexState}
-                    />
-                  </section>
-                </LayoutGroup>
-              </motion.main>
-            </>
-          ) : null}
-          <footer>
-            <button
-              onMouseDown={() => (mouseHasMoved.current = false)}
-              onMouseMove={() => (mouseHasMoved.current = true)}
-              onMouseUp={() => {
-                if (!mouseHasMoved.current) {
-                  setDevtoolsAreOpen((open) => !open)
-                }
-              }}
-            >
-              👁‍🗨
-            </button>
-          </footer>
-        </motion.main>
-      </>
-    )
-  }
-  return Devtools
+		return (
+			<>
+				<motion.span
+					ref={constraintsRef}
+					className="atom_io_devtools_zone"
+					style={{
+						position: `fixed`,
+						top: 0,
+						left: 0,
+						right: 0,
+						bottom: 0,
+						pointerEvents: `none`,
+					}}
+				/>
+				<motion.main
+					drag
+					dragConstraints={constraintsRef}
+					className="atom_io_devtools"
+					transition={spring}
+					style={
+						devtoolsAreOpen
+							? {}
+							: {
+									backgroundColor: `#0000`,
+									borderColor: `#0000`,
+									maxHeight: 28,
+									maxWidth: 33,
+							  }
+					}
+				>
+					{devtoolsAreOpen ? (
+						<>
+							<motion.header>
+								<h1>atom.io</h1>
+							</motion.header>
+							<motion.main>
+								<LayoutGroup>
+									<section>
+										<h2>atoms</h2>
+										<TokenList
+											storeHooks={storeHooks}
+											tokenIndex={atomTokenIndexState}
+										/>
+									</section>
+									<section>
+										<h2>selectors</h2>
+										<TokenList
+											storeHooks={storeHooks}
+											tokenIndex={selectorTokenIndexState}
+										/>
+									</section>
+								</LayoutGroup>
+							</motion.main>
+						</>
+					) : null}
+					<footer>
+						<button
+							type="button"
+							onMouseDown={() => (mouseHasMoved.current = false)}
+							onMouseMove={() => (mouseHasMoved.current = true)}
+							onMouseUp={() => {
+								if (!mouseHasMoved.current) {
+									setDevtoolsAreOpen((open) => !open)
+								}
+							}}
+						>
+							👁‍🗨
+						</button>
+					</footer>
+				</motion.main>
+			</>
+		)
+	}
+	return Devtools
 }
 
 export const AtomIODevtools = composeDevtools({ useI, useO, useIO })