atom.io 0.31.0 → 0.32.0

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(
 			`🔌`,
@@ -82,20 +80,12 @@ export const registerSelector = (
 			const family = params[0]
 			const key = params[1]
 			value = params[2]
-			const maybeToken =
-				store.config.lifespan === `ephemeral`
-					? findInStore(store, family, key)
-					: seekInStore(store, family, key)
-			if (!maybeToken) {
-				throw new NotFoundError(family, key, store)
-			}
-			token = maybeToken
+			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/deposit.ts

@@ -1,5 +1,6 @@
 import type {
 	AtomFamilyToken,
+	AtomIOToken,
 	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -11,6 +12,8 @@ import type {
 	RegularAtomToken,
 	SelectorFamilyToken,
 	SelectorToken,
+	TimelineManageable,
+	TimelineToken,
 	TransactionToken,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
@@ -22,6 +25,7 @@ import type { Canonical, Json } from "atom.io/json"
 import type {
 	Atom,
 	AtomFamily,
+	AtomIOInternalResource,
 	Func,
 	MutableAtom,
 	MutableAtomFamily,
@@ -33,6 +37,7 @@ import type {
 	RegularAtomFamily,
 	Selector,
 	SelectorFamily,
+	Timeline,
 	Transceiver,
 	WritableFamily,
 	WritableSelector,
@@ -80,16 +85,13 @@ export function deposit<T>(
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
+export function deposit<M extends TimelineManageable>(
+	state: Timeline<M>,
+): TimelineToken<M>
 
-export function deposit(state: ReadableState<any>): ReadableToken<any>
+export function deposit(resource: AtomIOInternalResource): AtomIOToken
 
-export function deposit(
-	state: ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>,
-): ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func>
-
-export function deposit(
-	state: ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>,
-): ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func> {
+export function deposit(state: AtomIOInternalResource): AtomIOToken {
 	const token = {
 		key: state.key,
 		type: state.type,

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

@@ -1,5 +1,6 @@
 import type {
 	AtomFamilyToken,
+	AtomIOToken,
 	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -24,8 +25,8 @@ import type { Canonical, Json } from "atom.io/json"
 import type {
 	Atom,
 	AtomFamily,
+	AtomIOInternalResource,
 	Func,
-	Molecule,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -47,118 +48,98 @@ import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-export type Withdrawable =
-	| Atom<any>
-	| AtomFamily<any, any>
-	| Molecule<any>
-	| MutableAtom<any, any>
-	| MutableAtomFamily<any, any, any>
-	| ReadableFamily<any, any>
-	| ReadableState<any>
-	| ReadonlySelector<any>
-	| ReadonlySelectorFamily<any, any>
-	| RegularAtom<any>
-	| RegularAtomFamily<any, any>
-	| Selector<any>
-	| SelectorFamily<any, any>
-	| Timeline<any>
-	| Transaction<any>
-	| WritableFamily<any, any>
-	| WritableSelector<any>
-	| WritableSelectorFamily<any, any>
-	| WritableState<any>
-
 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: ReadableToken<T>,
 	store: Store,
+	token: WritableToken<T>,
+): WritableState<T>
+export function withdraw<T>(
+	store: Store,
+	token: ReadableToken<T>,
 ): ReadableState<T>
 
 export function withdraw(
-	token:
-		| MutableAtomFamilyToken<any, any, any>
-		| MutableAtomToken<any, any>
-		| RegularAtomFamilyToken<any, any>
-		| RegularAtomToken<any>
-		| SelectorFamilyToken<any, any>
-		| SelectorToken<any>
-		| TimelineToken<any>
-		| TransactionToken<any>,
-	store: Store,
-): Withdrawable {
-	let withdrawn: Withdrawable | undefined
+	store: Store,
+	token: AtomIOToken,
+): AtomIOInternalResource
+
+export function withdraw(
+	store: Store,
+	token: AtomIOToken,
+): AtomIOInternalResource {
+	let withdrawn: AtomIOInternalResource | undefined
 	let target: Store | null = store
 	while (target !== null) {
 		switch (token.type) {

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`,