atom.io 0.27.3 → 0.27.5

package/internal/src/get-state/read-or-compute-value.ts

@@ -10,7 +10,7 @@ export const readOrComputeValue = <T>(
 		target.logger.info(`📖`, state.type, state.key, `reading cached value`)
 		return readCachedValue(state, target)
 	}
-	if (state.type !== `atom` && state.type !== `mutable_atom`) {
+	if (state.type === `selector` || state.type === `readonly_selector`) {
 		target.logger.info(`🧮`, state.type, state.key, `computing value`)
 		return state.get()
 	}

package/internal/src/index.ts

@@ -3,6 +3,7 @@ import type {
 	FamilyMetadata,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
@@ -113,8 +114,9 @@ export type AtomFamily<T, K extends Canonical = Canonical> =
 // biome-ignore format: intersection
 export type WritableSelectorFamily<T, K extends Canonical> = 
 	& WritableSelectorFamilyToken<T, K> 
+	& ((key: K) => WritableSelectorToken<T>)
 	& {
-		(key: K): WritableSelectorToken<T>
+		default: (key: K) => T,
 		subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>
 		install: (store: Store) => void
 		internalRoles : string[] | undefined
@@ -122,10 +124,10 @@ export type WritableSelectorFamily<T, K extends Canonical> =
 
 // biome-ignore format: intersection
 export type ReadonlySelectorFamily<T, K extends Canonical> = 
+	& ReadonlySelectorFamilyToken<T, K>
 	& ((key: K) => ReadonlySelectorToken<T>)
 	& {
-		key: string
-		type: `readonly_selector_family`
+		default: (key: K) => T,
 		subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>
 		install: (store: Store) => void
 		internalRoles : string[] | undefined

package/internal/src/ingest-updates/ingest-atom-update.ts

@@ -14,5 +14,5 @@ export function ingestAtomUpdate(
 	if (atomUpdate.family) {
 		Object.assign(token, { family: atomUpdate.family })
 	}
-	setIntoStore(token, value, store)
+	setIntoStore(store, token, value)
 }

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -22,7 +22,7 @@ export function ingestCreationEvent(
 			break
 		}
 		case `oldValue`: {
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		}
 	}
@@ -35,7 +35,7 @@ export function ingestDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`: {
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		}
 		case `oldValue`: {
@@ -58,7 +58,7 @@ function createInStore(token: ReadableToken<any>, store: Store): void {
 			if (store.config.lifespan === `immortal`) {
 				throw new Error(`No molecule found for key "${token.family.subKey}"`)
 			}
-			initFamilyMemberInStore(family, parseJson(token.family.subKey), store)
+			initFamilyMemberInStore(store, family, parseJson(token.family.subKey))
 		}
 	}
 }
@@ -79,7 +79,7 @@ export function ingestMoleculeCreationEvent(
 			)
 			break
 		case `oldValue`:
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 	}
 }
@@ -90,7 +90,7 @@ export function ingestMoleculeDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		case `oldValue`:
 			{

package/internal/src/molecule/create-molecule-family.ts

@@ -10,8 +10,8 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 
 export function createMoleculeFamily<M extends MoleculeConstructor>(
-	options: MoleculeFamilyOptions<M>,
 	store: Store,
+	options: MoleculeFamilyOptions<M>,
 ): MoleculeFamilyToken<M> {
 	const subject = new Subject<MoleculeCreation<M>>()
 

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

@@ -55,7 +55,7 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 			disposalEvent.family = token.family
 		}
 		for (const state of molecule.tokens.values()) {
-			disposeFromStore(state, store)
+			disposeFromStore(store, state)
 		}
 		for (const child of molecule.below.values()) {
 			if (child.family?.dependsOn === `all`) {

package/internal/src/molecule/grow-molecule-in-store.ts

@@ -83,7 +83,7 @@ export function growMoleculeInStore(
 	family: ReadableFamilyToken<any, any>,
 	store: Store,
 ): ReadableToken<any> {
-	const stateToken = initFamilyMemberInStore(family, molecule.key, store)
+	const stateToken = initFamilyMemberInStore(store, family, molecule.key)
 	molecule.tokens.set(stateToken.key, stateToken)
 	const isTransaction =
 		isChildStore(store) && store.transactionMeta.phase === `building`

package/internal/src/molecule/make-molecule-in-store.ts

@@ -68,17 +68,17 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 
 	const toolkit = {
 		get: ((...ps: Parameters<typeof getState>) =>
-			getFromStore(...ps, newest(rootStore))) as typeof getState,
+			getFromStore(newest(rootStore), ...ps)) as typeof getState,
 		set: ((...ps: Parameters<typeof setState>) => {
-			setIntoStore(...ps, newest(rootStore))
+			setIntoStore(newest(rootStore), ...ps)
 		}) as typeof setState,
-		seek: ((t, k) => seekInStore(t, k, newest(rootStore))) as typeof seekState,
-		json: (t) => getJsonToken(t, newest(rootStore)),
+		seek: ((t, k) => seekInStore(newest(rootStore), t, k)) as typeof seekState,
+		json: (t) => getJsonToken(newest(rootStore), t),
 		run: (t, i = arbitrary()) => actUponStore(t, i, newest(store)),
 		make: (ctx, f, k, ...args) =>
 			makeMoleculeInStore(newest(rootStore), ctx, f, k, ...args),
 		dispose: (t) => {
-			disposeFromStore(t, newest(rootStore))
+			disposeFromStore(newest(rootStore), t)
 		},
 		env: () => getEnvironmentData(newest(rootStore)),
 		bond: ((

package/internal/src/mutable/create-mutable-atom-family.ts

@@ -10,8 +10,7 @@ import type {
 import type { Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
-import type { MutableAtomFamily } from ".."
-import { throwInCaseOfConflictingFamily } from "../families/throw-in-case-of-conflicting-family"
+import { type MutableAtomFamily, prettyPrintTokenType } from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
@@ -24,8 +23,8 @@ export function createMutableAtomFamily<
 	J extends Json.Serializable,
 	K extends string,
 >(
-	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
+	options: MutableAtomFamilyOptions<T, J, K>,
 	internalRoles?: string[],
 ): MutableAtomFamilyToken<T, J, K> {
 	const familyToken = {
@@ -33,7 +32,17 @@ export function createMutableAtomFamily<
 		type: `mutable_atom_family`,
 	} as const satisfies MutableAtomFamilyToken<T, J, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`mutable_atom_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
@@ -56,7 +65,7 @@ export function createMutableAtomFamily<
 			individualOptions.effects = options.effects(key)
 		}
 
-		const token = createMutableAtom(individualOptions, family, target)
+		const token = createMutableAtom(target, individualOptions, family)
 
 		subject.next({ type: `state_creation`, token })
 		return token
@@ -64,7 +73,7 @@ export function createMutableAtomFamily<
 
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
-		install: (s: Store) => createMutableAtomFamily(options, s),
+		install: (s: Store) => createMutableAtomFamily(s, options),
 		toJson: options.toJson,
 		fromJson: options.fromJson,
 		internalRoles,

package/internal/src/mutable/create-mutable-atom.ts

@@ -20,9 +20,9 @@ export function createMutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
+	store: Store,
 	options: MutableAtomOptions<T, J>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): MutableAtomToken<T, J> {
 	store.logger.info(
 		`🔨`,
@@ -52,7 +52,7 @@ export function createMutableAtom<
 				options.key,
 				`installing in store "${s.config.name}"`,
 			)
-			return createMutableAtom(options, family, s)
+			return createMutableAtom(s, options, family)
 		},
 		subject,
 	} as const
@@ -70,7 +70,7 @@ export function createMutableAtom<
 		for (const effect of options.effects) {
 			const cleanup = effect({
 				setSelf: (next) => {
-					setIntoStore(token, next, store)
+					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),

package/internal/src/mutable/get-json-token.ts

@@ -14,8 +14,8 @@ export const getJsonToken = <
 	Core extends Transceiver<any>,
 	SerializableCore extends Json.Serializable,
 >(
-	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
 	store: Store,
+	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
 ): WritableSelectorToken<SerializableCore> => {
 	if (mutableAtomToken.family) {
 		const target = newest(store)
@@ -29,7 +29,7 @@ export const getJsonToken = <
 		}
 		const family = withdraw(jsonFamilyToken, target)
 		const subKey = JSON.parse(mutableAtomToken.family.subKey)
-		const jsonToken = findInStore(family, subKey, store)
+		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken
 	}
 	const token: WritableSelectorToken<SerializableCore> = {

package/internal/src/mutable/tracker-family.ts

@@ -29,11 +29,11 @@ export class FamilyTracker<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
+			store,
 			{
 				key: `*${mutableAtoms.key}`,
 				default: null,
 			},
-			store,
 			[`mutable`, `updates`],
 		)
 		this.latestUpdateAtoms = withdraw(updateAtoms, store)
@@ -43,7 +43,7 @@ export class FamilyTracker<
 			(event) => {
 				if (event.token.family) {
 					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					seekInStore(this.latestUpdateAtoms, key, store)
+					seekInStore(store, this.latestUpdateAtoms, key)
 					new Tracker<Core>(event.token, store)
 				}
 			},
@@ -53,7 +53,7 @@ export class FamilyTracker<
 			(event) => {
 				if (event.token.family) {
 					const key = parseJson(event.token.family.subKey) as FamilyMemberKey
-					const mutableAtomToken = seekInStore(this.mutableAtoms, key, store)
+					const mutableAtomToken = seekInStore(store, this.mutableAtoms, key)
 					if (mutableAtomToken) {
 						new Tracker<Core>(mutableAtomToken, store)
 					}

package/internal/src/mutable/tracker.ts

@@ -37,12 +37,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		const latestUpdateState = createRegularAtom<
 			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
 		>(
+			store,
 			{
 				key: latestUpdateStateKey,
 				default: null,
 			},
 			familyMetaData,
-			store,
 		)
 		if (store.parent?.valueMap.has(latestUpdateStateKey)) {
 			const parentValue = store.parent.valueMap.get(latestUpdateStateKey)
@@ -62,11 +62,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		const subscriptionKey = `tracker:${target.config.name}:${
 			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
-		const originalInnerValue = getFromStore(mutableState, target)
+		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
 			(update) => {
-				setIntoStore(latestUpdateState, update, target)
+				setIntoStore(target, latestUpdateState, update)
 			},
 		)
 		this.unsubscribeFromState = subscribeToState(
@@ -77,7 +77,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
 						(transceiverUpdate) => {
-							setIntoStore(latestUpdateState, transceiverUpdate, target)
+							setIntoStore(target, latestUpdateState, transceiverUpdate)
 						},
 					)
 				}
@@ -109,18 +109,14 @@ export class Tracker<Mutable extends Transceiver<any>> {
 							{ key: timelineId, type: `timeline` },
 							(update) => {
 								unsubscribe()
-								setIntoStore(
-									mutableState,
-									(transceiver) => {
-										if (update === `redo` && newValue) {
-											transceiver.do(newValue)
-										} else if (update === `undo` && oldValue) {
-											transceiver.undo(oldValue)
-										}
-										return transceiver
-									},
-									target,
-								)
+								setIntoStore(target, mutableState, (transceiver) => {
+									if (update === `redo` && newValue) {
+										transceiver.do(newValue)
+									} else if (update === `undo` && oldValue) {
+										transceiver.undo(oldValue)
+									}
+									return transceiver
+								})
 							},
 							subscriptionKey,
 							target,
@@ -133,15 +129,15 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					subscriptionKey,
 					() => {
 						unsubscribe()
-						const mutable = getFromStore(mutableState, target)
+						const mutable = getFromStore(target, mutableState)
 						const updateNumber =
 							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
 						const eventOffset = updateNumber - mutable.cacheUpdateNumber
 						if (newValue && eventOffset === 1) {
 							setIntoStore(
+								target,
 								mutableState,
 								(transceiver) => (transceiver.do(newValue), transceiver),
-								target,
 							)
 						} else {
 							target.logger.info(

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

@@ -12,9 +12,9 @@ import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
 export const createReadonlySelector = <T>(
+	store: Store,
 	options: ReadonlySelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): ReadonlySelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
@@ -34,7 +34,7 @@ export const createReadonlySelector = <T>(
 	const readonlySelector: ReadonlySelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createReadonlySelector(options, family, s),
+		install: (s: Store) => createReadonlySelector(s, options, family),
 		get: getSelf,
 		type: `readonly_selector`,
 		...(family && { family }),

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

@@ -10,25 +10,25 @@ import { createReadonlySelector } from "./create-readonly-selector"
 import { createWritableSelector } from "./create-writable-selector"
 
 export function createStandaloneSelector<T>(
-	options: WritableSelectorOptions<T>,
 	store: Store,
+	options: WritableSelectorOptions<T>,
 ): WritableSelectorToken<T>
 export function createStandaloneSelector<T>(
-	options: ReadonlySelectorOptions<T>,
 	store: Store,
+	options: ReadonlySelectorOptions<T>,
 ): ReadonlySelectorToken<T>
 export function createStandaloneSelector<T>(
-	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 	store: Store,
+	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 ): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
 	const isWritable = `set` in options
 
 	if (isWritable) {
-		const state = createWritableSelector(options, undefined, store)
+		const state = createWritableSelector(store, options, undefined)
 		store.on.selectorCreation.next(state)
 		return state
 	}
-	const state = createReadonlySelector(options, undefined, store)
+	const state = createReadonlySelector(store, options, undefined)
 	store.on.selectorCreation.next(state)
 	return state
 }

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

@@ -15,19 +15,19 @@ import { isRootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export const createWritableSelector = <T>(
+	store: Store,
 	options: WritableSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): WritableSelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
-	const toolkit = registerSelector(options.key, covered, target)
-	const { find, get, seek, json } = toolkit
+	const setterToolkit = registerSelector(options.key, covered, target)
+	const { find, get, seek, json } = setterToolkit
 	const getterToolkit = { find, get, seek, json }
 
-	const getSelf = (innerTarget = newest(store)): T => {
-		const value = options.get(getterToolkit)
+	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
+		const value = getFn(getterToolkit)
 		cacheValue(options.key, value, subject, innerTarget)
 		covered.clear()
 		return value
@@ -35,7 +35,7 @@ export const createWritableSelector = <T>(
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
 		const innerTarget = newest(store)
-		const oldValue = getSelf(innerTarget)
+		const oldValue = getSelf(options.get, innerTarget)
 		const newValue = become(next)(oldValue)
 		store.logger.info(
 			`📝`,
@@ -52,12 +52,12 @@ export const createWritableSelector = <T>(
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })
 		}
-		options.set(toolkit, newValue)
+		options.set(setterToolkit, newValue)
 	}
 	const mySelector: WritableSelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createWritableSelector(options, family, s),
+		install: (s: Store) => createWritableSelector(s, options, family),
 		get: getSelf,
 		set: setSelf,
 		type: `selector`,

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

@@ -43,12 +43,12 @@ export const registerSelector = (
 			const [family, key] = params
 			switch (family.type) {
 				case `molecule_family`:
-					return getFromStore(family, key, store)
+					return getFromStore(store, family, key)
 				default:
 					if (store.config.lifespan === `ephemeral`) {
-						dependency = findInStore(family, key, store)
+						dependency = findInStore(store, family, key)
 					} else {
-						const maybeDependency = seekInStore(family, key, store)
+						const maybeDependency = seekInStore(store, family, key)
 						if (maybeDependency) {
 							dependency = maybeDependency
 						} else {
@@ -61,7 +61,7 @@ export const registerSelector = (
 		}
 
 		if (dependency.type === `molecule`) {
-			return getFromStore(dependency, store)
+			return getFromStore(store, dependency)
 		}
 
 		const dependencyState = withdraw(dependency, store)
@@ -108,8 +108,8 @@ export const registerSelector = (
 			value = params[2]
 			const maybeToken =
 				store.config.lifespan === `ephemeral`
-					? findInStore(family, key, store)
-					: seekInStore(family, key, store)
+					? findInStore(store, family, key)
+					: seekInStore(store, family, key)
 			if (!maybeToken) {
 				throw new NotFoundError(family, key, store)
 			}
@@ -119,7 +119,7 @@ export const registerSelector = (
 		const state = withdraw(token, target)
 		setAtomOrSelector(state, value, target)
 	}) as typeof setState,
-	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
-	seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
-	json: (token) => getJsonToken(token, store),
+	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/set-state/set-into-store.ts

@@ -1,58 +1,61 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
-import { NotFoundError } from "../not-found-error"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
 export function setIntoStore<T, New extends T>(
+	store: Store,
 	token: WritableToken<T>,
 	value: New | ((oldValue: T) => New),
-	store: Store,
 ): void
 
 export function setIntoStore<T, K extends Canonical, New extends T>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: K,
 	value: New | ((oldValue: T) => New),
-	store: Store,
 ): void
 
 export function setIntoStore<T, New extends T>(
+	store: Store,
 	...params:
 		| [
 				token: WritableFamilyToken<T, Canonical>,
 				key: Canonical,
 				value: New | ((oldValue: T) => New),
-				store: Store,
-		  ]
-		| [
-				token: WritableToken<T>,
-				value: New | ((oldValue: T) => New),
-				store: Store,
 		  ]
+		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
 	let token: WritableToken<T>
 	let value: New | ((oldValue: T) => New)
-	let store: Store
-	if (params.length === 3) {
+	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
-		store = params[2]
 	} else {
 		const family = params[0]
 		const key = params[1]
 		value = params[2]
-		store = params[3]
 		const maybeToken =
 			store.config.lifespan === `ephemeral`
-				? findInStore(family, key, store)
-				: seekInStore(family, key, store)
+				? findInStore(store, family, key)
+				: seekInStore(store, family, key)
 		if (!maybeToken) {
-			throw new NotFoundError(family, key, store)
+			store.logger.error(
+				`❗`,
+				family.type,
+				family.key,
+				`tried to set member`,
+				stringifyJson(key),
+				`to`,
+				value,
+				`but it was not found in store`,
+				store.config.name,
+			)
+			return
 		}
 		token = maybeToken
 	}
@@ -69,7 +72,7 @@ export function setIntoStore<T, New extends T>(
 					token.key,
 					`resuming deferred setState from T-${rejectionTime}`,
 				)
-				setIntoStore(token, value, store)
+				setIntoStore(store, token, value)
 			},
 		)
 		return