atom.io 0.6.2 → 0.6.4

package/src/internal/operation.ts

@@ -8,138 +8,138 @@ import { IMPLICIT } from "./store"
 import type { StateToken } from ".."
 
 export type OperationProgress =
-  | {
-      open: false
-    }
-  | {
-      open: true
-      done: Set<string>
-      prev: Hamt<any, string>
-      time: number
-      token: StateToken<any>
-    }
+	| {
+			open: false
+	  }
+	| {
+			open: true
+			done: Set<string>
+			prev: Hamt<any, string>
+			time: number
+			token: StateToken<any>
+	  }
 
 export const openOperation = (token: StateToken<any>, store: Store): void => {
-  const core = target(store)
-  if (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 from "${token.key}" in store "${store.config.name}"`
-  )
+	const core = target(store)
+	if (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 from "${token.key}" in store "${store.config.name}"`,
+	)
 }
 export const closeOperation = (store: Store): void => {
-  const core = target(store)
-  core.operation = { open: false }
-  store.config.logger?.info(`🔴 operation done`)
+	const core = target(store)
+	core.operation = { open: false }
+	store.config.logger?.info(`🔴 operation done`)
 }
 
 export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
-  const core = target(store)
-  if (!core.operation.open) {
-    store.config.logger?.warn(
-      `isDone called outside of an operation. This is probably a bug.`
-    )
-    return true
-  }
-  return core.operation.done.has(key)
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`isDone called outside of an operation. This is probably a bug.`,
+		)
+		return true
+	}
+	return core.operation.done.has(key)
 }
 export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
-  const core = target(store)
-  if (!core.operation.open) {
-    store.config.logger?.warn(
-      `markDone called outside of an operation. This is probably a bug.`
-    )
-    return
-  }
-  core.operation.done.add(key)
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`markDone called outside of an operation. This is probably a bug.`,
+		)
+		return
+	}
+	core.operation.done.add(key)
 }
 export const recallState = <T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  store: Store = IMPLICIT.STORE
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	store: Store = IMPLICIT.STORE,
 ): T => {
-  const core = target(store)
-  if (!core.operation.open) {
-    store.config.logger?.warn(
-      `recall called outside of an operation. This is probably a bug.`
-    )
-    return HAMT.get(state.key, core.valueMap)
-  }
-  return HAMT.get(state.key, core.operation.prev)
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`recall called outside of an operation. This is probably a bug.`,
+		)
+		return HAMT.get(state.key, core.valueMap)
+	}
+	return HAMT.get(state.key, core.operation.prev)
 }
 
 export const cacheValue = (
-  key: string,
-  value: unknown,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	value: unknown,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.valueMap = HAMT.set(key, value, core.valueMap)
+	const core = target(store)
+	core.valueMap = HAMT.set(key, value, core.valueMap)
 }
 
 export const evictCachedValue = (
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.valueMap = HAMT.remove(key, core.valueMap)
+	const core = target(store)
+	core.valueMap = HAMT.remove(key, core.valueMap)
 }
 export const readCachedValue = <T>(
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): T => HAMT.get(key, target(store).valueMap)
 
 export const isValueCached = (
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): boolean => HAMT.has(key, target(store).valueMap)
 
 export const storeAtom = (
-  atom: Atom<any>,
-  store: Store = IMPLICIT.STORE
+	atom: Atom<any>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.atoms = HAMT.set(atom.key, atom, core.atoms)
+	const core = target(store)
+	core.atoms = HAMT.set(atom.key, atom, core.atoms)
 }
 
 export const storeSelector = (
-  selector: Selector<any>,
-  store: Store = IMPLICIT.STORE
+	selector: Selector<any>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.selectors = HAMT.set(selector.key, selector, core.selectors)
+	const core = target(store)
+	core.selectors = HAMT.set(selector.key, selector, core.selectors)
 }
 
 export const storeReadonlySelector = (
-  selector: ReadonlySelector<any>,
-  store: Store = IMPLICIT.STORE
+	selector: ReadonlySelector<any>,
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  const core = target(store)
-  core.readonlySelectors = HAMT.set(
-    selector.key,
-    selector,
-    core.readonlySelectors
-  )
+	const core = target(store)
+	core.readonlySelectors = HAMT.set(
+		selector.key,
+		selector,
+		core.readonlySelectors,
+	)
 }
 
 export const hasKeyBeenUsed = (
-  key: string,
-  store: Store = IMPLICIT.STORE
+	key: string,
+	store: Store = IMPLICIT.STORE,
 ): boolean => {
-  const core = target(store)
-  return (
-    HAMT.has(key, core.atoms) ||
-    HAMT.has(key, core.selectors) ||
-    HAMT.has(key, core.readonlySelectors)
-  )
+	const core = target(store)
+	return (
+		HAMT.has(key, core.atoms) ||
+		HAMT.has(key, core.selectors) ||
+		HAMT.has(key, core.readonlySelectors)
+	)
 }

package/src/internal/selector/create-read-write-selector.ts

@@ -1,62 +1,62 @@
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
 
 import { become } from "~/packages/anvl/src/function"
 
+import { Subject } from ".."
 import {
-  type Store,
-  type Selector,
-  type StoreCore,
-  registerSelector,
-  selector__INTERNAL,
+	type Store,
+	type Selector,
+	type StoreCore,
+	registerSelector,
+	selector__INTERNAL,
 } from ".."
 import type { FamilyMetadata, SelectorToken } from "../.."
 import type { SelectorOptions } from "../../selector"
 import { cacheValue, markDone } from "../operation"
 
 export const createReadWriteSelector = <T>(
-  options: SelectorOptions<T>,
-  family: FamilyMetadata | undefined,
-  store: Store,
-  core: StoreCore
+	options: SelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+	store: Store,
+	core: StoreCore,
 ): SelectorToken<T> => {
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
 
-  const { get, set } = registerSelector(options.key, store)
-  const getSelf = () => {
-    const value = options.get({ get })
-    cacheValue(options.key, value, store)
-    return value
-  }
+	const { get, set } = registerSelector(options.key, store)
+	const getSelf = () => {
+		const value = options.get({ get })
+		cacheValue(options.key, value, store)
+		return value
+	}
 
-  const setSelf = (next: T | ((oldValue: T) => T)): void => {
-    store.config.logger?.info(`   <- "${options.key}" became`, next)
-    const oldValue = getSelf()
-    const newValue = become(next)(oldValue)
-    cacheValue(options.key, newValue, store)
-    markDone(options.key, store)
-    if (store.transactionStatus.phase === `idle`) {
-      subject.next({ newValue, oldValue })
-    }
-    options.set({ get, set }, newValue)
-  }
-  const mySelector: Selector<T> = {
-    ...options,
-    subject,
-    install: (s: Store) => selector__INTERNAL(options, family, s),
-    get: getSelf,
-    set: setSelf,
-    type: `selector`,
-    ...(family && { family }),
-  }
-  core.selectors = HAMT.set(options.key, mySelector, core.selectors)
-  const initialValue = getSelf()
-  store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  const token: SelectorToken<T> = {
-    key: options.key,
-    type: `selector`,
-    family,
-  }
-  store.subject.selectorCreation.next(token)
-  return token
+	const setSelf = (next: T | ((oldValue: T) => T)): void => {
+		store.config.logger?.info(`   <- "${options.key}" became`, next)
+		const oldValue = getSelf()
+		const newValue = become(next)(oldValue)
+		cacheValue(options.key, newValue, store)
+		markDone(options.key, store)
+		if (store.transactionStatus.phase === `idle`) {
+			subject.next({ newValue, oldValue })
+		}
+		options.set({ get, set }, newValue)
+	}
+	const mySelector: Selector<T> = {
+		...options,
+		subject,
+		install: (s: Store) => selector__INTERNAL(options, family, s),
+		get: getSelf,
+		set: setSelf,
+		type: `selector`,
+		...(family && { family }),
+	}
+	core.selectors = HAMT.set(options.key, mySelector, core.selectors)
+	const initialValue = getSelf()
+	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
+	const token: SelectorToken<T> = {
+		key: options.key,
+		type: `selector`,
+		family,
+	}
+	store.subject.selectorCreation.next(token)
+	return token
 }

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

@@ -1,52 +1,52 @@
 import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
 
 import { registerSelector } from "./register-selector"
+import { Subject } from ".."
 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 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),
+	)
 }