atom.io 0.15.6 → 0.16.0

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

@@ -1,16 +1,15 @@
 import type {
-	AtomOptions,
-	AtomToken,
 	FamilyMetadata,
 	MutableAtomOptions,
+	RegularAtomOptions,
+	RegularAtomToken,
 	UpdateHandler,
 } from "atom.io"
 import { setState } from "atom.io"
 
-import type { Atom } from "."
+import type { RegularAtom } 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"
@@ -18,10 +17,10 @@ import { subscribeToState } from "../subscribe"
 import { markAtomAsDefault } from "./is-default"
 
 export function createRegularAtom<T>(
-	options: AtomOptions<T> | MutableAtomOptions<any, any>,
+	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
 	family: FamilyMetadata | undefined,
 	store: Store,
-): AtomToken<T> {
+): RegularAtomToken<T> {
 	store.logger.info(
 		`🔨`,
 		`atom`,
@@ -30,7 +29,7 @@ export function createRegularAtom<T>(
 	)
 	const target = newest(store)
 	const existing = target.atoms.get(options.key)
-	if (existing) {
+	if (existing && existing.type === `atom`) {
 		store.logger.error(
 			`❌`,
 			`atom`,
@@ -40,7 +39,7 @@ export function createRegularAtom<T>(
 		return deposit(existing)
 	}
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
-	const newAtom: Atom<T> = {
+	const newAtom: RegularAtom<T> = {
 		...options,
 		type: `atom`,
 		install: (store: Store) => {
@@ -50,9 +49,7 @@ export function createRegularAtom<T>(
 				options.key,
 				`installing in store "${store.config.name}"`,
 			)
-			return `mutable` in options
-				? createMutableAtom(options, family, store)
-				: createRegularAtom(options, family, store)
+			return createRegularAtom(options, family, store)
 		},
 		subject,
 	} as const
@@ -88,5 +85,5 @@ export function createRegularAtom<T>(
 		}
 	}
 	store.on.atomCreation.next(token)
-	return token as AtomToken<T>
+	return token
 }

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

@@ -0,0 +1,33 @@
+import type {
+	AtomToken,
+	MutableAtomOptions,
+	MutableAtomToken,
+	RegularAtomOptions,
+	RegularAtomToken,
+} from "atom.io"
+import type { Json } from "atom.io/json"
+
+import type { Transceiver } from "../mutable"
+import { createMutableAtom } from "../mutable"
+import type { Store } from "../store"
+import { createRegularAtom } from "./create-regular-atom"
+
+export function createStandaloneAtom<T>(
+	options: RegularAtomOptions<T>,
+	store: Store,
+): RegularAtomToken<T>
+export function createStandaloneAtom<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>
+export function createStandaloneAtom<T>(
+	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
+	store: Store,
+): AtomToken<T> {
+	const isMutable = `mutable` in options
+
+	if (isMutable) {
+		return createMutableAtom(options, undefined, store)
+	}
+	return createRegularAtom(options, undefined, store)
+}

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

@@ -1,9 +1,12 @@
-import type { AtomToken } from "atom.io"
+import type { RegularAtomToken } from "atom.io"
 
 import type { Store } from ".."
 import { deleteSelector, newest } from ".."
 
-export function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void {
+export function deleteAtom(
+	atomToken: RegularAtomToken<unknown>,
+	store: Store,
+): void {
 	const target = newest(store)
 	const { key } = atomToken
 	const atom = target.atoms.get(key)

package/internal/src/atom/index.ts

@@ -1,19 +1,4 @@
-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-standalone-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

@@ -1,5 +1,4 @@
 import { newest } from "../lineage"
-import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 
 export const isAtomDefault = (key: string, store: Store): boolean => {

package/internal/src/caching.ts

@@ -1,5 +1,5 @@
-import type { ReadableToken, StateUpdate } from "atom.io"
-import type { StateNode } from "."
+import type { StateUpdate } from "atom.io"
+import type { ReadableState } from "."
 import { Future } from "./future"
 import { copyMutableIfWithinTransaction } from "./set-state/copy-mutable-in-transaction"
 import type { Store } from "./store"
@@ -49,7 +49,10 @@ export function cacheValue<T>(
 	return value
 }
 
-export const readCachedValue = <T>(token: StateNode<any>, target: Store): T => {
+export const readCachedValue = <T>(
+	token: ReadableState<any>,
+	target: Store,
+): T => {
 	let value = target.valueMap.get(token.key) as T
 	if (token.type === `atom`) {
 		value = copyMutableIfWithinTransaction(value, token, target)

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

@@ -1,8 +1,8 @@
 import type {
-	AtomFamily,
-	AtomFamilyOptions,
 	MutableAtomFamily,
 	MutableAtomFamilyOptions,
+	RegularAtomFamily,
+	RegularAtomFamilyOptions,
 } from "atom.io"
 import type { Json } from "atom.io/json"
 
@@ -19,14 +19,18 @@ export function createAtomFamily<
 	store: Store,
 ): MutableAtomFamily<T, J, K>
 export function createAtomFamily<T, K extends Json.Serializable>(
-	options: AtomFamilyOptions<T, K>,
+	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): AtomFamily<T, K>
+): RegularAtomFamily<T, K>
 export function createAtomFamily<T, K extends Json.Serializable>(
-	options: AtomFamilyOptions<T, K> | MutableAtomFamilyOptions<any, any, any>,
+	options:
+		| MutableAtomFamilyOptions<any, any, any>
+		| RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): AtomFamily<T, K> | MutableAtomFamily<any, any, any> {
-	if (`mutable` in options) {
+): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
+	const isMutable = `mutable` in options
+
+	if (isMutable) {
 		return createMutableAtomFamily(options, store)
 	}
 	return createRegularAtomFamily<T, K>(options, store)

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

@@ -8,8 +8,9 @@ import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
-import { createSelector } from "../selector"
-import { type Store, deposit } from "../store"
+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>(
@@ -27,7 +28,7 @@ export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
 			if (existing) {
 				return deposit(existing)
 			}
-			return createSelector<T>(
+			return createReadonlySelector(
 				{
 					key: fullKey,
 					get: options.get(key),

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

@@ -1,37 +1,35 @@
 import type {
-	AtomFamily,
-	AtomFamilyOptions,
-	AtomOptions,
-	AtomToken,
 	FamilyMetadata,
-	MutableAtomFamilyOptions,
+	RegularAtomFamily,
+	RegularAtomFamilyOptions,
+	RegularAtomOptions,
+	RegularAtomToken,
 } 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>,
+	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
-): AtomFamily<T, K> {
-	const subject = new Subject<AtomToken<T>>()
-	const atomFamily = Object.assign(
-		(key: K): AtomToken<T> => {
+): 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 existing = withdraw({ key: fullKey, type: `atom` }, store)
-			let token: AtomToken<any>
+			let token: RegularAtomToken<any>
 			if (existing) {
 				token = deposit(existing)
 			} else {
-				const individualOptions: AtomOptions<any> = {
+				const individualOptions: RegularAtomOptions<any> = {
 					key: fullKey,
 					default:
 						options.default instanceof Function
@@ -41,17 +39,7 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 				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)
-				}
+				token = createRegularAtom(individualOptions, family, store)
 				subject.next(token)
 			}
 			return token
@@ -63,9 +51,6 @@ export function createRegularAtomFamily<T, K extends Json.Serializable>(
 			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

@@ -1,69 +1,33 @@
 import type {
-	FamilyMetadata,
 	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyOptions,
-	SelectorFamily,
-	SelectorFamilyOptions,
-	SelectorToken,
+	WritableSelectorFamily,
+	WritableSelectorFamilyOptions,
 } from "atom.io"
 import type { Json } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
 
-import { newest } from "../lineage"
-import { createSelector } from "../selector"
 import type { Store } from "../store"
-import { deposit } from "../store"
-import { Subject } from "../subject"
 import { createReadonlySelectorFamily } from "./create-readonly-selector-family"
+import { createWritableSelectorFamily } from "./create-writable-selector-family"
 
 export function createSelectorFamily<T, K extends Json.Serializable>(
-	options: SelectorFamilyOptions<T, K>,
+	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): SelectorFamily<T, K>
+): WritableSelectorFamily<T, K>
 export function createSelectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, K>
 export function createSelectorFamily<T, K extends Json.Serializable>(
-	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
+	options:
+		| ReadonlySelectorFamilyOptions<T, K>
+		| WritableSelectorFamilyOptions<T, K>,
 	store: Store,
-): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
-	const isReadonly = !(`set` in options)
+): ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K> {
+	const isWritable = `set` in options
 
-	if (isReadonly) {
-		return createReadonlySelectorFamily(options, store)
+	if (isWritable) {
+		return createWritableSelectorFamily(options, store)
 	}
-	const target = newest(store)
-	const subject = new Subject<SelectorToken<T>>()
-
-	const selectorFamily = Object.assign(
-		(key: K): SelectorToken<T> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const existing = target.selectors.get(fullKey)
-			if (existing) {
-				return deposit(existing)
-			}
-			const token = createSelector<T>(
-				{
-					key: fullKey,
-					get: options.get(key),
-					set: options.set(key),
-				},
-				family,
-				store,
-			)
-			subject.next(token)
-			return token
-		},
-		{
-			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)
-	return selectorFamily
+	return createReadonlySelectorFamily(options, store)
 }

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

@@ -0,0 +1,51 @@
+import type {
+	FamilyMetadata,
+	WritableSelectorFamily,
+	WritableSelectorFamilyOptions,
+	WritableSelectorToken,
+} from "atom.io"
+import type { Json } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
+
+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>(
+	options: WritableSelectorFamilyOptions<T, K>,
+	store: Store,
+): WritableSelectorFamily<T, K> {
+	const subject = new Subject<WritableSelectorToken<T>>()
+
+	const selectorFamily = Object.assign(
+		(key: K): WritableSelectorToken<T> => {
+			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 token = createWritableSelector(
+				{
+					key: fullKey,
+					get: options.get(key),
+					set: options.set(key),
+				},
+				family,
+				store,
+			)
+			subject.next(token)
+			return token
+		},
+		{
+			key: options.key,
+			type: `selector_family`,
+			subject,
+			install: (store: Store) => createWritableSelectorFamily(options, store),
+		} as const,
+	) as WritableSelectorFamily<T, K>
+	store.families.set(options.key, selectorFamily)
+	return selectorFamily
+}

package/internal/src/index.ts

@@ -1,5 +1,9 @@
-import type { Atom } from "./atom"
-import type { ReadonlySelector, Selector } from "./selector"
+import type { FamilyMetadata } from "atom.io"
+import type { Json, JsonInterface } from "atom.io/json"
+
+import type { Transceiver } from "./mutable"
+import type { Store } from "./store"
+import type { Subject } from "./subject"
 
 export * from "./atom"
 export * from "./caching"
@@ -22,4 +26,41 @@ export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
 
-export type StateNode<T> = Atom<T> | ReadonlySelector<T> | Selector<T>
+export type BaseStateData = {
+	key: string
+	family?: FamilyMetadata
+	install: (store: Store) => void
+	subject: Subject<{ newValue: any; oldValue: any }>
+}
+
+export type RegularAtom<T> = BaseStateData & {
+	type: `atom`
+	default: T | (() => T)
+	cleanup?: () => void
+}
+export type MutableAtom<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+> = BaseStateData &
+	JsonInterface<T, J> & {
+		type: `mutable_atom`
+		default: T | (() => T)
+		cleanup?: () => void
+	}
+export type Atom<T> =
+	| RegularAtom<T>
+	| (T extends Transceiver<any> ? MutableAtom<T, any> : never)
+
+export type WritableSelector<T> = BaseStateData & {
+	type: `selector`
+	get: () => T
+	set: (newValue: T | ((oldValue: T) => T)) => void
+}
+export type ReadonlySelector<T> = BaseStateData & {
+	type: `readonly_selector`
+	get: () => T
+}
+export type Selector<T> = ReadonlySelector<T> | WritableSelector<T>
+
+export type WritableState<T> = Atom<T> | WritableSelector<T>
+export type ReadableState<T> = Atom<T> | Selector<T>

package/internal/src/lineage.ts

@@ -9,10 +9,3 @@ export function newest<T extends Lineage>(scion: T): T {
 	}
 	return scion
 }
-
-export function eldest<T extends Lineage>(scion: T): T {
-	while (scion.parent !== null) {
-		scion = scion.parent
-	}
-	return scion
-}

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

@@ -1,25 +1,71 @@
-import type { MutableAtomFamily, MutableAtomFamilyOptions } from "atom.io"
+import type {
+	MutableAtomFamily,
+	MutableAtomFamilyOptions,
+	MutableAtomOptions,
+	MutableAtomToken,
+} from "atom.io"
+import type { FamilyMetadata } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJsonFamily } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
-import type { Store } from ".."
-import { createRegularAtomFamily } from ".."
+import { newest } from "../lineage"
+import { createMutableAtom } from "../mutable"
+import { deposit, withdraw } from "../store"
+import type { Store } from "../store"
+import { Subject } from "../subject"
 import { FamilyTracker } from "./tracker-family"
 import type { Transceiver } from "./transceiver"
 
 export function createMutableAtomFamily<
-	Core extends Transceiver<any>,
-	SerializableCore extends Json.Serializable,
-	Key extends string,
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends string,
 >(
-	options: MutableAtomFamilyOptions<Core, SerializableCore, Key>,
+	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
-): MutableAtomFamily<Core, SerializableCore, Key> {
-	const coreFamily = Object.assign(
-		createRegularAtomFamily<Core, Key>(options, store),
-		options,
-	) as MutableAtomFamily<Core, SerializableCore, Key>
-	selectJsonFamily(coreFamily, options)
-	new FamilyTracker(coreFamily, store)
-	return coreFamily
+): MutableAtomFamily<T, J, K> {
+	const subject = new Subject<MutableAtomToken<T, J>>()
+	const atomFamily: MutableAtomFamily<T, J, K> = Object.assign(
+		(key: K): MutableAtomToken<T, J> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = withdraw({ key: fullKey, type: `mutable_atom` }, store)
+			let token: MutableAtomToken<T, J>
+			if (existing) {
+				token = deposit(existing)
+			} 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)
+			}
+			return token
+		},
+		{
+			key: options.key,
+			type: `mutable_atom_family`,
+			subject,
+			install: (store: Store) => createMutableAtomFamily(options, store),
+			toJson: options.toJson,
+			fromJson: options.fromJson,
+		} as const,
+	)
+
+	const target = newest(store)
+	target.families.set(options.key, atomFamily)
+	selectJsonFamily(atomFamily, options, store)
+	new FamilyTracker(atomFamily, store)
+	return atomFamily
 }