atom.io 0.14.7 → 0.15.0

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

@@ -3,100 +3,19 @@ import type {
 	AtomToken,
 	FamilyMetadata,
 	MutableAtomOptions,
-	UpdateHandler,
 } from "atom.io"
-import { setState } from "atom.io"
-import { Json } from "atom.io/json"
 
-import { cacheValue } from "../caching"
-import { newest } from "../lineage"
-import { Transceiver, createMutableAtom } from "../mutable"
+import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
-import { deposit } from "../store"
-import { Subject } from "../subject"
-import { subscribeToState } from "../subscribe"
-import { markAtomAsDefault } from "./is-default"
-
-export type Atom<T> = {
-	key: string
-	type: `atom`
-	mutable?: boolean
-	family?: FamilyMetadata
-	install: (store: Store) => void
-	subject: Subject<{ newValue: T; oldValue: T }>
-	default: T | (() => T)
-	cleanup?: () => void
-}
+import { createRegularAtom } from "./create-regular-atom"
 
 export function createAtom<T>(
 	options: AtomOptions<T> | MutableAtomOptions<any, any>,
 	family: FamilyMetadata | undefined,
 	store: Store,
 ): AtomToken<T> {
-	store.logger.info(
-		`🔨`,
-		`atom`,
-		options.key,
-		`creating in store "${store.config.name}"`,
-	)
-	const target = newest(store)
-	const existing = target.atoms.get(options.key)
-	if (existing) {
-		store.logger.error(
-			`❌`,
-			`atom`,
-			options.key,
-			`Tried to create atom, but it already exists in the store.`,
-			`(Ignore if you are in development using hot module replacement.)`,
-		)
-		return deposit(existing)
-	}
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
-	const newAtom: Atom<T> = {
-		...options,
-		type: `atom`,
-		install: (store: Store) => {
-			store.logger.info(
-				`🛠️`,
-				`atom`,
-				options.key,
-				`installing in store "${store.config.name}"`,
-			)
-			return `mutable` in options
-				? createMutableAtom(options, store)
-				: createAtom(options, undefined, store)
-		},
-		subject,
-		...(family && { family }),
-	} as const
-	let initialValue = options.default
-	if (options.default instanceof Function) {
-		initialValue = options.default()
-	}
-	target.atoms.set(newAtom.key, newAtom)
-	markAtomAsDefault(options.key, store)
-	cacheValue(options.key, initialValue, subject, store)
-	const token = deposit(newAtom)
-	if (options.effects) {
-		let effectIndex = 0
-		const cleanupFunctions: (() => void)[] = []
-		for (const effect of options.effects) {
-			const cleanup = effect({
-				setSelf: (next) => setState(token, next, store),
-				onSet: (handle: UpdateHandler<T>) =>
-					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
-			})
-			if (cleanup) {
-				cleanupFunctions.push(cleanup)
-			}
-			++effectIndex
-		}
-		newAtom.cleanup = () => {
-			for (const cleanup of cleanupFunctions) {
-				cleanup()
-			}
-		}
+	if (`mutable` in options) {
+		return createMutableAtom(options, family, store)
 	}
-	store.subject.atomCreation.next(token)
-	return token as AtomToken<T>
+	return createRegularAtom<T>(options, family, store)
 }

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

@@ -0,0 +1,92 @@
+import type {
+	AtomOptions,
+	AtomToken,
+	FamilyMetadata,
+	MutableAtomOptions,
+	UpdateHandler,
+} from "atom.io"
+import { setState } from "atom.io"
+
+import type { Atom } from "."
+import { cacheValue } from "../caching"
+import { newest } from "../lineage"
+import { createMutableAtom } from "../mutable"
+import type { Store } from "../store"
+import { deposit } from "../store"
+import { Subject } from "../subject"
+import { subscribeToState } from "../subscribe"
+import { markAtomAsDefault } from "./is-default"
+
+export function createRegularAtom<T>(
+	options: AtomOptions<T> | MutableAtomOptions<any, any>,
+	family: FamilyMetadata | undefined,
+	store: Store,
+): AtomToken<T> {
+	store.logger.info(
+		`🔨`,
+		`atom`,
+		options.key,
+		`creating in store "${store.config.name}"`,
+	)
+	const target = newest(store)
+	const existing = target.atoms.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❌`,
+			`atom`,
+			options.key,
+			`Tried to create atom, but it already exists in the store.`,
+		)
+		return deposit(existing)
+	}
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const newAtom: Atom<T> = {
+		...options,
+		type: `atom`,
+		install: (store: Store) => {
+			store.logger.info(
+				`🛠️`,
+				`atom`,
+				options.key,
+				`installing in store "${store.config.name}"`,
+			)
+			return `mutable` in options
+				? createMutableAtom(options, family, store)
+				: createRegularAtom(options, family, store)
+		},
+		subject,
+	} as const
+	if (family) {
+		newAtom.family = family
+	}
+	let initialValue = options.default
+	if (options.default instanceof Function) {
+		initialValue = options.default()
+	}
+	target.atoms.set(newAtom.key, newAtom)
+	markAtomAsDefault(options.key, store)
+	cacheValue(options.key, initialValue, subject, target)
+	const token = deposit(newAtom)
+	if (options.effects) {
+		let effectIndex = 0
+		const cleanupFunctions: (() => void)[] = []
+		for (const effect of options.effects) {
+			const cleanup = effect({
+				setSelf: (next) => setState(token, next, store),
+				onSet: (handle: UpdateHandler<T>) =>
+					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
+			})
+			if (cleanup) {
+				cleanupFunctions.push(cleanup)
+			}
+			++effectIndex
+		}
+		newAtom.cleanup = () => {
+			for (const cleanup of cleanupFunctions) {
+				cleanup()
+			}
+		}
+	}
+	store.subject.atomCreation.next(token)
+	return token as AtomToken<T>
+}

package/internal/src/atom/index.ts

@@ -1,3 +1,19 @@
+import type { FamilyMetadata } from "~/packages/atom.io/src"
+import type { Store } from "../store"
+import type { Subject } from "../subject"
+
 export * from "./create-atom"
+export * from "./create-regular-atom"
 export * from "./delete-atom"
 export * from "./is-default"
+
+export type Atom<T> = {
+	key: string
+	type: `atom`
+	mutable?: boolean
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Subject<{ newValue: T; oldValue: T }>
+	default: T | (() => T)
+	cleanup?: () => void
+}

package/internal/src/atom/is-default.ts

@@ -17,8 +17,3 @@ export const markAtomAsNotDefault = (key: string, store: Store): void => {
 	core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault)
 	core.atomsThatAreDefault.delete(key)
 }
-
-export const isSelectorDefault = (key: string, store: Store): boolean => {
-	const rootKeys = traceAllSelectorAtoms(key, store)
-	return rootKeys.every((rootKey) => isAtomDefault(rootKey, store))
-}

package/internal/src/caching.ts

@@ -20,27 +20,26 @@ export function cacheValue<T>(
 	key: string,
 	value: T,
 	subject: Subject<StateUpdate<unknown>>,
-	store: Store,
+	target: Store,
 ): Future<T> | T {
-	const target = newest(store)
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
 		currentValue.cancel()
 	}
 	if (value instanceof Promise) {
 		const future = new Future<T>(value)
-		newest(store).valueMap.set(key, future)
+		target.valueMap.set(key, future)
 		future
 			.then((resolved) => {
 				if (future.isCanceled) {
 					return
 				}
-				cacheValue(key, resolved, subject, store)
+				cacheValue(key, resolved, subject, target)
 				subject.next({ newValue: resolved, oldValue: future })
 			})
 			.catch((thrown) => {
 				if (thrown !== `canceled`) {
-					store.logger.error(`💥`, `state`, key, `rejected:`, thrown)
+					target.logger.error(`💥`, `state`, key, `rejected:`, thrown)
 				}
 			})
 		return future
@@ -49,22 +48,21 @@ export function cacheValue<T>(
 	return value
 }
 
-export const readCachedValue = <T>(key: string, store: Store): T => {
-	return newest(store).valueMap.get(key) as T
+export const readCachedValue = <T>(key: string, target: Store): T => {
+	return target.valueMap.get(key) as T
 }
-export const isValueCached = (key: string, store: Store): boolean => {
-	return newest(store).valueMap.has(key)
+export const isValueCached = (key: string, target: Store): boolean => {
+	return target.valueMap.has(key)
 }
 
-export const evictCachedValue = (key: string, store: Store): void => {
-	const core = newest(store)
-	const currentValue = core.valueMap.get(key)
+export const evictCachedValue = (key: string, target: Store): void => {
+	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
 		currentValue.cancel()
 	}
-	if (core.operation.open) {
-		core.operation.prev.set(key, currentValue)
+	if (target.operation.open) {
+		target.operation.prev.set(key, currentValue)
 	}
-	core.valueMap.delete(key)
-	store.logger.info(`🗑`, `state`, key, `evicted`)
+	target.valueMap.delete(key)
+	target.logger.info(`🗑`, `state`, key, `evicted`)
 }

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

@@ -1,59 +1,33 @@
 import type {
 	AtomFamily,
 	AtomFamilyOptions,
-	AtomOptions,
-	AtomToken,
-	FamilyMetadata,
+	MutableAtomFamily,
+	MutableAtomFamilyOptions,
 } from "atom.io"
 import type { Json } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
 
-import { createAtom } from "../atom"
-import { newest } from "../lineage"
-import { deposit, withdraw } from "../store"
+import { type Transceiver, createMutableAtomFamily } from "../mutable"
 import type { Store } from "../store"
-import { Subject } from "../subject"
+import { createRegularAtomFamily } from "./create-regular-atom-family"
 
+export function createAtomFamily<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+>(
+	options: MutableAtomFamilyOptions<T, J, K>,
+	store: Store,
+): MutableAtomFamily<T, J, K>
 export function createAtomFamily<T, K extends Json.Serializable>(
 	options: AtomFamilyOptions<T, K>,
 	store: Store,
-): AtomFamily<T, K> {
-	const subject = new Subject<AtomToken<T>>()
-	const atomFamily = Object.assign(
-		(key: K): AtomToken<T> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const existing = withdraw({ key: fullKey, type: `atom` }, store)
-			let token: AtomToken<any>
-			if (existing) {
-				token = deposit(existing)
-			} else {
-				const individualOptions: AtomOptions<any> = {
-					key: fullKey,
-					default:
-						options.default instanceof Function
-							? options.default(key)
-							: options.default,
-				}
-				if (options.effects) {
-					individualOptions.effects = options.effects(key)
-				}
-				token = createAtom<T>(individualOptions, family, store)
-				subject.next(token)
-			}
-			return token
-		},
-		{
-			key: options.key,
-			type: `atom_family`,
-			subject,
-		} as const,
-	)
-	if (`mutable` in options && typeof options.mutable === `boolean`) {
-		Object.assign(atomFamily, { mutable: options.mutable })
+): AtomFamily<T, K>
+export function createAtomFamily<T, K extends Json.Serializable>(
+	options: AtomFamilyOptions<T, K> | MutableAtomFamilyOptions<any, any, any>,
+	store: Store,
+): AtomFamily<T, K> | MutableAtomFamily<any, any, any> {
+	if (`mutable` in options) {
+		return createMutableAtomFamily(options, store)
 	}
-	const target = newest(store)
-	target.families.set(options.key, atomFamily)
-	return atomFamily
+	return createRegularAtomFamily<T, K>(options, store)
 }

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

@@ -40,6 +40,7 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 			key: options.key,
 			type: `readonly_selector_family`,
 			subject,
+			install: (store: Store) => createReadonlySelectorFamily(options, store),
 		} as const,
 	) as ReadonlySelectorFamily<T, K>
 }

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

@@ -0,0 +1,72 @@
+import type {
+	AtomFamily,
+	AtomFamilyOptions,
+	AtomOptions,
+	AtomToken,
+	FamilyMetadata,
+	MutableAtomFamilyOptions,
+} from "atom.io"
+import type { Json } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
+
+import { createRegularAtom } from "../atom"
+import { newest } from "../lineage"
+import { createMutableAtom } from "../mutable"
+import { deposit, withdraw } from "../store"
+import type { Store } from "../store"
+import { Subject } from "../subject"
+
+export function createRegularAtomFamily<T, K extends Json.Serializable>(
+	options: AtomFamilyOptions<T, K> | MutableAtomFamilyOptions<any, any, K>,
+	store: Store,
+): AtomFamily<T, K> {
+	const subject = new Subject<AtomToken<T>>()
+	const atomFamily = Object.assign(
+		(key: K): AtomToken<T> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = withdraw({ key: fullKey, type: `atom` }, store)
+			let token: AtomToken<any>
+			if (existing) {
+				token = deposit(existing)
+			} else {
+				const individualOptions: AtomOptions<any> = {
+					key: fullKey,
+					default:
+						options.default instanceof Function
+							? options.default(key)
+							: options.default,
+				}
+				if (options.effects) {
+					individualOptions.effects = options.effects(key)
+				}
+				if (`mutable` in options) {
+					const mutableOptions = {
+						...individualOptions,
+						mutable: true,
+						toJson: options.toJson,
+						fromJson: options.fromJson,
+					} as const
+					token = createMutableAtom(mutableOptions, family, store)
+				} else {
+					token = createRegularAtom<T>(individualOptions, family, store)
+				}
+				subject.next(token)
+			}
+			return token
+		},
+		{
+			key: options.key,
+			type: `atom_family`,
+			subject,
+			install: (store: Store) => createRegularAtomFamily(options, store),
+		} as const,
+	)
+	if (`mutable` in options && typeof options.mutable === `boolean`) {
+		Object.assign(atomFamily, { mutable: options.mutable })
+	}
+	const target = newest(store)
+	target.families.set(options.key, atomFamily)
+	return atomFamily
+}

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

@@ -60,6 +60,8 @@ export function createSelectorFamily<T, K extends Json.Serializable>(
 		{
 			key: options.key,
 			type: `selector_family`,
+			subject,
+			install: (store: Store) => createSelectorFamily(options, store),
 		} as const,
 	) as SelectorFamily<T, K>
 	target.families.set(options.key, selectorFamily)

package/internal/src/families/index.ts

@@ -1,3 +1,4 @@
 export * from "./create-atom-family"
+export * from "./create-regular-atom-family"
 export * from "./create-readonly-selector-family"
 export * from "./create-selector-family"

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

@@ -3,7 +3,7 @@ import type { Json } from "atom.io/json"
 import { selectJsonFamily } from "atom.io/json"
 
 import type { Store } from ".."
-import { createAtomFamily } from ".."
+import { createRegularAtomFamily } from ".."
 import { FamilyTracker } from "./tracker-family"
 import type { Transceiver } from "./transceiver"
 
@@ -16,7 +16,7 @@ export function createMutableAtomFamily<
 	store: Store,
 ): MutableAtomFamily<Core, SerializableCore, Key> {
 	const coreFamily = Object.assign(
-		createAtomFamily<Core, Key>(options, store),
+		createRegularAtomFamily<Core, Key>(options, store),
 		options,
 	) as MutableAtomFamily<Core, SerializableCore, Key>
 	selectJsonFamily(coreFamily, options)

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

@@ -1,8 +1,12 @@
-import type { MutableAtomOptions, MutableAtomToken } from "atom.io"
+import type {
+	FamilyMetadata,
+	MutableAtomOptions,
+	MutableAtomToken,
+} from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
-import { createAtom } from "../atom"
+import { createRegularAtom } from "../atom"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { subscribeToState } from "../subscribe"
@@ -14,6 +18,7 @@ export function createMutableAtom<
 	SerializableCore extends Json.Serializable,
 >(
 	options: MutableAtomOptions<Core, SerializableCore>,
+	family: FamilyMetadata | undefined,
 	store: Store,
 ): MutableAtomToken<Core, SerializableCore> {
 	store.logger.info(
@@ -22,7 +27,7 @@ export function createMutableAtom<
 		options.key,
 		`creating in store "${store.config.name}"`,
 	)
-	const coreState = createAtom<Core>(options, undefined, store)
+	const coreState = createRegularAtom<Core>(options, family, store)
 	new Tracker(coreState, store)
 	const jsonState = selectJson(coreState, options, store)
 	const target = newest(store)

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

@@ -1,4 +1,4 @@
-import type { AtomFamily, MutableAtomFamily, SelectorFamily } from "atom.io"
+import type { AtomFamily, MutableAtomFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import { newest } from "../lineage"

package/internal/src/mutable/is-mutable.ts

@@ -1,44 +1,17 @@
-import type {
-	AtomFamily,
-	AtomToken,
-	MutableAtomFamily,
-	MutableAtomToken,
-} from "~/packages/atom.io/src"
+import type { AtomFamily, MutableAtomFamily } from "atom.io"
+
 import type { MutableAtom } from "."
 import type { Atom } from "../atom"
-import type { Store } from "../store"
-import { withdraw } from "../store"
 
-export function isMutable(
-	token: AtomToken<any>,
-	store: Store,
-): token is MutableAtomToken<any, any>
 export function isMutable(atom: Atom<any>): atom is MutableAtom<any>
 export function isMutable(
 	family: AtomFamily<any, any>,
 ): family is MutableAtomFamily<any, any, any>
 export function isMutable(
-	atomOrTokenOrFamily: Atom<any> | AtomFamily<any, any> | AtomToken<any>,
-	store?: Store,
+	atomOrTokenOrFamily: Atom<any> | AtomFamily<any, any>,
 ): boolean {
 	if (`mutable` in atomOrTokenOrFamily) {
 		return atomOrTokenOrFamily.mutable
 	}
-	if (atomOrTokenOrFamily.type === `atom_family`) {
-		return false
-	}
-	if (`default` in atomOrTokenOrFamily) {
-		return false
-	}
-	if (!store) {
-		throw new Error(`Cannot check mutability without a store`)
-	}
-	const atom = withdraw(atomOrTokenOrFamily, store)
-	if (!atom) {
-		throw new Error(`Cannot check mutability without an atom`)
-	}
-	if (`mutable` in atom) {
-		return atom.mutable
-	}
 	return false
 }

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

@@ -2,7 +2,7 @@ import type { AtomFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import { createAtomFamily } from "../families"
+import { createRegularAtomFamily } from "../families"
 import type { Store } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
@@ -25,7 +25,7 @@ export class FamilyTracker<
 		findMutableState: AtomFamily<Core, FamilyMemberKey>,
 		store: Store,
 	) {
-		this.findLatestUpdateState = createAtomFamily<
+		this.findLatestUpdateState = createRegularAtomFamily<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(

package/internal/src/mutable/tracker.ts

@@ -4,7 +4,7 @@ import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
 import { newest, subscribeToState, subscribeToTimeline } from ".."
-import { createAtom, deleteAtom } from "../atom"
+import { createRegularAtom, deleteAtom } from "../atom"
 import type { Transceiver } from "./transceiver"
 
 /**
@@ -28,7 +28,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					subKey: mutableState.family.subKey,
 			  }
 			: undefined
-		const latestUpdateState = createAtom<
+		const latestUpdateState = createRegularAtom<
 			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
 		>(
 			{
@@ -38,7 +38,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			familyMetaData,
 			store,
 		)
-		if (store.parent) {
+		if (store.parent?.valueMap.has(latestUpdateStateKey)) {
 			const parentValue = store.parent.valueMap.get(latestUpdateStateKey)
 			store.valueMap.set(latestUpdateStateKey, parentValue)
 		}
@@ -61,11 +61,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					: target.transactionMeta.update.key
 			}`,
 			(update) => {
-				const unsubscribe = store.subject.operationStatus.subscribe(
+				const unsubscribe = target.subject.operationStatus.subscribe(
 					mutableState.key,
 					() => {
 						unsubscribe()
-						setState(latestUpdateState, update, store)
+						setState(latestUpdateState, update, target)
 					},
 				)
 			},