atom.io 0.21.0 → 0.22.0

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

@@ -12,8 +12,10 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			`❌`,
 			`atom`,
 			key,
-			`Tried to delete atom, but it does not exist in the store.`,
+			`Tried to dispose atom, but it does not exist in the store.`,
 		)
+	} else if (!atom.family) {
+		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()
 		target.atoms.delete(key)
@@ -35,6 +37,7 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
 			disposeAtom(updateToken, store)
+			store.trackers.delete(key)
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`)
 		store.on.atomDisposal.next(atomToken)

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

@@ -10,7 +10,6 @@ import { stringifyJson } from "atom.io/json"
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
-import { deposit } from "../store"
 import { Subject } from "../subject"
 
 export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
@@ -18,24 +17,25 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 	store: Store,
 ): ReadonlySelectorFamily<T, K> {
 	const subject = new Subject<ReadonlySelectorToken<T>>()
+
 	const readonlySelectorFamily = Object.assign(
 		(key: K): ReadonlySelectorToken<T> => {
-			const target = newest(store)
 			const subKey = stringifyJson(key)
 			const family: FamilyMetadata = { key: options.key, subKey }
 			const fullKey = `${options.key}(${subKey})`
-			const existing = target.readonlySelectors.get(fullKey)
-			if (existing) {
-				return deposit(existing)
-			}
-			return createReadonlySelector(
+			const target = newest(store)
+
+			const token = createReadonlySelector(
 				{
 					key: fullKey,
 					get: options.get(key),
 				},
 				family,
-				store,
+				target,
 			)
+
+			subject.next(token)
+			return token
 		},
 		{
 			key: options.key,
@@ -43,7 +43,7 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 			subject,
 			install: (s: Store) => createReadonlySelectorFamily(options, s),
 		} as const,
-	) as ReadonlySelectorFamily<T, K>
+	) satisfies ReadonlySelectorFamily<T, K>
 	store.families.set(options.key, readonlySelectorFamily)
 	return readonlySelectorFamily
 }

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/future.ts

@@ -8,7 +8,7 @@
  * Can be constructed like a Promise, or from an existing Promise.
  */
 export class Future<T> extends Promise<T> {
-	private destiny: Promise<T> | undefined
+	private fate: Promise<T> | undefined
 	private resolve: (value: T) => void
 	private reject: (reason?: any) => void
 
@@ -17,38 +17,24 @@ export class Future<T> extends Promise<T> {
 			| Promise<T>
 			| ((resolve: (value: T) => void, reject: (reason?: any) => void) => void),
 	) {
-		let promise: Promise<T> | undefined
 		let superResolve: ((value: T) => void) | undefined
 		let superReject: ((reason?: any) => void) | undefined
 		super((resolve, reject) => {
 			superResolve = resolve
 			superReject = reject
-			promise = executor instanceof Promise ? executor : new Promise(executor)
-			promise.then(
-				(value) => {
-					if (promise) {
-						this.pass(promise, value)
-					}
-				},
-				(reason) => {
-					if (promise) {
-						this.fail(promise, reason)
-					}
-				},
-			)
 		})
-		this.destiny = promise
 		this.resolve = superResolve as (value: T) => void
 		this.reject = superReject as (reason?: any) => void
+		this.use(executor instanceof Promise ? executor : new Promise(executor))
 	}
 
 	private pass(promise: Promise<T>, value: T) {
-		if (promise === this.destiny) {
+		if (promise === this.fate) {
 			this.resolve(value)
 		}
 	}
 	private fail(promise: Promise<T>, reason: any) {
-		if (promise === this.destiny) {
+		if (promise === this.fate) {
 			this.reject(reason)
 		}
 	}
@@ -56,7 +42,7 @@ export class Future<T> extends Promise<T> {
 	public use(value: Promise<T> | T): void {
 		if (value instanceof Promise) {
 			const promise = value
-			this.destiny = promise
+			this.fate = promise
 			promise.then(
 				(resolved) => {
 					this.pass(promise, resolved)
@@ -67,7 +53,7 @@ export class Future<T> extends Promise<T> {
 			)
 		} else {
 			this.resolve(value)
-			this.destiny = undefined
+			this.fate = undefined
 		}
 	}
 }

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

@@ -1,11 +1,10 @@
 import type { ReadableToken } from "atom.io"
 
-import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
-import { withdraw, 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
 }