atom.io 0.21.1 → 0.22.0

package/internal/src/families/create-regular-atom-family.ts

@@ -18,30 +18,26 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 	store: Store,
 ): RegularAtomFamily<T, K> {
 	const subject = new Subject<RegularAtomToken<T>>()
+
 	const atomFamily: RegularAtomFamily<T, K> = Object.assign(
 		(key: K): RegularAtomToken<any> => {
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
 			const target = newest(store)
-			const atomAlreadyCreated = target.atoms.has(fullKey)
-			let token: RegularAtomToken<any>
-			if (atomAlreadyCreated) {
-				token = { type: `atom`, key: fullKey, family }
-			} else {
-				const individualOptions: RegularAtomOptions<any> = {
-					key: fullKey,
-					default:
-						options.default instanceof Function
-							? options.default(key)
-							: options.default,
-				}
-				if (options.effects) {
-					individualOptions.effects = options.effects(key)
-				}
-				token = createRegularAtom(individualOptions, family, store)
-				subject.next(token)
+
+			const def = options.default
+			const individualOptions: RegularAtomOptions<T> = {
+				key: fullKey,
+				default: def instanceof Function ? def(key) : def,
+			}
+			if (options.effects) {
+				individualOptions.effects = options.effects(key)
 			}
+
+			const token = createRegularAtom(individualOptions, family, target)
+
+			subject.next(token)
 			return token
 		},
 		{
@@ -50,8 +46,7 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 			subject,
 			install: (s: Store) => createRegularAtomFamily(options, s),
 		} as const,
-	)
-	const target = newest(store)
-	target.families.set(options.key, atomFamily)
+	) satisfies RegularAtomFamily<T, K>
+	store.families.set(options.key, atomFamily)
 	return atomFamily
 }

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

@@ -7,9 +7,9 @@ import type {
 import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
+import { newest } from "../lineage"
 import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
-import { deposit } from "../store"
 import { Subject } from "../subject"
 
 export function createWritableSelectorFamily<T, K extends Json.Serializable>(
@@ -23,10 +23,8 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = store.selectors.get(fullKey)
-			if (existing) {
-				return deposit(existing)
-			}
+			const target = newest(store)
+
 			const token = createWritableSelector(
 				{
 					key: fullKey,
@@ -34,8 +32,9 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 					set: options.set(key),
 				},
 				family,
-				store,
+				target,
 			)
+
 			subject.next(token)
 			return token
 		},
@@ -45,7 +44,7 @@ export function createWritableSelectorFamily<T, K extends Json.Serializable>(
 			subject,
 			install: (s: Store) => createWritableSelectorFamily(options, s),
 		} as const,
-	) as WritableSelectorFamily<T, K>
+	) satisfies WritableSelectorFamily<T, K>
 	store.families.set(options.key, selectorFamily)
 	return selectorFamily
 }

package/internal/src/families/find-in-store.ts

@@ -21,6 +21,8 @@ import type { Json } from "atom.io/json"
 import type { Transceiver } from "../mutable"
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
+import { initFamilyMember } from "./init-family-member"
+import { seekInStore } from "./seek-in-store"
 
 export function findInStore<
 	T extends Transceiver<any>,
@@ -80,11 +82,15 @@ export function findInStore(
 	key: Json.Serializable,
 	store: Store,
 ): ReadableToken<any> {
-	const familyKey = token.key
-	const family = store.families.get(familyKey)
-	if (family === undefined) {
-		throw new NotFoundError(token, store)
+	if (store.config.lifespan === `immortal`) {
+		throw new Error(
+			`Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`,
+		)
 	}
-	const state = family(key)
+	let state = seekInStore(token, key, store)
+	if (state) {
+		return state
+	}
+	state = initFamilyMember(token, key, store)
 	return state
 }

package/internal/src/families/index.ts

@@ -3,3 +3,5 @@ export * from "./create-readonly-selector-family"
 export * from "./create-regular-atom-family"
 export * from "./create-selector-family"
 export * from "./find-in-store"
+export * from "./init-family-member"
+export * from "./seek-in-store"

package/internal/src/families/init-family-member.ts

@@ -0,0 +1,91 @@
+import type {
+	AtomFamilyToken,
+	AtomToken,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	SelectorFamilyToken,
+	SelectorToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Json } from "atom.io/json"
+
+import type { Transceiver } from "../mutable"
+import { NotFoundError } from "../not-found-error"
+import type { Store } from "../store"
+import { seekInStore } from "./seek-in-store"
+
+export function initFamilyMember<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+	Key extends K,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	key: Key,
+	store: Store,
+): MutableAtomToken<T, J>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): RegularAtomToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableSelectorToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadonlySelectorToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableToken<T>
+
+export function initFamilyMember<T, K extends Json.Serializable, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadableToken<T>
+
+export function initFamilyMember(
+	token: ReadableFamilyToken<any, any>,
+	key: Json.Serializable,
+	store: Store,
+): ReadableToken<any> {
+	const familyKey = token.key
+	const family = store.families.get(familyKey)
+	if (family === undefined) {
+		throw new NotFoundError(token, store)
+	}
+	const state = family(key)
+	return state
+}

package/internal/src/families/seek-in-store.ts

@@ -0,0 +1,106 @@
+import type {
+	AtomFamilyToken,
+	AtomToken,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	SelectorFamilyToken,
+	SelectorToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import { type Json, stringifyJson } from "atom.io/json"
+
+import type { ReadableState } from ".."
+import { newest } from "../lineage"
+import type { Transceiver } from "../mutable"
+import { deposit, type Store } from "../store"
+
+export function seekInStore<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+	Key extends K,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	key: Key,
+	store: Store,
+): MutableAtomToken<T, J> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): RegularAtomToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableSelectorToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadonlySelectorToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableToken<T> | undefined
+
+export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadableToken<T> | undefined
+
+export function seekInStore(
+	token: ReadableFamilyToken<any, any>,
+	key: Json.Serializable,
+	store: Store,
+): ReadableToken<any> | undefined {
+	const subKey = stringifyJson(key)
+	const fullKey = `${token.key}(${subKey})`
+	const target = newest(store)
+	let state: ReadableState<any> | undefined
+	switch (token.type) {
+		case `atom_family`:
+		case `mutable_atom_family`:
+			state = target.atoms.get(fullKey)
+			break
+
+		case `selector_family`: {
+			state = target.selectors.get(fullKey)
+			break
+		}
+		case `readonly_selector_family`:
+			state = target.readonlySelectors.get(fullKey)
+			break
+	}
+	if (state) {
+		return deposit(state)
+	}
+	return state
+}

package/internal/src/get-state/get-from-store.ts

@@ -1,10 +1,10 @@
 import type { ReadableToken } from "atom.io"
 
 import type { Store } from "../store"
-import { withdrawOrCreate } from "../store"
+import { withdraw } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
 export function getFromStore<T>(token: ReadableToken<T>, store: Store): T {
-	const state = withdrawOrCreate(token, store)
+	const state = withdraw(token, store)
 	return readOrComputeValue(state, store)
 }

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

@@ -24,32 +24,28 @@ export function createMutableAtomFamily<
 	store: Store,
 ): MutableAtomFamily<T, J, K> {
 	const subject = new Subject<MutableAtomToken<T, J>>()
-	const atomFamily: MutableAtomFamily<T, J, K> = Object.assign(
+
+	const atomFamily = Object.assign(
 		(key: K): MutableAtomToken<T, J> => {
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
 			const target = newest(store)
-			const atomAlreadyCreated = target.atoms.has(fullKey)
-			let token: MutableAtomToken<T, J>
-			if (atomAlreadyCreated) {
-				token = { type: `mutable_atom`, key: fullKey, family }
-			} else {
-				const individualOptions: MutableAtomOptions<T, J> = {
-					key: fullKey,
-					default: () => options.default(key),
-					toJson: options.toJson,
-					fromJson: options.fromJson,
-					mutable: true,
-				}
-				if (options.effects) {
-					individualOptions.effects = options.effects(key)
-				}
-
-				token = createMutableAtom(individualOptions, family, store)
 
-				subject.next(token)
+			const individualOptions: MutableAtomOptions<T, J> = {
+				key: fullKey,
+				default: () => options.default(key),
+				toJson: options.toJson,
+				fromJson: options.fromJson,
+				mutable: true,
+			}
+			if (options.effects) {
+				individualOptions.effects = options.effects(key)
 			}
+
+			const token = createMutableAtom(individualOptions, family, target)
+
+			subject.next(token)
 			return token
 		},
 		{
@@ -60,10 +56,8 @@ export function createMutableAtomFamily<
 			toJson: options.toJson,
 			fromJson: options.fromJson,
 		} as const,
-	)
-
-	const target = newest(store)
-	target.families.set(options.key, atomFamily)
+	) satisfies MutableAtomFamily<T, J, K>
+	store.families.set(options.key, atomFamily)
 	selectJsonFamily(atomFamily, options, store)
 	new FamilyTracker(atomFamily, store)
 	return atomFamily

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

@@ -88,7 +88,9 @@ export function createMutableAtom<
 	}
 
 	new Tracker(token, store)
-	selectJson(token, options, store)
+	if (!family) {
+		selectJson(token, options, store)
+	}
 
 	store.on.atomCreation.next(token)
 

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

@@ -1,4 +1,4 @@
-import type { MutableAtomFamily, WritableSelectorFamily } from "atom.io"
+import type { MutableAtomFamilyToken, WritableSelectorFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import { newest } from "../lineage"
@@ -10,7 +10,7 @@ export const getJsonFamily = <
 	SerializableCore extends Json.Serializable,
 	Key extends string,
 >(
-	mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>,
+	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
 	store: Store,
 ): WritableSelectorFamily<SerializableCore, Key> => {
 	const target = newest(store)

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

@@ -1,6 +1,14 @@
-import type { MutableAtomToken, WritableSelectorToken } from "atom.io"
+import type {
+	MutableAtomToken,
+	WritableSelectorFamily,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+} from "atom.io"
 import type { Json } from "atom.io/json"
 
+import { findInStore } from "../families"
+import { newest } from "../lineage"
+import { type Store, withdraw } from "../store"
 import type { Transceiver } from "./transceiver"
 
 export const getJsonToken = <
@@ -8,19 +16,26 @@ export const getJsonToken = <
 	SerializableCore extends Json.Serializable,
 >(
 	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
+	store: Store,
 ): WritableSelectorToken<SerializableCore> => {
-	const key = mutableAtomToken.family
-		? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})`
-		: `${mutableAtomToken.key}:JSON`
-	const jsonToken: WritableSelectorToken<SerializableCore> = {
-		type: `selector`,
-		key,
-	}
 	if (mutableAtomToken.family) {
-		jsonToken.family = {
-			key: `${mutableAtomToken.family.key}:JSON`,
-			subKey: mutableAtomToken.family.subKey,
+		const target = newest(store)
+		const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`
+		const jsonFamilyToken: WritableSelectorFamilyToken<
+			SerializableCore,
+			string
+		> = {
+			key: jsonFamilyKey,
+			type: `selector_family`,
 		}
+		const family = withdraw(jsonFamilyToken, target)
+		const subKey = JSON.parse(mutableAtomToken.family.subKey)
+		const jsonToken = findInStore(family, subKey, store)
+		return jsonToken
+	}
+	const token: WritableSelectorToken<SerializableCore> = {
+		type: `selector`,
+		key: `${mutableAtomToken.key}:JSON`,
 	}
-	return jsonToken
+	return token
 }

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

@@ -2,7 +2,7 @@ import type { MutableAtomFamily, RegularAtomFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import { createRegularAtomFamily } from "../families"
+import { createRegularAtomFamily, seekInStore } from "../families"
 import type { Store } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
@@ -15,44 +15,46 @@ export class FamilyTracker<
 		? Signal
 		: never
 
-	public readonly findLatestUpdateState: RegularAtomFamily<
+	public readonly latestUpdateAtoms: RegularAtomFamily<
 		typeof this.Update | null,
 		FamilyMemberKey
 	>
-	public readonly findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>
+	public readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>
 
 	public constructor(
-		findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>,
+		mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>,
 		store: Store,
 	) {
-		this.findLatestUpdateState = createRegularAtomFamily<
+		this.latestUpdateAtoms = createRegularAtomFamily<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
 			{
-				key: `*${findMutableState.key}`,
+				key: `*${mutableAtoms.key}`,
 				default: null,
 			},
 			store,
 		)
-		this.findMutableState = findMutableState
-		this.findMutableState.subject.subscribe(
+		this.mutableAtoms = mutableAtoms
+		this.mutableAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
 			(atomToken) => {
 				if (atomToken.family) {
 					const key = parseJson(atomToken.family.subKey) as FamilyMemberKey
-					this.findLatestUpdateState(key)
+					seekInStore(this.latestUpdateAtoms, key, store)
 					new Tracker<Core>(atomToken, store)
 				}
 			},
 		)
-		this.findLatestUpdateState.subject.subscribe(
+		this.latestUpdateAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,
 			(atomToken) => {
 				if (atomToken.family) {
 					const key = parseJson(atomToken.family.subKey) as FamilyMemberKey
-					const mutableAtomToken = this.findMutableState(key)
-					new Tracker<Core>(mutableAtomToken, store)
+					const mutableAtomToken = seekInStore(this.mutableAtoms, key, store)
+					if (mutableAtomToken) {
+						new Tracker<Core>(mutableAtomToken, store)
+					}
 				}
 			},
 		)

package/internal/src/not-found-error.ts

@@ -16,10 +16,18 @@ type AtomIOToken =
 	| TransactionToken<any>
 
 function prettyPrintTokenType(token: AtomIOToken) {
-	if (token.type === `readonly_selector`) {
-		return `Readonly Selector`
+	switch (token.type) {
+		case `atom_family`:
+			return `Atom Family`
+		case `readonly_selector`:
+			return `Readonly Selector`
+		case `readonly_selector_family`:
+			return `Readonly Selector Family`
+		case `selector_family`:
+			return `Selector Family`
+		default:
+			return capitalize(token.type)
 	}
-	return capitalize(token.type)
 }
 
 export class NotFoundError extends Error {

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

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

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

@@ -22,8 +22,8 @@ export const createWritableSelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const transactors = registerSelector(options.key, target)
-	const { find, get } = transactors
-	const readonlyTransactors = { find, get }
+	const { find, get, seek } = transactors
+	const readonlyTransactors = { find, get, seek }
 
 	const getSelf = () => {
 		const value = options.get(readonlyTransactors)

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

@@ -9,30 +9,47 @@ export function disposeSelector(
 ): void {
 	const target = newest(store)
 	const { key } = selectorToken
-	switch (selectorToken.type) {
-		case `selector`:
-			target.selectors.delete(key)
-			break
-		case `readonly_selector`:
-			target.readonlySelectors.delete(key)
-			break
-	}
-	target.valueMap.delete(key)
-	target.selectorAtoms.delete(key)
-	const downstreamTokens = target.selectorGraph
-		.getRelationEntries({ upstreamSelectorKey: key })
-		.filter(([_, { source }]) => source === key)
-		.map(
-			([downstreamSelectorKey]) =>
-				target.selectors.get(downstreamSelectorKey) ??
-				target.readonlySelectors.get(downstreamSelectorKey),
+	const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key)
+	if (!selector) {
+		store.logger.error(
+			`❌`,
+			`selector`,
+			key,
+			`Tried to dispose selector, but it does not exist in the store.`,
+		)
+	} else if (!selector.family) {
+		store.logger.error(
+			`❌`,
+			`selector`,
+			key,
+			`Standalone selectors cannot be disposed.`,
 		)
-	for (const downstreamToken of downstreamTokens) {
-		if (downstreamToken) {
-			disposeSelector(downstreamToken, store)
+	} else {
+		switch (selectorToken.type) {
+			case `selector`:
+				target.selectors.delete(key)
+				break
+			case `readonly_selector`:
+				target.readonlySelectors.delete(key)
+				break
+		}
+		target.valueMap.delete(key)
+		target.selectorAtoms.delete(key)
+		const downstreamTokens = target.selectorGraph
+			.getRelationEntries({ upstreamSelectorKey: key })
+			.filter(([_, { source }]) => source === key)
+			.map(
+				([downstreamSelectorKey]) =>
+					target.selectors.get(downstreamSelectorKey) ??
+					target.readonlySelectors.get(downstreamSelectorKey),
+			)
+		for (const downstreamToken of downstreamTokens) {
+			if (downstreamToken) {
+				disposeSelector(downstreamToken, store)
+			}
 		}
+		target.selectorGraph.delete(key)
+		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
+		store.on.selectorDisposal.next(selectorToken)
 	}
-	target.selectorGraph.delete(key)
-	store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
-	store.on.selectorDisposal.next(selectorToken)
 }