atom.io 0.15.3 → 0.15.5

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

@@ -87,6 +87,6 @@ export function createRegularAtom<T>(
 			}
 		}
 	}
-	store.subject.atomCreation.next(token)
+	store.on.atomCreation.next(token)
 	return token as AtomToken<T>
 }

package/internal/src/get-environment-data.ts

@@ -0,0 +1,18 @@
+import type { Store } from "./store"
+
+export type EnvironmentData = {
+	runtime: `browser` | `node` | `unknown`
+	store: Store
+}
+
+export function getEnvironmentData(store: Store): EnvironmentData {
+	return {
+		runtime:
+			typeof window === `undefined`
+				? typeof global === `object`
+					? `node`
+					: `unknown`
+				: `browser`,
+		store,
+	}
+}

package/internal/src/index.ts

@@ -6,6 +6,8 @@ export * from "./caching"
 export * from "./lineage"
 export * from "./families"
 export * from "./future"
+export * from "./get-environment-data"
+export * from "./ingest-updates"
 export * from "./keys"
 export * from "./lazy-map"
 export * from "./mutable"

package/internal/src/ingest-updates/index.ts

@@ -0,0 +1,3 @@
+export * from "./ingest-atom-update"
+export * from "./ingest-selector-update"
+export * from "./ingest-transaction-update"

package/internal/src/ingest-updates/ingest-atom-update.ts

@@ -0,0 +1,14 @@
+import type { KeyedStateUpdate } from "atom.io"
+import { setState } from "atom.io"
+
+import type { Store } from "../store"
+
+export function ingestAtomUpdate(
+	applying: `newValue` | `oldValue`,
+	atomUpdate: KeyedStateUpdate<any>,
+	store: Store,
+): void {
+	const { key, newValue, oldValue } = atomUpdate
+	const value = applying === `newValue` ? newValue : oldValue
+	setState({ key, type: `atom` }, value, store)
+}

package/internal/src/ingest-updates/ingest-selector-update.ts

@@ -0,0 +1,17 @@
+import type { Store } from "../store"
+import type { TimelineSelectorUpdate } from "../timeline"
+import { ingestAtomUpdate } from "./ingest-atom-update"
+
+export function ingestSelectorUpdate(
+	applying: `newValue` | `oldValue`,
+	selectorUpdate: TimelineSelectorUpdate<any>,
+	store: Store,
+): void {
+	const updates =
+		applying === `newValue`
+			? selectorUpdate.atomUpdates
+			: [...selectorUpdate.atomUpdates].reverse()
+	for (const atomUpdate of updates) {
+		ingestAtomUpdate(applying, atomUpdate, store)
+	}
+}

package/internal/src/ingest-updates/ingest-transaction-update.ts

@@ -0,0 +1,22 @@
+import type { TransactionUpdate } from "atom.io"
+
+import type { Store } from "../store"
+import { ingestAtomUpdate } from "./ingest-atom-update"
+
+export function ingestTransactionUpdate(
+	applying: `newValue` | `oldValue`,
+	transactionUpdate: TransactionUpdate<any>,
+	store: Store,
+): void {
+	const updates =
+		applying === `newValue`
+			? transactionUpdate.updates
+			: [...transactionUpdate.updates].reverse()
+	for (const updateFromTransaction of updates) {
+		if (`newValue` in updateFromTransaction) {
+			ingestAtomUpdate(applying, updateFromTransaction, store)
+		} else {
+			ingestTransactionUpdate(applying, updateFromTransaction, store)
+		}
+	}
+}

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 { createRegularAtom, deleteAtom } from "../atom"
+import { createRegularAtom } from "../atom"
 import type { Transceiver } from "./transceiver"
 
 /**
@@ -63,7 +63,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			}`,
 			(update) => {
 				if (target.operation.open) {
-					const unsubscribe = target.subject.operationStatus.subscribe(
+					const unsubscribe = target.on.operationClose.subscribe(
 						mutableState.key,
 						() => {
 							unsubscribe()
@@ -90,7 +90,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 						}`,
 						(update) => {
 							if (target.operation.open) {
-								const unsubscribe = target.subject.operationStatus.subscribe(
+								const unsubscribe = target.on.operationClose.subscribe(
 									mutableState.key,
 									() => {
 										unsubscribe()
@@ -148,7 +148,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					}
 				}
 
-				const unsubscribe = store.subject.operationStatus.subscribe(
+				const unsubscribe = store.on.operationClose.subscribe(
 					latestUpdateState.key,
 					() => {
 						unsubscribe()

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

@@ -1,12 +1,10 @@
-import type { ReadonlySelectorToken, StateToken } from "atom.io"
+import type { ReadableToken } from "atom.io"
 
 import type { Store } from "./store"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 
-function prettyPrintTokenType(
-	token: ReadonlySelectorToken<any> | StateToken<any>,
-) {
+function prettyPrintTokenType(token: ReadableToken<any>) {
 	if (token.type === `readonly_selector`) {
 		return `Readonly Selector`
 	}
@@ -14,10 +12,7 @@ function prettyPrintTokenType(
 }
 
 export class NotFoundError extends Error {
-	public constructor(
-		token: ReadonlySelectorToken<any> | StateToken<any>,
-		store: Store,
-	) {
+	public constructor(token: ReadableToken<any>, store: Store) {
 		super(
 			`${prettyPrintTokenType(token)} "${token.key}" not found in store "${
 				store.config.name

package/internal/src/operation.ts

@@ -1,4 +1,4 @@
-import type { StateToken } from "atom.io"
+import type { WritableToken } from "atom.io"
 
 import { newest } from "./lineage"
 import type { Store } from "./store"
@@ -12,11 +12,11 @@ export type OperationProgress =
 			done: Set<string>
 			prev: Map<string, any>
 			time: number
-			token: StateToken<any>
+			token: WritableToken<any>
 	  }
 
 export const openOperation = (
-	token: StateToken<any>,
+	token: WritableToken<any>,
 	store: Store,
 ): `rejection` | undefined => {
 	if (store.operation.open) {
@@ -56,7 +56,7 @@ export const closeOperation = (store: Store): void => {
 		)
 	}
 	store.operation = { open: false }
-	store.subject.operationStatus.next(store.operation)
+	store.on.operationClose.next(store.operation)
 }
 
 export const isDone = (key: string, store: Store): boolean => {

package/internal/src/selector/create-read-write-selector.ts

@@ -17,10 +17,12 @@ export const createReadWriteSelector = <T>(
 ): SelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const transactors = registerSelector(options.key, store)
+	const { find, get } = transactors
+	const readonlyTransactors = { find, get }
 
-	const { get, set } = registerSelector(options.key, store)
 	const getSelf = () => {
-		const value = options.get({ get })
+		const value = options.get(readonlyTransactors)
 		cacheValue(options.key, value, subject, newest(store))
 		return value
 	}
@@ -43,7 +45,7 @@ export const createReadWriteSelector = <T>(
 		if (target.transactionMeta === null) {
 			subject.next({ newValue, oldValue })
 		}
-		options.set({ get, set }, newValue)
+		options.set(transactors, newValue)
 	}
 	const mySelector: Selector<T> = {
 		...options,
@@ -64,6 +66,6 @@ export const createReadWriteSelector = <T>(
 	if (family) {
 		token.family = family
 	}
-	store.subject.selectorCreation.next(token)
+	store.on.selectorCreation.next(token)
 	return token
 }

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

@@ -20,9 +20,9 @@ export const createReadonlySelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 
-	const { get } = registerSelector(options.key, store)
+	const { get, find } = registerSelector(options.key, store)
 	const getSelf = () => {
-		const value = options.get({ get })
+		const value = options.get({ get, find })
 		cacheValue(options.key, value, subject, store)
 		return value
 	}
@@ -51,6 +51,6 @@ export const createReadonlySelector = <T>(
 	if (family) {
 		token.family = family
 	}
-	store.subject.selectorCreation.next(token)
+	store.on.selectorCreation.next(token)
 	return token
 }

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

@@ -1,4 +1,5 @@
-import type { Transactors } from "atom.io"
+import type { Transactors, findState } from "atom.io"
+import { findInStore } from "atom.io"
 
 import { newest } from "../lineage"
 import { readOrComputeValue } from "../read-or-compute-value"
@@ -43,13 +44,14 @@ export const registerSelector = (
 		updateSelectorAtoms(selectorKey, dependency, store)
 		return dependencyValue
 	},
-	set: (stateToken, newValue) => {
-		const state = withdraw(stateToken, store)
+	set: (WritableToken, newValue) => {
+		const state = withdraw(WritableToken, store)
 		if (state === undefined) {
 			throw new Error(
-				`State "${stateToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
+				`State "${WritableToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,
 			)
 		}
 		setAtomOrSelector(state, newValue, store)
 	},
+	find: ((token, key) => findInStore(token, key, store)) as typeof findState,
 })

package/internal/src/selector/update-selector-atoms.ts

@@ -1,4 +1,4 @@
-import type { ReadonlySelectorToken, StateToken } from "atom.io"
+import type { ReadonlySelectorToken, WritableToken } from "atom.io"
 
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -6,7 +6,7 @@ import { traceSelectorAtoms } from "./trace-selector-atoms"
 
 export const updateSelectorAtoms = (
 	selectorKey: string,
-	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>,
 	store: Store,
 ): void => {
 	const target = newest(store)

package/internal/src/store/deposit.ts

@@ -1,26 +1,26 @@
 import type {
 	AtomToken,
+	ReadableToken,
 	ReadonlySelectorToken,
 	SelectorToken,
-	StateToken,
 	TransactionToken,
+	WritableToken,
 	ƒn,
 } from "atom.io"
 
+import type { StateNode } from ".."
 import type { Atom } from "../atom"
 import type { ReadonlySelector, Selector } from "../selector"
 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>): StateToken<T>
+export function deposit<T>(state: Atom<T> | Selector<T>): WritableToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(
 	state: Transaction<T extends ƒn ? T : never>,
 ): TransactionToken<T>
-export function deposit<T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-): ReadonlySelectorToken<T> | StateToken<T>
+export function deposit<T>(state: StateNode<T>): ReadableToken<T>
 export function deposit<T>(
 	state:
 		| Atom<T>

package/internal/src/store/store.ts

@@ -47,7 +47,7 @@ export class Store implements Lineage {
 		| SelectorFamily<any, any>
 	>()
 
-	public timelines = new Map<string, Timeline>()
+	public timelines = new Map<string, Timeline<any>>()
 	public transactions = new Map<string, Transaction<ƒn>>()
 
 	public atomsThatAreDefault = new Set<string>()
@@ -74,15 +74,15 @@ export class Store implements Lineage {
 		},
 	)
 
-	public subject = {
+	public on = {
 		atomCreation: new Subject<AtomToken<unknown>>(),
 		selectorCreation: new Subject<
 			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
 		>(),
 		transactionCreation: new Subject<TransactionToken<ƒn>>(),
-		timelineCreation: new Subject<TimelineToken>(),
+		timelineCreation: new Subject<TimelineToken<unknown>>(),
 		transactionApplying: new StatefulSubject<TransactionMeta<ƒn> | null>(null),
-		operationStatus: new Subject<OperationProgress>(),
+		operationClose: new Subject<OperationProgress>(),
 	}
 	public operation: OperationProgress = { open: false }
 	public transactionMeta: TransactionMeta<ƒn> | null = null

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

@@ -1,10 +1,11 @@
 import type {
 	AtomToken,
+	ReadableToken,
 	ReadonlySelectorToken,
 	SelectorToken,
-	StateToken,
+	WritableToken,
 } from "atom.io"
-import type { Atom, ReadonlySelector, Selector, Store } from ".."
+import type { Atom, ReadonlySelector, Selector, StateNode, Store } from ".."
 import { newest, withdraw } from ".."
 
 export function withdrawNewFamilyMember<T>(
@@ -20,21 +21,17 @@ export function withdrawNewFamilyMember<T>(
 	store: Store,
 ): ReadonlySelector<T> | undefined
 export function withdrawNewFamilyMember<T>(
-	token: StateToken<T>,
+	token: WritableToken<T>,
 	store: Store,
 ): Atom<T> | Selector<T> | undefined
 export function withdrawNewFamilyMember<T>(
-	token: ReadonlySelectorToken<T> | StateToken<T>,
+	token: ReadableToken<T>,
 	store: Store,
-): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined
+): StateNode<T> | undefined
 export function withdrawNewFamilyMember<T>(
-	token:
-		| AtomToken<T>
-		| ReadonlySelectorToken<T>
-		| SelectorToken<T>
-		| StateToken<T>,
+	token: ReadableToken<T>,
 	store: Store,
-): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined {
+): StateNode<T> | undefined {
 	if (token.family) {
 		store.logger.info(
 			`👪`,

package/internal/src/store/withdraw.ts

@@ -1,13 +1,16 @@
 import type {
 	AtomToken,
+	ReadableToken,
 	ReadonlySelectorToken,
 	SelectorToken,
-	StateToken,
+	TimelineManageable,
 	TimelineToken,
 	TransactionToken,
+	WritableToken,
 	ƒn,
 } from "atom.io"
 
+import type { StateNode } from ".."
 import type { Atom } from "../atom"
 import type { ReadonlySelector, Selector } from "../selector"
 import type { Timeline } from "../timeline"
@@ -18,7 +21,7 @@ type Withdrawable<T> =
 	| Atom<T>
 	| ReadonlySelector<T>
 	| Selector<T>
-	| Timeline
+	| Timeline<T extends TimelineManageable ? T : never>
 	| Transaction<T extends ƒn ? T : never>
 
 export function withdraw<T>(
@@ -30,7 +33,7 @@ export function withdraw<T>(
 	store: Store,
 ): Selector<T> | undefined
 export function withdraw<T>(
-	token: StateToken<T>,
+	token: WritableToken<T>,
 	store: Store,
 ): Atom<T> | Selector<T> | undefined
 export function withdraw<T>(
@@ -42,19 +45,15 @@ export function withdraw<T>(
 	store: Store,
 ): Transaction<T extends ƒn ? T : never> | undefined
 export function withdraw<T>(
-	token: ReadonlySelectorToken<T> | StateToken<T>,
+	token: ReadableToken<T>,
 	store: Store,
-): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined
+): StateNode<T> | undefined
 export function withdraw<T>(
-	token: TimelineToken,
+	token: TimelineToken<T>,
 	store: Store,
-): Timeline | undefined
+): Timeline<T extends TimelineManageable ? T : never> | undefined
 export function withdraw<T>(
-	token:
-		| ReadonlySelectorToken<T>
-		| StateToken<T>
-		| TimelineToken
-		| TransactionToken<T>,
+	token: ReadableToken<T> | TimelineToken<T> | TransactionToken<T>,
 	store: Store,
 ): Withdrawable<T> | undefined {
 	let withdrawn: Withdrawable<T> | undefined

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

@@ -1,10 +1,10 @@
-import type { ReadonlySelectorToken, StateToken, UpdateHandler } from "atom.io"
+import type { ReadableToken, UpdateHandler } from "atom.io"
 import type { Store } from "../store"
 import { withdraw, withdrawNewFamilyMember } from "../store"
 import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"
 
 export function subscribeToState<T>(
-	token: ReadonlySelectorToken<T> | StateToken<T>,
+	token: ReadableToken<T>,
 	handleUpdate: UpdateHandler<T>,
 	key: string,
 	store: Store,

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

@@ -1,10 +1,10 @@
-import type { TimelineToken, TimelineUpdate } from "atom.io"
+import type { TimelineManageable, TimelineToken, TimelineUpdate } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { withdraw } from "atom.io/internal"
 
-export const subscribeToTimeline = (
-	token: TimelineToken,
-	handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void,
+export const subscribeToTimeline = <ManagedAtom extends TimelineManageable>(
+	token: TimelineToken<ManagedAtom>,
+	handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void,
 	key: string,
 	store: Store,
 ): (() => void) => {

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

@@ -13,7 +13,7 @@ import type {
 
 export const addAtomToTimeline = (
 	atomToken: AtomToken<any>,
-	tl: Timeline,
+	tl: Timeline<any>,
 	store: Store,
 ): void => {
 	let maybeAtom = withdraw(atomToken, store)
@@ -40,9 +40,8 @@ export const addAtomToTimeline = (
 			store.operation.open && store.operation.token.type === `selector`
 				? store.operation.time
 				: null
-		const currentTransactionKey =
-			target.subject.transactionApplying.state?.update.key
-		const currentTransactionTime = target.subject.transactionApplying.state?.time
+		const currentTransactionKey = target.on.transactionApplying.state?.update.key
+		const currentTransactionTime = target.on.transactionApplying.state?.time
 
 		store.logger.info(
 			`⏳`,
@@ -62,7 +61,8 @@ export const addAtomToTimeline = (
 		)
 		if (tl.timeTraveling === null) {
 			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
-				const mostRecentUpdate: TimelineUpdate | undefined = tl.history.at(-1)
+				const mostRecentUpdate: TimelineUpdate<any> | undefined =
+					tl.history.at(-1)
 				if (mostRecentUpdate === undefined) {
 					throw new Error(
 						`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
@@ -155,7 +155,7 @@ export const addAtomToTimeline = (
 					)
 				}
 			} else if (currentSelectorKey && currentSelectorTime) {
-				let latestUpdate: TimelineUpdate | undefined = tl.history.at(-1)
+				let latestUpdate: TimelineUpdate<any> | undefined = tl.history.at(-1)
 
 				if (currentSelectorTime !== tl.selectorTime) {
 					latestUpdate = {
@@ -217,7 +217,7 @@ export const addAtomToTimeline = (
 				if (tl.at !== tl.history.length) {
 					tl.history.splice(tl.at)
 				}
-				const atomUpdate: TimelineAtomUpdate = {
+				const atomUpdate: TimelineAtomUpdate<any> = {
 					type: `atom_update`,
 					timestamp,
 					key: atom.key,

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

@@ -1,9 +1,13 @@
 import type {
+	AtomFamily,
+	AtomToken,
 	FamilyMetadata,
 	StateUpdate,
+	TimelineManageable,
 	TimelineOptions,
 	TimelineToken,
 	TimelineUpdate,
+	TokenType,
 	TransactionUpdate,
 	ƒn,
 } from "atom.io"
@@ -16,17 +20,18 @@ import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
 import { addAtomToTimeline } from "./add-atom-to-timeline"
 
-export type TimelineAtomUpdate = StateUpdate<unknown> & {
-	key: string
-	type: `atom_update`
-	timestamp: number
-	family?: FamilyMetadata
-}
-export type TimelineSelectorUpdate = {
+export type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> =
+	StateUpdate<TokenType<ManagedAtom>> & {
+		key: string
+		type: `atom_update`
+		timestamp: number
+		family?: FamilyMetadata
+	}
+export type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
 	key: string
 	type: `selector_update`
 	timestamp: number
-	atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
+	atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[]
 }
 export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 	key: string
@@ -34,31 +39,34 @@ export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 	timestamp: number
 }
 
-export type Timeline = {
+export type Timeline<ManagedAtom extends TimelineManageable> = {
 	type: `timeline`
 	key: string
 	at: number
-	shouldCapture?: (update: TimelineUpdate, timeline: Timeline) => boolean
+	shouldCapture?: (
+		update: TimelineUpdate<TimelineManageable>,
+		timeline: Timeline<ManagedAtom>,
+	) => boolean
 	timeTraveling: `into_future` | `into_past` | null
-	history: TimelineUpdate[]
+	history: TimelineUpdate<ManagedAtom>[]
 	selectorTime: number | null
 	transactionKey: string | null
 	install: (store: Store) => void
 	subject: Subject<
-		| TimelineAtomUpdate
-		| TimelineSelectorUpdate
+		| TimelineAtomUpdate<ManagedAtom>
+		| TimelineSelectorUpdate<ManagedAtom>
 		| TimelineTransactionUpdate
 		| `redo`
 		| `undo`
 	>
 }
 
-export function createTimeline(
-	options: TimelineOptions,
+export function createTimeline<ManagedAtom extends TimelineManageable>(
+	options: TimelineOptions<ManagedAtom>,
 	store: Store,
-	data?: Timeline,
-): TimelineToken {
-	const tl: Timeline = {
+	data?: Timeline<ManagedAtom>,
+): TimelineToken<ManagedAtom> {
+	const tl: Timeline<ManagedAtom> = {
 		type: `timeline`,
 		key: options.key,
 		at: 0,
@@ -88,7 +96,7 @@ export function createTimeline(
 			continue
 		}
 		if (tokenOrFamily.type === `atom_family`) {
-			let family = tokenOrFamily
+			let family: AtomFamily<any> = tokenOrFamily
 			if (isMutable(family)) {
 				family = getUpdateFamily(family, store)
 				atomKey = family.key
@@ -146,10 +154,10 @@ export function createTimeline(
 	}
 
 	store.timelines.set(options.key, tl)
-	const token: TimelineToken = {
+	const token: TimelineToken<ManagedAtom> = {
 		key: timelineKey,
 		type: `timeline`,
 	}
-	store.subject.timelineCreation.next(token)
+	store.on.timelineCreation.next(token)
 	return token
 }