atom.io 0.31.1 → 0.32.0

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

@@ -19,14 +19,10 @@ export const createReadonlySelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
-	const { get, find, seek, json } = registerSelector(
-		options.key,
-		covered,
-		target,
-	)
+	const { get, find, json } = registerSelector(options.key, covered, target)
 	const getSelf = () => {
-		const value = options.get({ get, find, seek, json })
-		cacheValue(options.key, value, subject, newest(store))
+		const value = options.get({ get, find, json })
+		cacheValue(newest(store), options.key, value, subject)
 		covered.clear()
 		return value
 	}

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

@@ -23,12 +23,12 @@ export const createWritableSelector = <T>(
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
 	const setterToolkit = registerSelector(options.key, covered, target)
-	const { find, get, seek, json } = setterToolkit
-	const getterToolkit = { find, get, seek, json }
+	const { find, get, json } = setterToolkit
+	const getterToolkit = { find, get, json }
 
 	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
 		const value = getFn(getterToolkit)
-		cacheValue(options.key, value, subject, innerTarget)
+		cacheValue(innerTarget, options.key, value, subject)
 		covered.clear()
 		return value
 	}
@@ -47,7 +47,7 @@ export const createWritableSelector = <T>(
 			newValue,
 			`)`,
 		)
-		cacheValue(options.key, newValue, subject, innerTarget)
+		cacheValue(innerTarget, options.key, newValue, subject)
 		markDone(innerTarget, options.key)
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })

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

@@ -1,15 +1,15 @@
-import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
+import type { SelectorFamilyToken, SelectorToken } from "atom.io"
 
 import type { Store } from ".."
 import { isChildStore, newest, withdraw } from ".."
 
 export function disposeSelector(
-	selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>,
 	store: Store,
+	selectorToken: SelectorToken<unknown>,
 ): void {
 	const target = newest(store)
 	const { key } = selectorToken
-	const selector = withdraw(selectorToken, target)
+	const selector = withdraw(target, selectorToken)
 	if (!selector.family) {
 		store.logger.error(
 			`❌`,
@@ -22,23 +22,31 @@ export function disposeSelector(
 		if (molecule) {
 			target.moleculeData.delete(selector.family.subKey, selector.family.key)
 		}
+		let familyToken: SelectorFamilyToken<any, any>
 		switch (selectorToken.type) {
 			case `selector`:
 				{
 					target.selectors.delete(key)
-					const family = withdraw(
-						{ key: selector.family.key, type: `selector_family` },
-						store,
-					)
+					familyToken = {
+						key: selector.family.key,
+						type: `selector_family`,
+					}
+					const family = withdraw(store, familyToken)
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken,
+					})
 				}
 				break
 			case `readonly_selector`:
 				{
 					target.readonlySelectors.delete(key)
-					const family = withdraw(
-						{ key: selector.family.key, type: `readonly_selector_family` },
-						store,
-					)
+					familyToken = {
+						key: selector.family.key,
+						type: `readonly_selector_family`,
+					}
+					const family = withdraw(store, familyToken)
 					family.subject.next({
 						type: `state_disposal`,
 						subType: `selector`,
@@ -47,6 +55,7 @@ export function disposeSelector(
 				}
 				break
 		}
+
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
 		target.selectorGraph.delete(key)

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

@@ -15,6 +15,6 @@ export const getSelectorDependencyKeys = (
 		.selectorGraph.getRelationEntries({ downstreamSelectorKey: key })
 		.filter(([_, { source }]) => source !== key)
 		.map(([_, { source }]) => source)
-		.filter((source) => isStateKey(source, store))
+		.filter((source) => isStateKey(store, source))
 	return sources
 }

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

@@ -1,4 +1,5 @@
 import type {
+	findState,
 	ReadableFamilyToken,
 	ReadableToken,
 	setState,
@@ -6,15 +7,12 @@ import type {
 	WritableFamilyToken,
 	WritableToken,
 } from "atom.io"
-import type { findState } from "atom.io/ephemeral"
-import type { seekState } from "atom.io/immortal"
 import type { Json } from "atom.io/json"
 
-import { findInStore, seekInStore } from "../families"
+import { findInStore } from "../families"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
-import { NotFoundError } from "../not-found-error"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
 import { withdraw } from "../store"
@@ -40,8 +38,8 @@ export const registerSelector = (
 			;[dependency] = params
 		}
 
-		const dependencyState = withdraw(dependency, store)
-		const dependencyValue = readOrComputeValue(dependencyState, store)
+		const dependencyState = withdraw(store, dependency)
+		const dependencyValue = readOrComputeValue(store, dependencyState)
 
 		store.logger.info(
 			`🔌`,
@@ -85,10 +83,9 @@ export const registerSelector = (
 			token = findInStore(store, family, key)
 		}
 		const target = newest(store)
-		const state = withdraw(token, target)
-		setAtomOrSelector(state, value, target)
+		const state = withdraw(target, token)
+		setAtomOrSelector(target, state, value)
 	}) as typeof setState,
 	find: ((token, key) => findInStore(store, token, key)) as typeof findState,
-	seek: ((token, key) => seekInStore(store, token, key)) as typeof seekState,
 	json: (token) => getJsonToken(store, token),
 })

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

@@ -22,7 +22,7 @@ export const traceSelectorAtoms = (
 		}
 		covered.add(indirectDependencyKey)
 
-		if (!isAtomKey(indirectDependencyKey, store)) {
+		if (!isAtomKey(store, indirectDependencyKey)) {
 			indirectDependencyKeys.push(
 				...getSelectorDependencyKeys(indirectDependencyKey, store),
 			)
@@ -42,7 +42,7 @@ export const traceAllSelectorAtoms = (
 	const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store)
 	const covered = new Set<string>()
 	return directDependencyKeys.flatMap((depKey) =>
-		isAtomKey(depKey, store)
+		isAtomKey(store, depKey)
 			? depKey
 			: traceSelectorAtoms(depKey, covered, store),
 	)

package/internal/src/set-state/copy-mutable-if-needed.ts

@@ -3,9 +3,9 @@ import { Tracker } from "../mutable"
 import type { Store } from "../store"
 
 export function copyMutableIfNeeded<T extends Transceiver<any>>(
+	target: Store,
 	atom: MutableAtom<T, any>,
 	origin: Store,
-	target: Store,
 ): T {
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)

package/internal/src/set-state/emit-update.ts

@@ -3,9 +3,9 @@ import type { StateUpdate } from "atom.io"
 import type { Atom, Selector, Store } from ".."
 
 export const emitUpdate = <T>(
+	store: Store,
 	state: Atom<T> | Selector<T>,
 	update: StateUpdate<T>,
-	store: Store,
 ): void => {
 	switch (state.type) {
 		case `mutable_atom`:

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

@@ -4,7 +4,7 @@ import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
 
-export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
+export const evictDownStream = <T>(store: Store, atom: Atom<T>): void => {
 	const target = newest(store)
 	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key)
 	target.logger.info(

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

@@ -3,9 +3,9 @@ import type { Store } from "../store"
 import { setAtom } from "./set-atom"
 
 export const setAtomOrSelector = <T>(
+	store: Store,
 	state: WritableState<T>,
 	value: T | ((oldValue: T) => T),
-	store: Store,
 ): void => {
 	switch (state.type) {
 		case `atom`:

package/internal/src/set-state/set-atom.ts

@@ -17,38 +17,38 @@ export const setAtom = <T>(
 	next: T | ((oldValue: T) => T),
 	target: Store,
 ): void => {
-	const oldValue = readOrComputeValue(atom, target)
+	const oldValue = readOrComputeValue(target, atom)
 	let newValue = oldValue
 	if (atom.type === `mutable_atom` && isChildStore(target)) {
 		const { parent } = target
-		const copiedValue = copyMutableIfNeeded(atom, parent, target)
+		const copiedValue = copyMutableIfNeeded(target, atom, parent)
 		newValue = copiedValue
 	}
 	newValue = become(next)(newValue)
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
-	newValue = cacheValue(atom.key, newValue, atom.subject, target)
-	if (isAtomDefault(atom.key, target)) {
-		markAtomAsNotDefault(atom.key, target)
+	newValue = cacheValue(target, atom.key, newValue, atom.subject)
+	if (isAtomDefault(target, atom.key)) {
+		markAtomAsNotDefault(target, atom.key)
 	}
 	markDone(target, atom.key)
-	evictDownStream(atom, target)
+	evictDownStream(target, atom)
 	const update = { oldValue, newValue }
 	if (isRootStore(target)) {
-		emitUpdate(atom, update, target)
+		emitUpdate(target, atom, update)
 	} else if (target.parent) {
 		if (target.on.transactionApplying.state === null) {
-			stowUpdate(atom, update, target)
+			stowUpdate(target, atom, update)
 		} else if (atom.key.startsWith(`*`)) {
 			const mutableKey = atom.key.slice(1)
 			const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
 			let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
 			if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
 				const { parent } = target
-				const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target)
+				const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent)
 				transceiver = copiedValue
 			}
 			const accepted = transceiver.do(update.newValue) === null
-			if (accepted) evictDownStream(mutableAtom, target)
+			if (accepted) evictDownStream(target, mutableAtom)
 		}
 	}
 }

package/internal/src/set-state/set-into-store.ts

@@ -84,7 +84,7 @@ export function setIntoStore<T, New extends T>(
 		)
 		return
 	}
-	const state = withdraw(token, store)
-	setAtomOrSelector(state, value, store)
+	const state = withdraw(store, token)
+	setAtomOrSelector(store, state, value)
 	closeOperation(store)
 }

package/internal/src/set-state/stow-update.ts

@@ -19,9 +19,9 @@ function shouldUpdateBeStowed(key: string, update: StateUpdate<any>): boolean {
 }
 
 export const stowUpdate = <T>(
+	store: Store,
 	state: Atom<T>,
 	update: StateUpdate<T>,
-	store: Store,
 ): void => {
 	const { key } = state
 	const target = newest(store)

package/internal/src/store/store.ts

@@ -9,7 +9,6 @@ import type {
 	WritableSelectorToken,
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
-import type { Join } from "atom.io/data"
 import type { Canonical, stringified } from "atom.io/json"
 
 import type {
@@ -21,6 +20,7 @@ import type {
 	WritableSelector,
 	WritableSelectorFamily,
 } from ".."
+import type { Join } from "../join"
 import { Junction } from "../junction"
 import type { Lineage } from "../lineage"
 import type { Molecule } from "../molecule"

package/internal/src/store/withdraw.ts

@@ -49,95 +49,95 @@ import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
 export function withdraw<T>(
-	token: RegularAtomToken<T>,
 	store: Store,
+	token: RegularAtomToken<T>,
 ): RegularAtom<T>
 export function withdraw<T extends Transceiver<any>>(
-	token: MutableAtomToken<T, any>,
 	store: Store,
+	token: MutableAtomToken<T, any>,
 ): MutableAtom<T, any>
-export function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>
+export function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>
 export function withdraw<T>(
-	token: WritableSelectorToken<T>,
 	store: Store,
+	token: WritableSelectorToken<T>,
 ): WritableSelector<T>
 export function withdraw<T>(
-	token: ReadonlySelectorToken<T>,
 	store: Store,
+	token: ReadonlySelectorToken<T>,
 ): ReadonlySelector<T>
-export function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>
+export function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>
 export function withdraw<T>(
-	token: WritableToken<T>,
 	store: Store,
+	token: WritableToken<T>,
 ): WritableState<T>
 export function withdraw<T>(
-	token: ReadableToken<T>,
 	store: Store,
+	token: ReadableToken<T>,
 ): ReadableState<T>
 
 export function withdraw<T, K extends Canonical>(
-	token: RegularAtomFamilyToken<T, K>,
 	store: Store,
+	token: RegularAtomFamilyToken<T, K>,
 ): RegularAtomFamily<T, K>
 export function withdraw<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	token: MutableAtomFamilyToken<T, J, K>,
 	store: Store,
+	token: MutableAtomFamilyToken<T, J, K>,
 ): MutableAtomFamily<T, J, K>
 export function withdraw<T, K extends Canonical>(
-	token: AtomFamilyToken<T>,
 	store: Store,
+	token: AtomFamilyToken<T>,
 ): AtomFamily<T, any>
 export function withdraw<T, K extends Canonical>(
-	token: ReadonlySelectorFamilyToken<T, K>,
 	store: Store,
+	token: ReadonlySelectorFamilyToken<T, K>,
 ): ReadonlySelectorFamily<T, any>
 export function withdraw<T, K extends Canonical>(
-	token: WritableSelectorFamilyToken<T, K>,
 	store: Store,
+	token: WritableSelectorFamilyToken<T, K>,
 ): WritableSelectorFamily<T, any>
 export function withdraw<T, K extends Canonical>(
-	token: SelectorFamilyToken<T, K>,
 	store: Store,
+	token: SelectorFamilyToken<T, K>,
 ): SelectorFamily<T, any>
 export function withdraw<T, K extends Canonical>(
-	token: ReadableFamilyToken<T, K>,
 	store: Store,
+	token: ReadableFamilyToken<T, K>,
 ): ReadableFamily<T, any>
 export function withdraw<T, K extends Canonical>(
-	token: WritableFamilyToken<T, K>,
 	store: Store,
+	token: WritableFamilyToken<T, K>,
 ): WritableFamily<T, any>
 
 export function withdraw<T extends Func>(
-	token: TransactionToken<T>,
 	store: Store,
+	token: TransactionToken<T>,
 ): Transaction<T extends Func ? T : never>
 export function withdraw<T>(
-	token: TimelineToken<T>,
 	store: Store,
+	token: TimelineToken<T>,
 ): Timeline<T extends TimelineManageable ? T : never>
 
 export function withdraw<T>(
-	token: WritableToken<T>,
 	store: Store,
+	token: WritableToken<T>,
 ): WritableState<T>
 export function withdraw<T>(
-	token: ReadableToken<T>,
 	store: Store,
+	token: ReadableToken<T>,
 ): ReadableState<T>
 
 export function withdraw(
-	token: AtomIOToken,
 	store: Store,
+	token: AtomIOToken,
 ): AtomIOInternalResource
 
 export function withdraw(
-	token: AtomIOToken,
 	store: Store,
+	token: AtomIOToken,
 ): AtomIOInternalResource {
 	let withdrawn: AtomIOInternalResource | undefined
 	let target: Store | null = store

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

@@ -2,7 +2,7 @@ import type { ReadableState } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 
-export const recallState = <T>(state: ReadableState<T>, store: Store): T => {
+export const recallState = <T>(store: Store, state: ReadableState<T>): T => {
 	const target = newest(store)
 	if (target.operation.open) {
 		return target.operation.prev.get(state.key)

package/internal/src/subscribe/subscribe-in-store.ts

@@ -53,10 +53,10 @@ export function subscribeInStore(
 		case `mutable_atom`:
 		case `readonly_selector`:
 		case `selector`:
-			return subscribeToState(token, handleUpdate, key, store)
+			return subscribeToState(store, token, key, handleUpdate)
 		case `transaction`:
-			return subscribeToTransaction(token, handleUpdate, key, store)
+			return subscribeToTransaction(store, token, key, handleUpdate)
 		case `timeline`:
-			return subscribeToTimeline(token, handleUpdate, key, store)
+			return subscribeToTimeline(store, token, key, handleUpdate)
 	}
 }

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

@@ -6,8 +6,8 @@ import type { Store } from "../store"
 import { recallState } from "./recall-state"
 
 export const subscribeToRootAtoms = <T>(
-	selector: Selector<T>,
 	store: Store,
+	selector: Selector<T>,
 ): (() => void)[] => {
 	const target = newest(store)
 	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
@@ -32,8 +32,8 @@ export const subscribeToRootAtoms = <T>(
 						`->`,
 						atomChange.newValue,
 					)
-					const oldValue = recallState(selector, target)
-					const newValue = readOrComputeValue(selector, target)
+					const oldValue = recallState(target, selector)
+					const newValue = readOrComputeValue(target, selector)
 					store.logger.info(
 						`✨`,
 						selector.type,

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

@@ -5,10 +5,10 @@ import { withdraw } from "../store"
 import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"
 
 export function subscribeToState<T>(
+	store: Store,
 	token: ReadableToken<T>,
-	handleUpdate: UpdateHandler<T>,
 	key: string,
-	store: Store,
+	handleUpdate: UpdateHandler<T>,
 ): () => void {
 	function safelyHandleUpdate(update: StateUpdate<any>): void {
 		if (store.operation.open) {
@@ -23,18 +23,18 @@ export function subscribeToState<T>(
 			handleUpdate(update)
 		}
 	}
-	const state = withdraw(token, store)
+	const state = withdraw(store, token)
 	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`)
 	const isSelector =
 		state.type === `selector` || state.type === `readonly_selector`
 	let dependencyUnsubFunctions: (() => void)[] | null = null
 	let updateHandler: UpdateHandler<T> = safelyHandleUpdate
 	if (isSelector) {
-		dependencyUnsubFunctions = subscribeToRootAtoms(state, store)
+		dependencyUnsubFunctions = subscribeToRootAtoms(store, state)
 		updateHandler = (update) => {
 			if (dependencyUnsubFunctions) {
 				dependencyUnsubFunctions.length = 0
-				dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store))
+				dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state))
 			}
 			safelyHandleUpdate(update)
 		}

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

@@ -4,12 +4,12 @@ import type { Store } from ".."
 import { withdraw } from ".."
 
 export const subscribeToTimeline = <ManagedAtom extends TimelineManageable>(
+	store: Store,
 	token: TimelineToken<ManagedAtom>,
-	handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void,
 	key: string,
-	store: Store,
+	handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void,
 ): (() => void) => {
-	const tl = withdraw(token, store)
+	const tl = withdraw(store, token)
 	store.logger.info(`👀`, `timeline`, token.key, `Adding subscription "${key}"`)
 	const unsubscribe = tl.subject.subscribe(key, handleUpdate)
 	return () => {

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

@@ -4,12 +4,12 @@ import type { Func, Store } from ".."
 import { withdraw } from ".."
 
 export const subscribeToTransaction = <F extends Func>(
+	store: Store,
 	token: TransactionToken<F>,
-	handleUpdate: TransactionUpdateHandler<F>,
 	key: string,
-	store: Store,
+	handleUpdate: TransactionUpdateHandler<F>,
 ): (() => void) => {
-	const tx = withdraw(token, store)
+	const tx = withdraw(store, token)
 	store.logger.info(
 		`👀`,
 		`transaction`,