atom.io 0.33.20 → 0.34.0

package/src/internal/selector/create-writable-held-selector.ts

@@ -29,8 +29,18 @@ export const createWritableHeldSelector = <T extends object>(
 	const getterToolkit = { find, get, json }
 
 	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
+			downstreamSelectorKey: key,
+		})
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) {
+			if (source !== key) {
+				innerTarget.selectorGraph.delete(downstreamSelectorKey, key)
+			}
+		}
+		innerTarget.selectorAtoms.delete(key)
 		getFn(getterToolkit, constant)
 		cacheValue(innerTarget, key, constant, subject)
+		store.logger.info(`✨`, type, key, `=`, constant)
 		covered.clear()
 		return constant
 	}
@@ -57,8 +67,7 @@ export const createWritableHeldSelector = <T extends object>(
 		...(family && { family }),
 	}
 	target.writableSelectors.set(key, mySelector)
-	const initialValue = getSelf()
-	store.logger.info(`✨`, type, key, `=`, initialValue)
+	// const initialValue = getSelf()
 
 	const token: WritableHeldSelectorToken<T> = { key, type }
 	if (family) {

package/src/internal/selector/create-writable-pure-selector.ts

@@ -29,8 +29,18 @@ export const createWritablePureSelector = <T>(
 	const getterToolkit = { find, get, json }
 
 	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
+		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
+			downstreamSelectorKey: key,
+		})
+		for (const [downstreamSelectorKey, { source }] of upstreamStates) {
+			if (source !== key) {
+				innerTarget.selectorGraph.delete(downstreamSelectorKey, key)
+			}
+		}
+		innerTarget.selectorAtoms.delete(key)
 		const value = getFn(getterToolkit)
-		cacheValue(innerTarget, key, value, subject)
+		const cached = cacheValue(innerTarget, key, value, subject)
+		store.logger.info(`✨`, type, key, `=`, cached)
 		covered.clear()
 		return value
 	}

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

@@ -1,51 +1,29 @@
-import type { Atom, Selector, Store } from ".."
-import type { AtomKey, StateKey } from "../keys"
+import type { Atom, Store } from ".."
 import { isAtomKey } from "../keys"
 import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
 
-export const traceSelectorAtoms = (
+export const traceRootSelectorAtoms = (
 	store: Store,
-	directDependencyKey: StateKey<unknown>,
-	covered: Set<string>,
-): AtomKey<unknown>[] => {
-	const rootKeys: AtomKey<unknown>[] = []
+	selectorKey: string,
+	covered: Set<string> = new Set<string>(),
+): Map<string, Atom<unknown>> => {
+	const dependencies = getSelectorDependencyKeys(store, selectorKey)
 
-	const indirectDependencyKeys = getSelectorDependencyKeys(
-		store,
-		directDependencyKey,
-	)
-	while (indirectDependencyKeys.length > 0) {
+	const roots = new Map<string, Atom<unknown>>()
+
+	while (dependencies.length > 0) {
 		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
-		const indirectDependencyKey = indirectDependencyKeys.shift()!
-		if (covered.has(indirectDependencyKey)) {
+		const dependencyKey = dependencies.pop()!
+		if (covered.has(dependencyKey)) {
 			continue
 		}
-		covered.add(indirectDependencyKey)
-
-		if (!isAtomKey(store, indirectDependencyKey)) {
-			indirectDependencyKeys.push(
-				...getSelectorDependencyKeys(store, indirectDependencyKey),
-			)
-		} else if (!rootKeys.includes(indirectDependencyKey)) {
-			rootKeys.push(indirectDependencyKey)
+		covered.add(dependencyKey)
+		if (isAtomKey(store, dependencyKey)) {
+			const atom = store.atoms.get(dependencyKey) as Atom<unknown>
+			roots.set(atom.key, atom)
+		} else {
+			dependencies.push(...getSelectorDependencyKeys(store, dependencyKey))
 		}
 	}
-
-	return rootKeys
-}
-
-export const traceAllSelectorAtoms = (
-	selector: Selector<any>,
-	store: Store,
-): Atom<unknown>[] => {
-	const selectorKey = selector.key
-	const directDependencyKeys = getSelectorDependencyKeys(store, selectorKey)
-	const covered = new Set<string>()
-	return directDependencyKeys
-		.flatMap((depKey) =>
-			isAtomKey(store, depKey)
-				? depKey
-				: traceSelectorAtoms(store, depKey, covered),
-		)
-		.map((atomKey) => store.atoms.get(atomKey) as Atom<unknown>)
+	return roots
 }

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

@@ -2,7 +2,7 @@ import type { ReadonlyPureSelectorToken, WritableToken } from "atom.io"
 
 import { newest } from "../lineage"
 import type { Store } from "../store"
-import { traceSelectorAtoms } from "./trace-selector-atoms"
+import { traceRootSelectorAtoms } from "./trace-selector-atoms"
 
 export const updateSelectorAtoms = (
 	store: Store,
@@ -29,16 +29,16 @@ export const updateSelectorAtoms = (
 			`discovers root atom "${dependencyKey}"`,
 		)
 	} else {
-		const rootKeys = traceSelectorAtoms(store, dependencyKey, covered)
+		const rootKeys = traceRootSelectorAtoms(store, dependencyKey, covered)
 		store.logger.info(
 			`🔍`,
 			selectorType,
 			selectorKey,
-			`discovers root atoms: [ ${rootKeys
-				.map((key) => `"${key}"`)
+			`discovers root atoms: [ ${[...rootKeys.values()]
+				.map((root) => `"${root.key}"`)
 				.join(`, `)} ]`,
 		)
-		for (const atomKey of rootKeys) {
+		for (const { key: atomKey } of rootKeys.values()) {
 			target.selectorAtoms = target.selectorAtoms.set({
 				selectorKey,
 				atomKey,

package/src/internal/set-state/evict-downstream.ts

@@ -29,7 +29,7 @@ export function evictDownStream(store: Store, atom: Atom<any>): void {
 			if (isDone(target, key)) {
 				continue
 			}
-			evictCachedValue(key, target)
+			evictCachedValue(target, key)
 			markDone(target, key)
 		}
 	}
@@ -49,7 +49,7 @@ export function evictDownStreamFromSelector(
 		if (isDone(target, downstreamSelectorKey)) {
 			continue
 		}
-		evictCachedValue(downstreamSelectorKey, target)
+		evictCachedValue(target, downstreamSelectorKey)
 		markDone(target, downstreamSelectorKey)
 	}
 }

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -1,5 +1,5 @@
 import type { Atom, WritableState } from ".."
-import { traceAllSelectorAtoms } from ".."
+import { traceRootSelectorAtoms } from ".."
 import type { Store } from "../store"
 import { setAtom } from "./set-atom"
 
@@ -23,8 +23,8 @@ export function resetAtomOrSelector(
 		case `writable_pure_selector`:
 		case `writable_held_selector`:
 			{
-				const atoms = traceAllSelectorAtoms(state, store)
-				for (const atom of atoms) {
+				const atoms = traceRootSelectorAtoms(store, state.key)
+				for (const atom of atoms.values()) {
 					resetAtom(store, atom)
 				}
 			}

package/src/internal/store/store.ts

@@ -193,7 +193,6 @@ export class Store implements Lineage {
 			...config,
 		}
 		if (store !== null) {
-			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
 			if (isRootStore(store)) {
 				this.transactionMeta = {

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

@@ -1,46 +1,50 @@
-import type { Selector } from ".."
+import type { Atom, Selector } from ".."
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
-import { newest } from "../lineage"
-import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { recallState } from "./recall-state"
 
-export const subscribeToRootAtoms = <T>(
-	store: Store,
-	selector: Selector<T>,
-): (() => void)[] => {
-	const target = newest(store)
-	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
-		(atom) => {
-			return atom.subject.subscribe(
-				`${selector.type}:${selector.key}`,
-				(atomChange) => {
-					store.logger.info(
-						`📢`,
-						selector.type,
-						selector.key,
-						`root`,
-						atom.key,
-						`went`,
-						atomChange.oldValue,
-						`->`,
-						atomChange.newValue,
-					)
-					const oldValue = recallState(target, selector)
-					const newValue = readOrComputeValue(target, selector)
-					store.logger.info(
-						`✨`,
-						selector.type,
-						selector.key,
-						`went`,
-						oldValue,
-						`->`,
-						newValue,
-					)
-					selector.subject.next({ newValue, oldValue })
-				},
+export const subscribeToRootDependency = (
+	target: Store,
+	selector: Selector<any>,
+	atom: Atom<any>,
+): (() => void) => {
+	return atom.subject.subscribe(
+		`${selector.type}:${selector.key}`,
+		(atomChange) => {
+			target.logger.info(
+				`📢`,
+				selector.type,
+				selector.key,
+				`root`,
+				atom.key,
+				`went`,
+				atomChange.oldValue,
+				`->`,
+				atomChange.newValue,
 			)
+			const oldValue = recallState(target, selector)
+			const newValue = readOrComputeValue(target, selector)
+			target.logger.info(
+				`✨`,
+				selector.type,
+				selector.key,
+				`went`,
+				oldValue,
+				`->`,
+				newValue,
+			)
+			selector.subject.next({ newValue, oldValue })
 		},
 	)
-	return dependencySubscriptions
 }
+
+// export const subscribeToRootAtoms = (
+// 	store: Store,
+// 	selector: Selector<any>,
+// ): (() => void)[] => {
+// 	const target = newest(store)
+// 	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
+// 		(atom) => subscribeToRootDependency(target, selector, atom),
+// 	)
+// 	return dependencySubscriptions
+// }

package/src/internal/subscribe/subscribe-to-state.ts

@@ -1,8 +1,10 @@
 import type { ReadableToken, StateUpdate, UpdateHandler } from "atom.io"
 
+import { readOrComputeValue } from "../get-state"
+import { traceRootSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { withdraw } from "../store"
-import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"
+import { subscribeToRootDependency } from "./subscribe-to-root-atoms"
 
 export function subscribeToState<T>(
 	store: Store,
@@ -28,14 +30,26 @@ export function subscribeToState<T>(
 	const isSelector =
 		state.type === `writable_pure_selector` ||
 		state.type === `readonly_pure_selector`
-	let dependencyUnsubFunctions: (() => void)[] | null = null
+	const rootSubs = new Map<string, () => void>()
 	let updateHandler: UpdateHandler<T> = safelyHandleUpdate
 	if (isSelector) {
-		dependencyUnsubFunctions = subscribeToRootAtoms(store, state)
-		updateHandler = (update) => {
-			if (dependencyUnsubFunctions) {
-				dependencyUnsubFunctions.length = 0
-				dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state))
+		readOrComputeValue(store, state)
+		for (const [atomKey, atom] of traceRootSelectorAtoms(store, state.key)) {
+			rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom))
+		}
+		updateHandler = function updateRootsBeforeHandlingUpdate(update) {
+			const dependencies = traceRootSelectorAtoms(store, state.key)
+			for (const [previousRootKey, unsub] of rootSubs) {
+				const currentRoot = dependencies.get(previousRootKey)
+				if (currentRoot) {
+					dependencies.delete(previousRootKey)
+				} else {
+					unsub()
+					rootSubs.delete(previousRootKey)
+				}
+			}
+			for (const [atomKey, atom] of dependencies) {
+				rootSubs.set(atomKey, subscribeToRootDependency(store, state, atom))
 			}
 			safelyHandleUpdate(update)
 		}
@@ -49,10 +63,8 @@ export function subscribeToState<T>(
 			`Removing subscription "${key}"`,
 		)
 		mainUnsubFunction()
-		if (dependencyUnsubFunctions) {
-			for (const unsubFromDependency of dependencyUnsubFunctions) {
-				unsubFromDependency()
-			}
+		for (const unsubFromDependency of rootSubs.values()) {
+			unsubFromDependency()
 		}
 	}
 

package/src/react/use-loadable.ts

@@ -31,7 +31,7 @@ export function useLoadable(
 		| readonly [ReadableToken<any>, unknown]
 		| readonly [ReadableToken<any>]
 ): `LOADING` | { loading: boolean; value: unknown } {
-	let loadable: ReadableToken<any>
+	let state: unknown
 	let fallback: unknown
 
 	const [token] = params
@@ -43,7 +43,7 @@ export function useLoadable(
 		case `readonly_pure_selector`:
 		case `writable_held_selector`:
 		case `writable_pure_selector`:
-			loadable = useO(token)
+			state = useO(token)
 			fallback = params[1]
 			break
 		case `atom_family`:
@@ -53,27 +53,32 @@ export function useLoadable(
 		case `writable_held_selector_family`:
 		case `writable_pure_selector_family`:
 			key = params[1] as Canonical
-			loadable = useO(token, key)
+			state = useO(token, key)
 			fallback = params[2]
 	}
 
+	const wrapperRef = React.useRef({ loading: false, value: null as unknown })
 	const lastLoadedRef = React.useRef(
-		fallback ?? (loadable instanceof Promise ? `LOADING` : loadable),
+		fallback ?? (state instanceof Promise ? `LOADING` : state),
 	)
+
 	const { current: lastLoaded } = lastLoadedRef
-	if (loadable instanceof Promise) {
+	let { current: wrapper } = wrapperRef
+
+	if (state instanceof Promise) {
 		if (lastLoaded === `LOADING`) {
 			return `LOADING`
 		}
-		return {
-			loading: true,
-			value: lastLoaded,
+		wrapper = wrapperRef.current = { loading: true, value: lastLoaded }
+	} else {
+		lastLoadedRef.current = state
+		if (wrapper.loading === true) {
+			wrapper = wrapperRef.current = { loading: false, value: state }
+		} else {
+			wrapper.loading = false
+			wrapper.value = state
 		}
 	}
 
-	lastLoadedRef.current = loadable
-	return {
-		loading: false,
-		value: loadable,
-	}
+	return wrapper
 }

package/src/realtime-client/realtime-client-stores/client-sync-store.ts

@@ -4,12 +4,12 @@ export const optimisticUpdateQueue: AtomIO.RegularAtomToken<
 	AtomIO.TransactionUpdate<any>[]
 > = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
 	key: `updateQueue`,
-	default: [],
+	default: () => [],
 })
 
 export const confirmedUpdateQueue: AtomIO.RegularAtomToken<
 	AtomIO.TransactionUpdate<any>[]
 > = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
 	key: `serverConfirmedUpdateQueue`,
-	default: [],
+	default: () => [],
 })

package/src/realtime-testing/setup-realtime-test.tsx

@@ -192,11 +192,6 @@ export const setupRealtimeTestClient = (
 			auth: { token: `test`, username: `${name}-${testNumber}` },
 		})
 		const silo = new AtomIO.Silo({ name, lifespan: `ephemeral` }, IMPLICIT.STORE)
-		for (const [key, value] of silo.store.valueMap.entries()) {
-			if (Array.isArray(value)) {
-				silo.store.valueMap.set(key, [...value])
-			}
-		}
 		silo.setState(RTC.myUsernameState, `${name}-${testNumber}`)
 
 		const { document } = new Happy.Window()