atom.io 0.9.9 → 0.9.10

package/internal/src/atom/is-default.ts

@@ -32,6 +32,6 @@ export const isSelectorDefault = (
 	key: string,
 	store: Store = IMPLICIT.STORE,
 ): boolean => {
-	const roots = traceAllSelectorAtoms(key, store)
-	return roots.every((root) => isAtomDefault(root.key, store))
+	const rootKeys = traceAllSelectorAtoms(key, store)
+	return rootKeys.every((rootKey) => isAtomDefault(rootKey, store))
 }

package/internal/src/caching.ts

@@ -27,10 +27,12 @@ export const cacheValue = (
 				subject.next({ newValue: value, oldValue: value })
 			})
 			.catch((error) => {
-				store.config.logger?.error(
-					`Promised value for "${key}" rejected:`,
-					error,
-				)
+				if (error !== `canceled`) {
+					store.config.logger?.error(
+						`Promised value for "${key}" rejected:`,
+						error,
+					)
+				}
 			})
 	} else {
 		target(store).valueMap.set(key, value)

package/internal/src/index.ts

@@ -3,6 +3,7 @@ export * from "./caching"
 export * from "./families"
 export * from "./future"
 export * from "./get-state-internal"
+export * from "./keys"
 export * from "./operation"
 export * from "./mutable"
 export * from "./selector"

package/internal/src/keys.ts

@@ -0,0 +1,30 @@
+import type { Store } from "./store"
+import { target } from "./transaction"
+
+export type AtomKey<T> = string & { __atomKey?: never; __brand?: T }
+export type SelectorKey<T> = string & { __selectorKey?: never; __brand?: T }
+export type ReadonlySelectorKey<T> = string & {
+	__readonlySelectorKey?: never
+	__brand?: T
+}
+
+export const isAtomKey = (key: string, store: Store): key is AtomKey<unknown> =>
+	target(store).atoms.has(key)
+export const isSelectorKey = (
+	key: string,
+	store: Store,
+): key is SelectorKey<unknown> => target(store).selectors.has(key)
+export const isReadonlySelectorKey = (
+	key: string,
+	store: Store,
+): key is ReadonlySelectorKey<unknown> =>
+	target(store).readonlySelectors.has(key)
+
+export type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>
+export const isStateKey = (
+	key: string,
+	store: Store,
+): key is StateKey<unknown> =>
+	isAtomKey(key, store) ||
+	isSelectorKey(key, store) ||
+	isReadonlySelectorKey(key, store)

package/internal/src/selector/get-selector-dependency-keys.ts

@@ -0,0 +1,20 @@
+import type { AtomKey, ReadonlySelectorKey, SelectorKey } from "../keys"
+import { isStateKey } from "../keys"
+import type { Store } from "../store"
+import { target } from "../transaction"
+
+export const getSelectorDependencyKeys = (
+	key: string,
+	store: Store,
+): (
+	| AtomKey<unknown>
+	| ReadonlySelectorKey<unknown>
+	| SelectorKey<unknown>
+)[] => {
+	const sources = target(store)
+		.selectorGraph.getRelationEntries({ downstreamSelectorKey: key })
+		.filter(([_, { source }]) => source !== key)
+		.map(([_, { source }]) => source)
+		.filter((source) => isStateKey(source, store))
+	return sources
+}

package/internal/src/selector/index.ts

@@ -1,4 +1,4 @@
-export * from "./lookup-selector-sources"
+export * from "./get-selector-dependency-keys"
 export * from "./register-selector"
 export * from "./create-selector"
 export * from "./trace-selector-atoms"

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

@@ -1,50 +1,50 @@
-import type { AtomToken, ReadonlySelectorToken, StateToken } from "atom.io"
-
 import type { Store } from ".."
-import { lookupSelectorSources } from "./lookup-selector-sources"
+import type { AtomKey, StateKey } from "../keys"
+import { isAtomKey } from "../keys"
+import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
 
 export const traceSelectorAtoms = (
 	selectorKey: string,
-	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	directDependencyKey: StateKey<unknown>,
 	store: Store,
-): AtomToken<unknown>[] => {
-	const roots: AtomToken<unknown>[] = []
+): AtomKey<unknown>[] => {
+	const rootKeys: AtomKey<unknown>[] = []
 
-	const sources = lookupSelectorSources(dependency.key, store)
+	const indirectDependencyKeys = getSelectorDependencyKeys(
+		directDependencyKey,
+		store,
+	)
 	let depth = 0
-	while (sources.length > 0) {
+	while (indirectDependencyKeys.length > 0) {
 		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
-		const source = sources.shift()!
+		const indirectDependencyKey = indirectDependencyKeys.shift()!
 		++depth
-		if (depth > 999) {
-			store.config.logger?.warn(
-				`Maximum selector dependency depth exceeded 999 in selector "${selectorKey}".`,
-			)
-		}
 		if (depth > 99999) {
 			throw new Error(
-				`Maximum selector dependency depth exceeded in selector "${selectorKey}".`,
+				`Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`,
 			)
 		}
 
-		if (source.type !== `atom`) {
-			sources.push(...lookupSelectorSources(source.key, store))
-		} else {
-			roots.push(source)
+		if (!isAtomKey(indirectDependencyKey, store)) {
+			indirectDependencyKeys.push(
+				...getSelectorDependencyKeys(indirectDependencyKey, store),
+			)
+		} else if (!rootKeys.includes(indirectDependencyKey)) {
+			rootKeys.push(indirectDependencyKey)
 		}
 	}
 
-	return roots
+	return rootKeys
 }
 
 export const traceAllSelectorAtoms = (
 	selectorKey: string,
 	store: Store,
-): AtomToken<unknown>[] => {
-	const sources = lookupSelectorSources(selectorKey, store)
-	return sources.flatMap((source) =>
-		source.type === `atom`
-			? source
-			: traceSelectorAtoms(selectorKey, source, store),
+): AtomKey<unknown>[] => {
+	const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store)
+	return directDependencyKeys.flatMap((depKey) =>
+		isAtomKey(depKey, store)
+			? depKey
+			: traceSelectorAtoms(selectorKey, depKey, store),
 	)
 }

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

@@ -20,15 +20,15 @@ export const updateSelectorAtoms = (
 		)
 		return
 	}
-	const roots = traceSelectorAtoms(selectorKey, dependency, store)
+	const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store)
 	store.config.logger?.info(
 		`   || adding roots for "${selectorKey}":`,
-		roots.map((r) => r.key),
+		rootKeys.map((r) => r),
 	)
-	for (const root of roots) {
+	for (const atomKey of rootKeys) {
 		core.selectorAtoms = core.selectorAtoms.set({
 			selectorKey,
-			atomKey: root.key,
+			atomKey,
 		})
 	}
 }

package/internal/src/store/index.ts

@@ -1,5 +1,4 @@
 export * from "./deposit"
-export * from "./lookup"
 export * from "./store"
 export * from "./withdraw"
 export * from "./withdraw-new-family-member"

package/internal/src/subscribe/subscribe-to-root-atoms.ts

@@ -2,7 +2,6 @@ import { getState__INTERNAL } from "../get-state-internal"
 import type { ReadonlySelector, Selector } from "../selector"
 import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
-import { withdraw } from "../store"
 import { recallState } from "./recall-state"
 
 export const subscribeToRootAtoms = <T>(
@@ -12,18 +11,18 @@ export const subscribeToRootAtoms = <T>(
 	const dependencySubscriptions =
 		`default` in state
 			? null
-			: traceAllSelectorAtoms(state.key, store).map((atomToken) => {
-					const atom = withdraw(atomToken, store)
+			: traceAllSelectorAtoms(state.key, store).map((atomKey) => {
+					const atom = store.atoms.get(atomKey)
 					if (atom === undefined) {
 						throw new Error(
-							`Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
+							`Atom "${atomKey}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
 						)
 					}
 					return atom.subject.subscribe(
 						`${state.type}:${state.key}`,
 						(atomChange) => {
 							store.config.logger?.info(
-								`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
+								`📢 selector "${state.key}" saw root "${atomKey}" go (`,
 								atomChange.oldValue,
 								`->`,
 								atomChange.newValue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -55,7 +55,7 @@
     "@types/tmp": "0.2.6",
     "@vitest/coverage-v8": "0.34.6",
     "concurrently": "8.2.2",
-    "eslint": "8.53.0",
+    "eslint": "8.54.0",
     "framer-motion": "10.16.5",
     "happy-dom": "12.10.3",
     "npmlog": "7.0.1",

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

@@ -1,20 +0,0 @@
-import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "atom.io"
-
-import type { Store } from "../store"
-import { lookup } from "../store"
-import { target } from "../transaction"
-
-export const lookupSelectorSources = (
-	key: string,
-	store: Store,
-): (
-	| AtomToken<unknown>
-	| ReadonlySelectorToken<unknown>
-	| SelectorToken<unknown>
-)[] => {
-	const sources = target(store)
-		.selectorGraph.getRelationEntries({ downstreamSelectorKey: key })
-		.filter(([_, { source }]) => source !== key)
-		.map(([_, { source }]) => lookup(source, store))
-	return sources
-}

package/internal/src/store/lookup.ts

@@ -1,26 +0,0 @@
-import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "atom.io"
-
-import { target } from "../transaction"
-import type { Store } from "./store"
-
-export function lookup(
-	key: string,
-	store: Store,
-): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown> {
-	const core = target(store)
-	let type: string = core.atoms.has(key)
-		? `atom`
-		: core.selectors.has(key)
-		? `selector`
-		: core.readonlySelectors.has(key)
-		? `readonly_selector`
-		: ``
-	if (!type) {
-		const errorId = Math.random().toString(36)
-		type = `🚨 This state could not be found by lookup! Check the console for "${errorId}"`
-		store.config.logger?.error(
-			`${errorId}: Key "${key}" does not exist in the store.`,
-		)
-	}
-	return { key, type } as any
-}