atom.io 0.6.9 → 0.7.0

package/internal/src/store/deposit.ts

@@ -0,0 +1,43 @@
+import type {
+	AtomToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+	StateToken,
+	TransactionToken,
+	ƒn,
+} from "atom.io"
+
+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: 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:
+		| Atom<T>
+		| ReadonlySelector<T>
+		| Selector<T>
+		| Transaction<T extends ƒn ? T : never>,
+):
+	| AtomToken<T>
+	| ReadonlySelectorToken<T>
+	| SelectorToken<T>
+	| TransactionToken<T> {
+	const token = {
+		key: state.key,
+		type: state.type,
+	} as any
+	if (`family` in state) {
+		token.family = state.family
+	}
+	return token
+}

package/internal/src/store/index.ts

@@ -0,0 +1,5 @@
+export * from "./deposit"
+export * from "./lookup"
+export * from "./store"
+export * from "./withdraw"
+export * from "./withdraw-new-family-member"

package/internal/src/store/lookup.ts

@@ -0,0 +1,26 @@
+import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "atom.io"
+
+import { target } from "../transaction"
+import type { Store } from "./store"
+
+export function lookup(
+	key: string,
+	store: Store,
+): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown> {
+	const core = target(store)
+	let type: string = core.atoms.has(key)
+		? `atom`
+		: core.selectors.has(key)
+		? `selector`
+		: core.readonlySelectors.has(key)
+		? `readonly_selector`
+		: ``
+	if (!type) {
+		const errorId = Math.random().toString(36)
+		type = `🚨 This state could not be found by lookup! Check the console for "${errorId}"`
+		store.config.logger?.error(
+			`${errorId}: Key "${key}" does not exist in the store.`,
+		)
+	}
+	return { key, type } as any
+}

package/internal/src/store/store.ts

@@ -0,0 +1,154 @@
+import type {
+	AtomFamily,
+	AtomToken,
+	Logger,
+	ReadonlySelectorFamily,
+	ReadonlySelectorToken,
+	SelectorFamily,
+	SelectorToken,
+	TimelineToken,
+	TransactionToken,
+	ƒn,
+} from "atom.io"
+
+import { Junction } from "~/packages/rel8/junction/src"
+
+import type { Atom } from "../atom"
+import type { MutableAtom, Tracker, Transceiver } from "../mutable"
+import type { OperationProgress } from "../operation"
+import type { ReadonlySelector, Selector } from "../selector"
+import { Subject } from "../subject"
+import type { Timeline } from "../timeline"
+import type { Transaction, TransactionStatus } from "../transaction"
+
+export type StoreCore = Pick<
+	Store,
+	| `atoms`
+	| `atomsThatAreDefault`
+	| `families`
+	| `operation`
+	| `readonlySelectors`
+	| `selectorAtoms`
+	| `selectorGraph`
+	| `selectors`
+	| `timelineAtoms`
+	| `timelines`
+	| `trackers`
+	| `transactions`
+	| `valueMap`
+>
+
+export class Store {
+	public valueMap = new Map<string, any>()
+
+	public atoms = new Map<string, Atom<any> | MutableAtom<any>>()
+	public selectors = new Map<string, Selector<any>>()
+	public readonlySelectors = new Map<string, ReadonlySelector<any>>()
+
+	public trackers = new Map<string, Tracker<Transceiver<any>>>()
+	public families = new Map<
+		string,
+		| AtomFamily<any, any>
+		| ReadonlySelectorFamily<any, any>
+		| SelectorFamily<any, any>
+	>()
+
+	public timelines = new Map<string, Timeline>()
+	public transactions = new Map<string, Transaction<ƒn>>()
+
+	public atomsThatAreDefault = new Set<string>()
+
+	public timelineAtoms = new Junction({
+		between: [`timelineKey`, `atomKey`],
+		cardinality: `1:n`,
+	})
+	public selectorAtoms = new Junction({
+		between: [`selectorKey`, `atomKey`],
+		cardinality: `n:n`,
+	})
+	public selectorGraph = new Junction<
+		`upstreamSelectorKey`,
+		`downstreamSelectorKey`,
+		{ source: string }
+	>(
+		{
+			between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
+			cardinality: `n:n`,
+		},
+		{
+			makeContentKey: (...keys) => keys.sort().join(`:`),
+		},
+	)
+
+	public subject = {
+		atomCreation: new Subject<AtomToken<unknown>>(),
+		selectorCreation: new Subject<
+			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+		>(),
+		transactionCreation: new Subject<TransactionToken<ƒn>>(),
+		timelineCreation: new Subject<TimelineToken>(),
+		operationStatus: new Subject<OperationProgress>(),
+	}
+	public operation: OperationProgress = { open: false }
+	public transactionStatus: TransactionStatus<ƒn> = { phase: `idle` }
+
+	public config: {
+		name: string
+		logger: Logger | null
+		logger__INTERNAL: Logger
+	} = {
+		name: `IMPLICIT_STORE`,
+		logger: { ...console, info: () => undefined },
+		logger__INTERNAL: console,
+	}
+
+	public constructor(name: string, store: Store | null = null) {
+		if (store !== null) {
+			this.valueMap = new Map(store?.valueMap)
+
+			this.operation = { ...store?.operation }
+			this.transactionStatus = { ...store?.transactionStatus }
+			this.config = {
+				...store?.config,
+				logger__INTERNAL: console,
+				logger: {
+					...console,
+					info: () => undefined,
+					...store?.config?.logger,
+				},
+				name,
+			}
+		}
+
+		store?.atoms.forEach((atom) => {
+			atom.install(this)
+		})
+		store?.readonlySelectors.forEach((selector) => {
+			selector.install(this)
+		})
+		store?.selectors.forEach((selector) => {
+			selector.install(this)
+		})
+		store?.transactions.forEach((tx) => {
+			tx.install(this)
+		})
+		store?.timelines.forEach((timeline) => {
+			timeline.install(this)
+		})
+	}
+}
+
+export const IMPLICIT = {
+	STORE_INTERNAL: undefined as Store | undefined,
+	get STORE(): Store {
+		return (
+			this.STORE_INTERNAL ?? (this.STORE_INTERNAL = new Store(`IMPLICIT_STORE`))
+		)
+	},
+}
+
+export const clearStore = (store: Store = IMPLICIT.STORE): void => {
+	const { config } = store
+	Object.assign(store, new Store(config.name))
+	store.config = config
+}

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

@@ -0,0 +1,53 @@
+import type {
+	AtomToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+	StateToken,
+} from "atom.io"
+import type { Atom, ReadonlySelector, Selector, Store } from ".."
+import { withdraw } from ".."
+import { target } from "../transaction"
+
+export function withdrawNewFamilyMember<T>(
+	token: AtomToken<T>,
+	store: Store,
+): Atom<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: SelectorToken<T>,
+	store: Store,
+): Selector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: ReadonlySelectorToken<T>,
+	store: Store,
+): ReadonlySelector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: StateToken<T>,
+	store: Store,
+): Atom<T> | Selector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token: ReadonlySelectorToken<T> | StateToken<T>,
+	store: Store,
+): Atom<T> | ReadonlySelector<T> | Selector<T> | null
+export function withdrawNewFamilyMember<T>(
+	token:
+		| AtomToken<T>
+		| ReadonlySelectorToken<T>
+		| SelectorToken<T>
+		| StateToken<T>,
+	store: Store,
+): Atom<T> | ReadonlySelector<T> | Selector<T> | null {
+	store.config.logger?.info(
+		`👪 creating new family member "${token.key}" in store "${store.config.name}"`,
+	)
+	if (token.family) {
+		const core = target(store)
+		const family = core.families.get(token.family.key)
+		if (family) {
+			const jsonSubKey = JSON.parse(token.family.subKey)
+			family(jsonSubKey)
+			const state = withdraw(token, store)
+			return state
+		}
+	}
+	return null
+}

package/internal/src/store/withdraw.ts

@@ -0,0 +1,113 @@
+import type {
+	AtomToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+	StateToken,
+	TimelineToken,
+	TransactionToken,
+	ƒn,
+} from "atom.io"
+
+import type { Atom } from "../atom"
+import type { ReadonlySelector, Selector } from "../selector"
+import { addAtomToTimeline } from "../timeline"
+import type { Timeline } from "../timeline"
+import type { Transaction } from "../transaction"
+import { target } from "../transaction"
+import type { Store } from "./store"
+
+export function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null
+export function withdraw<T>(
+	token: SelectorToken<T>,
+	store: Store,
+): Selector<T> | null
+export function withdraw<T>(
+	token: StateToken<T>,
+	store: Store,
+): Atom<T> | Selector<T> | null
+export function withdraw<T>(
+	token: ReadonlySelectorToken<T>,
+	store: Store,
+): ReadonlySelector<T> | null
+export function withdraw<T>(
+	token: TransactionToken<T>,
+	store: Store,
+): Transaction<T extends ƒn ? T : never> | null
+export function withdraw<T>(
+	token: ReadonlySelectorToken<T> | StateToken<T>,
+	store: Store,
+): Atom<T> | ReadonlySelector<T> | Selector<T> | null
+export function withdraw<T>(token: TimelineToken, store: Store): Timeline | null
+export function withdraw<T>(
+	token:
+		| ReadonlySelectorToken<T>
+		| StateToken<T>
+		| TimelineToken
+		| TransactionToken<T>,
+	store: Store,
+):
+	| Atom<T>
+	| ReadonlySelector<T>
+	| Selector<T>
+	| Timeline
+	| Transaction<T extends ƒn ? T : never>
+	| null {
+	let core = target(store)
+	let state =
+		core.atoms.get(token.key) ??
+		core.selectors.get(token.key) ??
+		core.readonlySelectors.get(token.key) ??
+		core.transactions.get(token.key) ??
+		core.timelines.get(token.key)
+	if (state) {
+		return state
+	}
+	if (store.transactionStatus.phase === `applying`) {
+		core = store.transactionStatus.core
+		state =
+			core.atoms.get(token.key) ??
+			core.selectors.get(token.key) ??
+			core.readonlySelectors.get(token.key) ??
+			core.transactions.get(token.key) ??
+			core.timelines.get(token.key)
+
+		if (state) {
+			store.config.logger?.info(`🛠️ add ${token.type} "${token.key}"`)
+			switch (state.type) {
+				case `atom`: {
+					store.atoms.set(token.key, state)
+					store.valueMap.set(token.key, state.default)
+					const stateKey = state.key
+					const familyKey = state.family?.key
+					let timelineKey = core.timelineAtoms.getRelatedKey(stateKey)
+					if (timelineKey === undefined && typeof familyKey === `string`) {
+						timelineKey = core.timelineAtoms.getRelatedKey(familyKey)
+					}
+					const timeline =
+						typeof timelineKey === `string`
+							? store.timelines.get(timelineKey)
+							: undefined
+
+					if (timeline) {
+						addAtomToTimeline(state, timeline, store)
+					}
+					break
+				}
+				case `selector`:
+					core.selectors.set(token.key, state)
+					break
+				case `readonly_selector`:
+					core.readonlySelectors.set(token.key, state)
+					break
+				case `transaction`:
+					core.transactions.set(token.key, state)
+					break
+				case `timeline`:
+					core.timelines.set(token.key, state)
+					break
+			}
+			return state
+		}
+	}
+	return null
+}

package/internal/src/subject.ts

@@ -0,0 +1,21 @@
+export class Subject<T> {
+	public Subscriber: (value: T) => void
+
+	public subscribers: Map<string, this[`Subscriber`]> = new Map()
+
+	public subscribe(key: string, subscriber: this[`Subscriber`]): () => void {
+		this.subscribers.set(key, subscriber)
+		const unsubscribe = () => this.unsubscribe(key)
+		return unsubscribe
+	}
+
+	private unsubscribe(key: string) {
+		this.subscribers.delete(key)
+	}
+
+	public next(value: T): void {
+		for (const subscriber of this.subscribers.values()) {
+			subscriber(value)
+		}
+	}
+}

package/internal/src/subscribe/index.ts

@@ -0,0 +1 @@
+export * from "./subscribe-to-root-atoms"

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

@@ -0,0 +1,19 @@
+import type { Atom } from "../atom"
+import type { ReadonlySelector, Selector } from "../selector"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { target } from "../transaction"
+
+export const recallState = <T>(
+	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	store: Store = IMPLICIT.STORE,
+): T => {
+	const core = target(store)
+	if (!core.operation.open) {
+		store.config.logger?.warn(
+			`recall called outside of an operation. This is probably a bug.`,
+		)
+		return core.valueMap.get(state.key)
+	}
+	return core.operation.prev.get(state.key)
+}

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

@@ -0,0 +1,47 @@
+import { getState__INTERNAL } from "../get-state-internal"
+import type { ReadonlySelector, Selector } from "../selector"
+import { traceAllSelectorAtoms } from "../selector"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+import { recallState } from "./recall-state"
+
+export const subscribeToRootAtoms = <T>(
+	state: ReadonlySelector<T> | Selector<T>,
+	store: Store,
+): (() => void)[] | null => {
+	const dependencySubscriptions =
+		`default` in state
+			? null
+			: traceAllSelectorAtoms(state.key, store).map((atomToken) => {
+					const atom = withdraw(atomToken, store)
+					if (atom === null) {
+						throw new Error(
+							`Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
+						)
+					}
+					return atom.subject.subscribe(
+						`${state.type}:${state.key}`,
+						(atomChange) => {
+							store.config.logger?.info(
+								`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
+								atomChange.oldValue,
+								`->`,
+								atomChange.newValue,
+								`)`,
+							)
+							const oldValue = recallState(state, store)
+							// ❗ this retrieves a stale cached value when applying a transaction on the server
+							const newValue = getState__INTERNAL(state, store)
+							store.config.logger?.info(
+								`   <- "${state.key}" went (`,
+								oldValue,
+								`->`,
+								newValue,
+								`)`,
+							)
+							state.subject.next({ newValue, oldValue })
+						},
+					)
+			  })
+	return dependencySubscriptions
+}

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

@@ -0,0 +1,189 @@
+import type { AtomToken, TimelineUpdate } from "atom.io"
+
+import type { Store } from "../store"
+import { IMPLICIT, withdraw } from "../store"
+import { target } from "../transaction"
+import type {
+	Timeline,
+	TimelineAtomUpdate,
+	TimelineTransactionUpdate,
+} from "./timeline-internal"
+
+export const addAtomToTimeline = (
+	atomToken: AtomToken<any>,
+	tl: Timeline,
+	store: Store = IMPLICIT.STORE,
+): void => {
+	const atom = withdraw(atomToken, store)
+	if (atom === null) {
+		throw new Error(
+			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
+		)
+	}
+	atom.subject.subscribe(`timeline`, (update) => {
+		const currentSelectorKey =
+			store.operation.open && store.operation.token.type === `selector`
+				? store.operation.token.key
+				: null
+		const currentSelectorTime =
+			store.operation.open && store.operation.token.type === `selector`
+				? store.operation.time
+				: null
+		const currentTransactionKey =
+			store.transactionStatus.phase === `applying`
+				? store.transactionStatus.key
+				: null
+		const currentTransactionTime =
+			store.transactionStatus.phase === `applying`
+				? store.transactionStatus.time
+				: null
+
+		store.config.logger?.info(
+			`⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
+			update.oldValue,
+			`->`,
+			update.newValue,
+			currentTransactionKey
+				? `) in transaction "${currentTransactionKey}"`
+				: currentSelectorKey
+				? `) in selector "${currentSelectorKey}"`
+				: `)`,
+		)
+
+		if (tl.timeTraveling === null) {
+			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
+				const mostRecentUpdate: TimelineUpdate | 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.`,
+					)
+				}
+			}
+			if (
+				currentTransactionKey &&
+				store.transactionStatus.phase === `applying`
+			) {
+				const currentTransaction = withdraw(
+					{ key: currentTransactionKey, type: `transaction` },
+					store,
+				)
+				if (currentTransaction === null) {
+					throw new Error(
+						`Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`,
+					)
+				}
+				if (tl.transactionKey !== currentTransactionKey) {
+					if (tl.transactionKey) {
+						store.config.logger?.error(
+							`Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`,
+						)
+					}
+					tl.transactionKey = currentTransactionKey
+					const unsubscribe = currentTransaction.subject.subscribe(
+						`timeline:${tl.key}`,
+						(update) => {
+							unsubscribe()
+							if (tl.timeTraveling === null && currentTransactionTime) {
+								if (tl.at !== tl.history.length) {
+									tl.history.splice(tl.at)
+								}
+
+								const atomUpdates = update.atomUpdates.filter((atomUpdate) => {
+									const core = target(store)
+									const atomOrFamilyKeys = core.timelineAtoms.getRelatedKeys(
+										tl.key,
+									)
+
+									return atomOrFamilyKeys
+										? [...atomOrFamilyKeys].some(
+												(key) =>
+													key === atomUpdate.key ||
+													key === atomUpdate.family?.key,
+										  )
+										: false
+								})
+
+								const timelineTransactionUpdate: TimelineTransactionUpdate = {
+									type: `transaction_update`,
+									timestamp: currentTransactionTime,
+									...update,
+									atomUpdates,
+								}
+								tl.history.push(timelineTransactionUpdate)
+								tl.at = tl.history.length
+								tl.subject.next(timelineTransactionUpdate)
+							}
+							tl.transactionKey = null
+							store.config.logger?.info(
+								`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
+							)
+						},
+					)
+				}
+			} else if (currentSelectorKey && currentSelectorTime) {
+				let latestUpdate: TimelineUpdate | undefined = tl.history.at(-1)
+
+				if (currentSelectorTime !== tl.selectorTime) {
+					latestUpdate = {
+						type: `selector_update`,
+						timestamp: currentSelectorTime,
+						key: currentSelectorKey,
+						atomUpdates: [],
+					}
+					latestUpdate.atomUpdates.push({
+						key: atom.key,
+						type: `atom_update`,
+						...update,
+					})
+					if (tl.at !== tl.history.length) {
+						tl.history.splice(tl.at)
+					}
+					tl.history.push(latestUpdate)
+
+					store.config.logger?.info(
+						`⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
+						latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
+					)
+
+					tl.at = tl.history.length
+					tl.selectorTime = currentSelectorTime
+				} else {
+					if (latestUpdate?.type === `selector_update`) {
+						latestUpdate.atomUpdates.push({
+							key: atom.key,
+							type: `atom_update`,
+							...update,
+						})
+						store.config.logger?.info(
+							`   ⌛ timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
+							latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
+						)
+					}
+				}
+				if (latestUpdate) tl.subject.next(latestUpdate)
+			} else {
+				const timestamp = Date.now()
+				tl.selectorTime = null
+				if (tl.at !== tl.history.length) {
+					tl.history.splice(tl.at)
+				}
+				const atomUpdate: TimelineAtomUpdate = {
+					type: `atom_update`,
+					timestamp,
+					key: atom.key,
+					oldValue: update.oldValue,
+					newValue: update.newValue,
+				}
+				if (atom.family) {
+					atomUpdate.family = atom.family
+				}
+				tl.history.push(atomUpdate)
+				tl.subject.next(atomUpdate)
+				store.config.logger?.info(
+					`⌛ timeline "${tl.key}" got an atom_update to "${atom.key}"`,
+				)
+				tl.at = tl.history.length
+			}
+		}
+	})
+}

package/internal/src/timeline/index.ts

@@ -0,0 +1,3 @@
+export * from "./add-atom-to-timeline"
+export * from "./time-travel-internal"
+export * from "./timeline-internal"