atom.io 0.6.2 → 0.6.3

package/src/internal/selector/create-readonly-selector.ts

@@ -3,50 +3,50 @@ import * as Rx from "rxjs"
 
 import { registerSelector } from "./register-selector"
 import type {
-  FamilyMetadata,
-  ReadonlySelectorOptions,
-  ReadonlySelectorToken,
-  Store,
+	FamilyMetadata,
+	ReadonlySelectorOptions,
+	ReadonlySelectorToken,
+	Store,
 } from "../.."
 import { cacheValue } from "../operation"
 import { selector__INTERNAL, type ReadonlySelector } from "../selector-internal"
 import type { StoreCore } from "../store"
 
 export const createReadonlySelector = <T>(
-  options: ReadonlySelectorOptions<T>,
-  family: FamilyMetadata | undefined,
-  store: Store,
-  core: StoreCore
+	options: ReadonlySelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+	store: Store,
+	core: StoreCore,
 ): ReadonlySelectorToken<T> => {
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
 
-  const { get } = registerSelector(options.key, store)
-  const getSelf = () => {
-    const value = options.get({ get })
-    cacheValue(options.key, value, store)
-    return value
-  }
+	const { get } = registerSelector(options.key, store)
+	const getSelf = () => {
+		const value = options.get({ get })
+		cacheValue(options.key, value, store)
+		return value
+	}
 
-  const readonlySelector: ReadonlySelector<T> = {
-    ...options,
-    subject,
-    install: (s: Store) => selector__INTERNAL(options, family, s),
-    get: getSelf,
-    type: `readonly_selector`,
-    ...(family && { family }),
-  }
-  core.readonlySelectors = HAMT.set(
-    options.key,
-    readonlySelector,
-    core.readonlySelectors
-  )
-  const initialValue = getSelf()
-  store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  const token: ReadonlySelectorToken<T> = {
-    key: options.key,
-    type: `readonly_selector`,
-    family,
-  }
-  store.subject.selectorCreation.next(token)
-  return token
+	const readonlySelector: ReadonlySelector<T> = {
+		...options,
+		subject,
+		install: (s: Store) => selector__INTERNAL(options, family, s),
+		get: getSelf,
+		type: `readonly_selector`,
+		...(family && { family }),
+	}
+	core.readonlySelectors = HAMT.set(
+		options.key,
+		readonlySelector,
+		core.readonlySelectors,
+	)
+	const initialValue = getSelf()
+	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
+	const token: ReadonlySelectorToken<T> = {
+		key: options.key,
+		type: `readonly_selector`,
+		family,
+	}
+	store.subject.selectorCreation.next(token)
+	return token
 }

package/src/internal/selector/lookup-selector-sources.ts

@@ -3,14 +3,14 @@ import { target, lookup } from ".."
 import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "../.."
 
 export const lookupSelectorSources = (
-  key: string,
-  store: Store
+	key: string,
+	store: Store,
 ): (
-  | AtomToken<unknown>
-  | ReadonlySelectorToken<unknown>
-  | SelectorToken<unknown>
+	| AtomToken<unknown>
+	| ReadonlySelectorToken<unknown>
+	| SelectorToken<unknown>
 )[] =>
-  target(store)
-    .selectorGraph.getRelations(key)
-    .filter(({ source }) => source !== key)
-    .map(({ source }) => lookup(source, store))
+	target(store)
+		.selectorGraph.getRelations(key)
+		.filter(({ source }) => source !== key)
+		.map(({ source }) => lookup(source, store))

package/src/internal/selector/register-selector.ts

@@ -7,51 +7,51 @@ import { IMPLICIT } from "../store"
 import { target } from "../transaction-internal"
 
 export const registerSelector = (
-  selectorKey: string,
-  store: Store = IMPLICIT.STORE
+	selectorKey: string,
+	store: Store = IMPLICIT.STORE,
 ): Transactors => ({
-  get: (dependency) => {
-    const core = target(store)
-    const alreadyRegistered = core.selectorGraph
-      .getRelations(selectorKey)
-      .some(({ source }) => source === dependency.key)
+	get: (dependency) => {
+		const core = target(store)
+		const alreadyRegistered = core.selectorGraph
+			.getRelations(selectorKey)
+			.some(({ source }) => source === dependency.key)
 
-    const dependencyState = withdraw(dependency, store)
-    if (dependencyState === null) {
-      throw new Error(
-        `State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      )
-    }
-    const dependencyValue = getState__INTERNAL(dependencyState, store)
+		const dependencyState = withdraw(dependency, store)
+		if (dependencyState === null) {
+			throw new Error(
+				`State "${dependency.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
+			)
+		}
+		const dependencyValue = getState__INTERNAL(dependencyState, store)
 
-    if (alreadyRegistered) {
-      store.config.logger?.info(
-        `   || ${selectorKey} <- ${dependency.key} =`,
-        dependencyValue
-      )
-    } else {
-      store.config.logger?.info(
-        `🔌 registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
-        dependencyValue,
-        `)`
-      )
-      core.selectorGraph = core.selectorGraph.set(
-        { from: dependency.key, to: selectorKey },
-        {
-          source: dependency.key,
-        }
-      )
-    }
-    updateSelectorAtoms(selectorKey, dependency, store)
-    return dependencyValue
-  },
-  set: (stateToken, newValue) => {
-    const state = withdraw(stateToken, store)
-    if (state === null) {
-      throw new Error(
-        `State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      )
-    }
-    setState__INTERNAL(state, newValue, store)
-  },
+		if (alreadyRegistered) {
+			store.config.logger?.info(
+				`   || ${selectorKey} <- ${dependency.key} =`,
+				dependencyValue,
+			)
+		} else {
+			store.config.logger?.info(
+				`🔌 registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
+				dependencyValue,
+				`)`,
+			)
+			core.selectorGraph = core.selectorGraph.set(
+				{ from: dependency.key, to: selectorKey },
+				{
+					source: dependency.key,
+				},
+			)
+		}
+		updateSelectorAtoms(selectorKey, dependency, store)
+		return dependencyValue
+	},
+	set: (stateToken, newValue) => {
+		const state = withdraw(stateToken, store)
+		if (state === null) {
+			throw new Error(
+				`State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
+			)
+		}
+		setState__INTERNAL(state, newValue, store)
+	},
 })

package/src/internal/selector/trace-selector-atoms.ts

@@ -2,42 +2,42 @@ import { lookupSelectorSources } from "./lookup-selector-sources"
 import type { Store, AtomToken, ReadonlySelectorToken, StateToken } from "../.."
 
 export const traceSelectorAtoms = (
-  selectorKey: string,
-  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store
+	selectorKey: string,
+	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	store: Store,
 ): AtomToken<unknown>[] => {
-  const roots: AtomToken<unknown>[] = []
+	const roots: AtomToken<unknown>[] = []
 
-  const sources = lookupSelectorSources(dependency.key, store)
-  let depth = 0
-  while (sources.length > 0) {
-    /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-    const source = sources.shift()!
-    ++depth
-    if (depth > 999) {
-      throw new Error(
-        `Maximum selector dependency depth exceeded in selector "${selectorKey}".`
-      )
-    }
+	const sources = lookupSelectorSources(dependency.key, store)
+	let depth = 0
+	while (sources.length > 0) {
+		// rome-ignore lint/style/noNonNullAssertion: just checked length ^^^
+		const source = sources.shift()!
+		++depth
+		if (depth > 999) {
+			throw new Error(
+				`Maximum selector dependency depth exceeded in selector "${selectorKey}".`,
+			)
+		}
 
-    if (source.type !== `atom`) {
-      sources.push(...lookupSelectorSources(source.key, store))
-    } else {
-      roots.push(source)
-    }
-  }
+		if (source.type !== `atom`) {
+			sources.push(...lookupSelectorSources(source.key, store))
+		} else {
+			roots.push(source)
+		}
+	}
 
-  return roots
+	return roots
 }
 
 export const traceAllSelectorAtoms = (
-  selectorKey: string,
-  store: Store
+	selectorKey: string,
+	store: Store,
 ): AtomToken<unknown>[] => {
-  const sources = lookupSelectorSources(selectorKey, store)
-  return sources.flatMap((source) =>
-    source.type === `atom`
-      ? source
-      : traceSelectorAtoms(selectorKey, source, store)
-  )
+	const sources = lookupSelectorSources(selectorKey, store)
+	return sources.flatMap((source) =>
+		source.type === `atom`
+			? source
+			: traceSelectorAtoms(selectorKey, source, store),
+	)
 }

package/src/internal/selector/update-selector-atoms.ts

@@ -4,30 +4,30 @@ import { target } from ".."
 import type { ReadonlySelectorToken, StateToken } from "../.."
 
 export const updateSelectorAtoms = (
-  selectorKey: string,
-  dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store
+	selectorKey: string,
+	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	store: Store,
 ): void => {
-  const core = target(store)
-  if (dependency.type === `atom`) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: dependency.key,
-    })
-    store.config.logger?.info(
-      `   || adding root for "${selectorKey}": ${dependency.key}`
-    )
-    return
-  }
-  const roots = traceSelectorAtoms(selectorKey, dependency, store)
-  store.config.logger?.info(
-    `   || adding roots for "${selectorKey}":`,
-    roots.map((r) => r.key)
-  )
-  for (const root of roots) {
-    core.selectorAtoms = core.selectorAtoms.set({
-      selectorKey,
-      atomKey: root.key,
-    })
-  }
+	const core = target(store)
+	if (dependency.type === `atom`) {
+		core.selectorAtoms = core.selectorAtoms.set({
+			selectorKey,
+			atomKey: dependency.key,
+		})
+		store.config.logger?.info(
+			`   || adding root for "${selectorKey}": ${dependency.key}`,
+		)
+		return
+	}
+	const roots = traceSelectorAtoms(selectorKey, dependency, store)
+	store.config.logger?.info(
+		`   || adding roots for "${selectorKey}":`,
+		roots.map((r) => r.key),
+	)
+	for (const root of roots) {
+		core.selectorAtoms = core.selectorAtoms.set({
+			selectorKey,
+			atomKey: root.key,
+		})
+	}
 }

package/src/internal/selector-internal.ts

@@ -6,56 +6,56 @@ import { target, IMPLICIT } from "."
 import { createReadWriteSelector } from "./selector/create-read-write-selector"
 import { createReadonlySelector } from "./selector/create-readonly-selector"
 import type {
-  FamilyMetadata,
-  ReadonlySelectorOptions,
-  ReadonlySelectorToken,
-  SelectorOptions,
-  SelectorToken,
+	FamilyMetadata,
+	ReadonlySelectorOptions,
+	ReadonlySelectorToken,
+	SelectorOptions,
+	SelectorToken,
 } from ".."
 
 export type Selector<T> = {
-  key: string
-  type: `selector`
-  family?: FamilyMetadata
-  install: (store: Store) => void
-  subject: Rx.Subject<{ newValue: T; oldValue: T }>
-  get: () => T
-  set: (newValue: T | ((oldValue: T) => T)) => void
+	key: string
+	type: `selector`
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Rx.Subject<{ newValue: T; oldValue: T }>
+	get: () => T
+	set: (newValue: T | ((oldValue: T) => T)) => void
 }
 export type ReadonlySelector<T> = {
-  key: string
-  type: `readonly_selector`
-  family?: FamilyMetadata
-  install: (store: Store) => void
-  subject: Rx.Subject<{ newValue: T; oldValue: T }>
-  get: () => T
+	key: string
+	type: `readonly_selector`
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Rx.Subject<{ newValue: T; oldValue: T }>
+	get: () => T
 }
 
 export function selector__INTERNAL<T>(
-  options: SelectorOptions<T>,
-  family?: FamilyMetadata,
-  store?: Store
+	options: SelectorOptions<T>,
+	family?: FamilyMetadata,
+	store?: Store,
 ): SelectorToken<T>
 export function selector__INTERNAL<T>(
-  options: ReadonlySelectorOptions<T>,
-  family?: FamilyMetadata,
-  store?: Store
+	options: ReadonlySelectorOptions<T>,
+	family?: FamilyMetadata,
+	store?: Store,
 ): ReadonlySelectorToken<T>
 export function selector__INTERNAL<T>(
-  options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
-  family?: FamilyMetadata,
-  store: Store = IMPLICIT.STORE
+	options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
+	family?: FamilyMetadata,
+	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
-  const core = target(store)
+	const core = target(store)
 
-  if (HAMT.has(options.key, core.selectors)) {
-    store.config.logger?.error(
-      `Key "${options.key}" already exists in the store.`
-    )
-  }
+	if (HAMT.has(options.key, core.selectors)) {
+		store.config.logger?.error(
+			`Key "${options.key}" already exists in the store.`,
+		)
+	}
 
-  if (!(`set` in options)) {
-    return createReadonlySelector(options, family, store, core)
-  }
-  return createReadWriteSelector(options, family, store, core)
+	if (!(`set` in options)) {
+		return createReadonlySelector(options, family, store, core)
+	}
+	return createReadWriteSelector(options, family, store, core)
 }

package/src/internal/set.ts

@@ -4,99 +4,99 @@ import { become } from "~/packages/anvl/src/function"
 
 import type { Atom, Selector, Store } from "."
 import {
-  IMPLICIT,
-  cacheValue,
-  emitUpdate,
-  evictCachedValue,
-  getState__INTERNAL,
-  isAtomDefault,
-  isDone,
-  markAtomAsNotDefault,
-  markDone,
-  stowUpdate,
-  target,
+	IMPLICIT,
+	cacheValue,
+	emitUpdate,
+	evictCachedValue,
+	getState__INTERNAL,
+	isAtomDefault,
+	isDone,
+	markAtomAsNotDefault,
+	markDone,
+	stowUpdate,
+	target,
 } from "."
 
 export const evictDownStream = <T>(
-  state: Atom<T>,
-  store: Store = IMPLICIT.STORE
+	state: Atom<T>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  const downstream = core.selectorAtoms.getRelations(state.key)
-  const downstreamKeys = downstream.map(({ id }) => id)
-  store.config.logger?.info(
-    `   || ${downstreamKeys.length} downstream:`,
-    downstreamKeys
-  )
-  if (core.operation.open) {
-    store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
-  }
-  downstream.forEach(({ id: stateKey }) => {
-    if (isDone(stateKey, store)) {
-      store.config.logger?.info(`   || ${stateKey} already done`)
-      return
-    }
-    const state =
-      HAMT.get(stateKey, core.selectors) ??
-      HAMT.get(stateKey, core.readonlySelectors)
-    if (!state) {
-      store.config.logger?.info(
-        `   || ${stateKey} is an atom, and can't be downstream`
-      )
-      return
-    }
-    evictCachedValue(stateKey, store)
-    store.config.logger?.info(`   xx evicted "${stateKey}"`)
+	const core = target(store)
+	const downstream = core.selectorAtoms.getRelations(state.key)
+	const downstreamKeys = downstream.map(({ id }) => id)
+	store.config.logger?.info(
+		`   || ${downstreamKeys.length} downstream:`,
+		downstreamKeys,
+	)
+	if (core.operation.open) {
+		store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
+	}
+	downstream.forEach(({ id: stateKey }) => {
+		if (isDone(stateKey, store)) {
+			store.config.logger?.info(`   || ${stateKey} already done`)
+			return
+		}
+		const state =
+			HAMT.get(stateKey, core.selectors) ??
+			HAMT.get(stateKey, core.readonlySelectors)
+		if (!state) {
+			store.config.logger?.info(
+				`   || ${stateKey} is an atom, and can't be downstream`,
+			)
+			return
+		}
+		evictCachedValue(stateKey, store)
+		store.config.logger?.info(`   xx evicted "${stateKey}"`)
 
-    markDone(stateKey, store)
-  })
+		markDone(stateKey, store)
+	})
 }
 
 export const setAtomState = <T>(
-  atom: Atom<T>,
-  next: T | ((oldValue: T) => T),
-  store: Store = IMPLICIT.STORE
+	atom: Atom<T>,
+	next: T | ((oldValue: T) => T),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const oldValue = getState__INTERNAL(atom, store)
-  const newValue = become(next)(oldValue)
-  store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
-  cacheValue(atom.key, newValue, store)
-  if (isAtomDefault(atom.key, store)) {
-    markAtomAsNotDefault(atom.key, store)
-  }
-  markDone(atom.key, store)
-  store.config.logger?.info(
-    `   || evicting caches downstream from "${atom.key}"`
-  )
-  evictDownStream(atom, store)
-  const update = { oldValue, newValue }
-  if (store.transactionStatus.phase !== `building`) {
-    emitUpdate(atom, update, store)
-  } else {
-    stowUpdate(atom, update, store)
-  }
+	const oldValue = getState__INTERNAL(atom, store)
+	const newValue = become(next)(oldValue)
+	store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
+	cacheValue(atom.key, newValue, store)
+	if (isAtomDefault(atom.key, store)) {
+		markAtomAsNotDefault(atom.key, store)
+	}
+	markDone(atom.key, store)
+	store.config.logger?.info(
+		`   || evicting caches downstream from "${atom.key}"`,
+	)
+	evictDownStream(atom, store)
+	const update = { oldValue, newValue }
+	if (store.transactionStatus.phase !== `building`) {
+		emitUpdate(atom, update, store)
+	} else {
+		stowUpdate(atom, update, store)
+	}
 }
 export const setSelectorState = <T>(
-  selector: Selector<T>,
-  next: T | ((oldValue: T) => T),
-  store: Store = IMPLICIT.STORE
+	selector: Selector<T>,
+	next: T | ((oldValue: T) => T),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const oldValue = getState__INTERNAL(selector, store)
-  const newValue = become(next)(oldValue)
+	const oldValue = getState__INTERNAL(selector, store)
+	const newValue = become(next)(oldValue)
 
-  store.config.logger?.info(`<< setting selector "${selector.key}" to`, newValue)
-  store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
+	store.config.logger?.info(`<< setting selector "${selector.key}" to`, newValue)
+	store.config.logger?.info(`   || propagating change made to "${selector.key}"`)
 
-  selector.set(newValue)
+	selector.set(newValue)
 }
 export const setState__INTERNAL = <T>(
-  state: Atom<T> | Selector<T>,
-  value: T | ((oldValue: T) => T),
-  store: Store = IMPLICIT.STORE
+	state: Atom<T> | Selector<T>,
+	value: T | ((oldValue: T) => T),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  if (`set` in state) {
-    setSelectorState(state, value, store)
-  } else {
-    setAtomState(state, value, store)
-  }
+	if (`set` in state) {
+		setSelectorState(state, value, store)
+	} else {
+		setAtomState(state, value, store)
+	}
 }