atom.io 0.15.6 → 0.16.0

package/internal/src/store/deposit.ts

@@ -1,35 +1,47 @@
 import type {
-	AtomToken,
+	MutableAtomToken,
 	ReadableToken,
 	ReadonlySelectorToken,
+	RegularAtomToken,
 	SelectorToken,
 	TransactionToken,
+	WritableSelectorToken,
 	WritableToken,
 	ƒn,
 } from "atom.io"
 
-import type { StateNode } from ".."
-import type { Atom } from "../atom"
-import type { ReadonlySelector, Selector } from "../selector"
+import type {
+	MutableAtom,
+	ReadableState,
+	ReadonlySelector,
+	RegularAtom,
+	Transceiver,
+	WritableSelector,
+	WritableState,
+} from ".."
 import type { Transaction } from "../transaction"
 
-export function deposit<T>(state: Atom<T>): AtomToken<T>
-export function deposit<T>(state: Selector<T>): SelectorToken<T>
-export function deposit<T>(state: Atom<T> | Selector<T>): WritableToken<T>
+export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
+export function deposit<T extends Transceiver<any>>(
+	state: MutableAtom<T, any>,
+): MutableAtomToken<T, any>
+export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
+export function deposit<T>(state: WritableState<T>): WritableToken<T>
 export function deposit<T>(
 	state: Transaction<T extends ƒn ? T : never>,
 ): TransactionToken<T>
-export function deposit<T>(state: StateNode<T>): ReadableToken<T>
+export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
 export function deposit<T>(
 	state:
-		| Atom<T>
 		| ReadonlySelector<T>
-		| Selector<T>
-		| Transaction<T extends ƒn ? T : never>,
+		| RegularAtom<T>
+		| Transaction<T extends ƒn ? T : never>
+		| WritableSelector<T>
+		| (T extends Transceiver<any> ? MutableAtom<T, any> : never),
 ):
-	| AtomToken<T>
-	| ReadonlySelectorToken<T>
+	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
+	| RegularAtomToken<T>
 	| SelectorToken<T>
 	| TransactionToken<T> {
 	const token = {

package/internal/src/store/store.ts

@@ -1,30 +1,31 @@
 import { AtomIOLogger } from "atom.io"
 import type {
-	AtomFamily,
 	AtomToken,
 	Logger,
+	MutableAtomFamily,
 	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
-	SelectorFamily,
-	SelectorToken,
+	RegularAtomFamily,
+	RegularAtomToken,
 	TimelineToken,
 	TransactionToken,
+	WritableSelectorFamily,
+	WritableSelectorToken,
 	ƒn,
 } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
-import type { Atom } from "../atom"
+import type {
+	Atom,
+	ReadonlySelector,
+	Tracker,
+	Transceiver,
+	WritableSelector,
+} from ".."
 import type { Lineage } from "../lineage"
-import {
-	type MutableAtom,
-	type Tracker,
-	type Transceiver,
-	getJsonToken,
-	getUpdateToken,
-} from "../mutable"
+import { getJsonToken, getUpdateToken } from "../mutable"
 import type { OperationProgress } from "../operation"
-import type { ReadonlySelector, Selector } from "../selector"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
 import type { Transaction, TransactionMeta } from "../transaction"
@@ -35,16 +36,17 @@ export class Store implements Lineage {
 
 	public valueMap = new Map<string, any>()
 
-	public atoms = new Map<string, Atom<any> | MutableAtom<any>>()
-	public selectors = new Map<string, Selector<any>>()
+	public atoms = new Map<string, Atom<any>>()
+	public selectors = new Map<string, WritableSelector<any>>()
 	public readonlySelectors = new Map<string, ReadonlySelector<any>>()
 
 	public trackers = new Map<string, Tracker<Transceiver<any>>>()
 	public families = new Map<
 		string,
-		| AtomFamily<any, any>
+		| MutableAtomFamily<any, any, any>
 		| ReadonlySelectorFamily<any, any>
-		| SelectorFamily<any, any>
+		| RegularAtomFamily<any, any>
+		| WritableSelectorFamily<any, any>
 	>()
 
 	public timelines = new Map<string, Timeline<any>>()
@@ -77,7 +79,7 @@ export class Store implements Lineage {
 	public on = {
 		atomCreation: new Subject<AtomToken<unknown>>(),
 		selectorCreation: new Subject<
-			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
 		>(),
 		transactionCreation: new Subject<TransactionToken<ƒn>>(),
 		timelineCreation: new Subject<TimelineToken<unknown>>(),
@@ -112,9 +114,7 @@ export class Store implements Lineage {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
-			this.transactionMeta = store?.transactionMeta
-				? { ...store?.transactionMeta }
-				: null
+			this.transactionMeta = null
 			this.config = {
 				...store?.config,
 				name,
@@ -128,7 +128,7 @@ export class Store implements Lineage {
 					continue
 				}
 				atom.install(this)
-				if (`mutable` in atom) {
+				if (atom.type === `mutable_atom`) {
 					const originalJsonToken = getJsonToken(atom)
 					const originalUpdateToken = getUpdateToken(atom)
 					mutableHelpers.add(originalJsonToken.key)

package/internal/src/store/withdraw-new-family-member.ts

@@ -1,21 +1,28 @@
 import type {
-	AtomToken,
 	ReadableToken,
 	ReadonlySelectorToken,
-	SelectorToken,
+	RegularAtomToken,
+	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Atom, ReadonlySelector, Selector, StateNode, Store } from ".."
+import type {
+	Atom,
+	ReadableState,
+	ReadonlySelector,
+	Store,
+	WritableSelector,
+	WritableState,
+} from ".."
 import { newest, withdraw } from ".."
 
 export function withdrawNewFamilyMember<T>(
-	token: AtomToken<T>,
+	token: RegularAtomToken<T>,
 	store: Store,
 ): Atom<T> | undefined
 export function withdrawNewFamilyMember<T>(
-	token: SelectorToken<T>,
+	token: WritableSelectorToken<T>,
 	store: Store,
-): Selector<T> | undefined
+): WritableSelector<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token: ReadonlySelectorToken<T>,
 	store: Store,
@@ -23,15 +30,15 @@ export function withdrawNewFamilyMember<T>(
 export function withdrawNewFamilyMember<T>(
 	token: WritableToken<T>,
 	store: Store,
-): Atom<T> | Selector<T> | undefined
+): WritableState<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token: ReadableToken<T>,
 	store: Store,
-): StateNode<T> | undefined
+): ReadableState<T> | undefined
 export function withdrawNewFamilyMember<T>(
 	token: ReadableToken<T>,
 	store: Store,
-): StateNode<T> | undefined {
+): ReadableState<T> | undefined {
 	if (token.family) {
 		store.logger.info(
 			`👪`,

package/internal/src/store/withdraw.ts

@@ -1,33 +1,55 @@
 import type {
 	AtomToken,
+	MutableAtomToken,
 	ReadableToken,
 	ReadonlySelectorToken,
+	RegularAtomToken,
 	SelectorToken,
 	TimelineManageable,
 	TimelineToken,
 	TransactionToken,
+	WritableSelectorToken,
 	WritableToken,
 	ƒn,
 } from "atom.io"
 
-import type { StateNode } from ".."
-import type { Atom } from "../atom"
-import type { ReadonlySelector, Selector } from "../selector"
+import type {
+	Atom,
+	MutableAtom,
+	ReadableState,
+	ReadonlySelector,
+	RegularAtom,
+	Selector,
+	Transceiver,
+	WritableSelector,
+	WritableState,
+} from ".."
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-type Withdrawable<T> =
-	| Atom<T>
-	| ReadonlySelector<T>
-	| Selector<T>
-	| Timeline<T extends TimelineManageable ? T : never>
-	| Transaction<T extends ƒn ? T : never>
+export type Withdrawable = ReadableState<any> | Timeline<any> | Transaction<any>
 
+export function withdraw<T>(
+	token: RegularAtomToken<T>,
+	store: Store,
+): RegularAtom<T> | undefined
+export function withdraw<T extends Transceiver<any>>(
+	token: MutableAtomToken<T, any>,
+	store: Store,
+): MutableAtom<T, any> | undefined
 export function withdraw<T>(
 	token: AtomToken<T>,
 	store: Store,
 ): Atom<T> | undefined
+export function withdraw<T>(
+	token: WritableSelectorToken<T>,
+	store: Store,
+): WritableSelector<T> | undefined
+export function withdraw<T>(
+	token: ReadonlySelectorToken<T>,
+	store: Store,
+): ReadonlySelector<T> | undefined
 export function withdraw<T>(
 	token: SelectorToken<T>,
 	store: Store,
@@ -35,32 +57,34 @@ export function withdraw<T>(
 export function withdraw<T>(
 	token: WritableToken<T>,
 	store: Store,
-): Atom<T> | Selector<T> | undefined
+): WritableState<T> | undefined
 export function withdraw<T>(
-	token: ReadonlySelectorToken<T>,
+	token: ReadableToken<T>,
 	store: Store,
-): ReadonlySelector<T> | undefined
+): ReadableState<T> | undefined
 export function withdraw<T>(
 	token: TransactionToken<T>,
 	store: Store,
 ): Transaction<T extends ƒn ? T : never> | undefined
-export function withdraw<T>(
-	token: ReadableToken<T>,
-	store: Store,
-): StateNode<T> | undefined
 export function withdraw<T>(
 	token: TimelineToken<T>,
 	store: Store,
 ): Timeline<T extends TimelineManageable ? T : never> | undefined
 export function withdraw<T>(
-	token: ReadableToken<T> | TimelineToken<T> | TransactionToken<T>,
+	token:
+		| RegularAtomToken<T>
+		| SelectorToken<T>
+		| TimelineToken<T>
+		| TransactionToken<T>
+		| (T extends Transceiver<any> ? MutableAtomToken<T, any> : never),
 	store: Store,
-): Withdrawable<T> | undefined {
-	let withdrawn: Withdrawable<T> | undefined
+): Withdrawable | undefined {
+	let withdrawn: Withdrawable | undefined
 	let target: Store | null = store
 	while (target !== null) {
 		switch (token.type) {
 			case `atom`:
+			case `mutable_atom`:
 				withdrawn = target.atoms.get(token.key)
 				break
 			case `selector`:

package/internal/src/subscribe/recall-state.ts

@@ -1,12 +1,8 @@
-import type { Atom } from "../atom"
+import type { ReadableState } from ".."
 import { newest } from "../lineage"
-import type { ReadonlySelector, Selector } from "../selector"
 import type { Store } from "../store"
 
-export const recallState = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	store: Store,
-): T => {
+export const recallState = <T>(state: ReadableState<T>, store: Store): T => {
 	const target = newest(store)
 	if (!target.operation.open) {
 		return target.valueMap.get(state.key)

package/internal/src/subscribe/subscribe-to-root-atoms.ts

@@ -1,54 +1,52 @@
+import type { Selector } from ".."
 import { newest } from "../lineage"
 import { readOrComputeValue } from "../read-or-compute-value"
-import type { ReadonlySelector, Selector } from "../selector"
 import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { recallState } from "./recall-state"
 
 export const subscribeToRootAtoms = <T>(
-	state: ReadonlySelector<T> | Selector<T>,
+	selector: Selector<T>,
 	store: Store,
 ): (() => void)[] | null => {
 	const target = newest(store)
-	const dependencySubscriptions =
-		`default` in state
-			? null
-			: traceAllSelectorAtoms(state.key, store).map((atomKey) => {
-					const atom = target.atoms.get(atomKey)
-					if (atom === undefined) {
-						throw new Error(
-							`Atom "${atomKey}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
-						)
-					}
-					return atom.subject.subscribe(
-						`${state.type}:${state.key}`,
-						(atomChange) => {
-							store.logger.info(
-								`📢`,
-								state.type,
-								state.key,
-								`root`,
-								atomKey,
-								`went`,
-								atomChange.oldValue,
-								`->`,
-								atomChange.newValue,
-							)
-							const oldValue = recallState(state, target)
-							// ❌ this retrieves a stale cached value when applying a transaction on the server
-							const newValue = readOrComputeValue(state, target)
-							store.logger.info(
-								`✨`,
-								state.type,
-								state.key,
-								`went`,
-								oldValue,
-								`->`,
-								newValue,
-							)
-							state.subject.next({ newValue, oldValue })
-						},
+	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
+		(atomKey) => {
+			const atom = target.atoms.get(atomKey)
+			if (atom === undefined) {
+				throw new Error(
+					`Atom "${atomKey}", a dependency of selector "${selector.key}", not found in store "${store.config.name}".`,
+				)
+			}
+			return atom.subject.subscribe(
+				`${selector.type}:${selector.key}`,
+				(atomChange) => {
+					store.logger.info(
+						`📢`,
+						selector.type,
+						selector.key,
+						`root`,
+						atomKey,
+						`went`,
+						atomChange.oldValue,
+						`->`,
+						atomChange.newValue,
 					)
-			  })
+					const oldValue = recallState(selector, target)
+					const newValue = readOrComputeValue(selector, target)
+					store.logger.info(
+						`✨`,
+						selector.type,
+						selector.key,
+						`went`,
+						oldValue,
+						`->`,
+						newValue,
+					)
+					selector.subject.next({ newValue, oldValue })
+				},
+			)
+		},
+	)
 	return dependencySubscriptions
 }

package/internal/src/subscribe/subscribe-to-state.ts

@@ -19,7 +19,9 @@ export function subscribeToState<T>(
 	const unsubFunction = state.subject.subscribe(key, handleUpdate)
 	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`)
 	const dependencyUnsubFunctions =
-		state.type !== `atom` ? subscribeToRootAtoms(state, store) : null
+		state.type !== `atom` && state.type !== `mutable_atom`
+			? subscribeToRootAtoms(state, store)
+			: null
 
 	const unsubscribe =
 		dependencyUnsubFunctions === null

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -1,5 +1,5 @@
-import type { TransactionUpdate, ƒn } from "atom.io"
-import type { AtomToken, TimelineUpdate } from "atom.io"
+import type { AtomToken, TransactionUpdate, ƒn } from "atom.io"
+import type { TimelineUpdate } from "atom.io"
 
 import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
@@ -17,9 +17,8 @@ export const addAtomToTimeline = (
 	store: Store,
 ): void => {
 	let maybeAtom = withdraw(atomToken, store)
-	if (maybeAtom?.mutable) {
-		console.log(`adding transceiver to timeline`, atomToken.key)
-		const updateToken = getUpdateToken(atomToken)
+	if (maybeAtom?.type === `mutable_atom`) {
+		const updateToken = getUpdateToken(maybeAtom)
 		maybeAtom = withdraw(updateToken, store)
 	}
 	const atom = maybeAtom
@@ -28,6 +27,7 @@ export const addAtomToTimeline = (
 			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
 		)
 	}
+	store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key })
 
 	atom.subject.subscribe(`timeline`, (update) => {
 		// debugger

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

@@ -1,6 +1,5 @@
 import type {
 	AtomFamily,
-	AtomToken,
 	FamilyMetadata,
 	StateUpdate,
 	TimelineManageable,
@@ -13,9 +12,7 @@ import type {
 } from "atom.io"
 
 import { newest } from "../lineage"
-import { getUpdateToken } from "../mutable"
-import { getUpdateFamily } from "../mutable/get-update-family"
-import { isMutable } from "../mutable/is-mutable"
+import { getUpdateToken, isMutable } from "../mutable"
 import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
 import { addAtomToTimeline } from "./add-atom-to-timeline"
@@ -85,27 +82,18 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 	const target = newest(store)
 	for (const tokenOrFamily of options.atoms) {
 		let atomKey = tokenOrFamily.key
-		const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey)
-		if (existingTimelineKey) {
-			store.logger.error(
-				`❌`,
-				`timeline`,
-				options.key,
-				`Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`,
-			)
-			continue
-		}
-		if (tokenOrFamily.type === `atom_family`) {
-			let family: AtomFamily<any> = tokenOrFamily
-			if (isMutable(family)) {
-				family = getUpdateFamily(family, store)
-				atomKey = family.key
-			}
+		if (
+			tokenOrFamily.type === `atom_family` ||
+			tokenOrFamily.type === `mutable_atom_family`
+		) {
+			const family: AtomFamily<any> = tokenOrFamily
+			const familyKey = family.key
+			target.timelineAtoms.set({ atomKey: familyKey, timelineKey })
 			family.subject.subscribe(`timeline:${options.key}`, (token) => {
 				addAtomToTimeline(token, tl, store)
 			})
 			for (const atom of target.atoms.values()) {
-				if (atom.family?.key === family.key) {
+				if (atom.family?.key === familyKey) {
 					addAtomToTimeline(atom, tl, store)
 				}
 			}
@@ -148,9 +136,18 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 					continue
 				}
 			}
+			const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey)
+			if (existingTimelineKey) {
+				store.logger.error(
+					`❌`,
+					`timeline`,
+					options.key,
+					`Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`,
+				)
+				continue
+			}
 			addAtomToTimeline(atom, tl, store)
 		}
-		target.timelineAtoms.set({ atomKey, timelineKey })
 	}
 
 	store.timelines.set(options.key, tl)

package/introspection/dist/index.cjs

@@ -99,12 +99,11 @@ var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
     void 0,
     store
   );
-  return Internal.createSelector(
+  return Internal.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index`,
       get: ({ get }) => get(atomTokenIndexState__INTERNAL)
     },
-    void 0,
     store
   );
 };
@@ -172,12 +171,11 @@ var attachSelectorIndex = (store = Internal.IMPLICIT.STORE) => {
     void 0,
     store
   );
-  return Internal.createSelector(
+  return Internal.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index`,
       get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
     },
-    void 0,
     Internal.IMPLICIT.STORE
   );
 };
@@ -253,12 +251,11 @@ var attachTimelineIndex = (store = Internal.IMPLICIT.STORE) => {
     void 0,
     store
   );
-  const timelineTokenIndex = Internal.createSelector(
+  const timelineTokenIndex = Internal.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index`,
       get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
     },
-    void 0,
     store
   );
   return timelineTokenIndex;
@@ -284,12 +281,11 @@ var attachTransactionIndex = (store = Internal.IMPLICIT.STORE) => {
     void 0,
     store
   );
-  const transactionTokenIndex = Internal.createSelector(
+  const transactionTokenIndex = Internal.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index`,
       get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
     },
-    void 0,
     store
   );
   return transactionTokenIndex;