atom.io 0.6.8 → 0.6.9

package/src/internal/store.ts

@@ -1,151 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-import { doNothing } from "~/packages/anvl/src/function"
-import { Join } from "~/packages/anvl/src/join"
-
-import { Subject } from "."
-import type {
-	Atom,
-	OperationProgress,
-	ReadonlySelector,
-	Selector,
-	TransactionStatus,
-	Timeline,
-	Transaction,
-} from "."
-import type {
-	AtomToken,
-	Logger,
-	ReadonlySelectorToken,
-	SelectorToken,
-	TimelineToken,
-	TransactionToken,
-} from ".."
-
-export type StoreCore = Pick<
-	Store,
-	| `atoms`
-	| `atomsThatAreDefault`
-	| `operation`
-	| `readonlySelectors`
-	| `selectorAtoms`
-	| `selectorGraph`
-	| `selectors`
-	| `timelineAtoms`
-	| `timelines`
-	| `transactions`
-	| `valueMap`
->
-
-export interface Store {
-	atoms: Map<string, Atom<any>>
-	atomsThatAreDefault: Set<string>
-	readonlySelectors: Map<string, ReadonlySelector<any>>
-	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
-	selectorGraph: Join<{ source: string }>
-	selectors: Map<string, Selector<any>>
-	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-	timelines: Map<string, Timeline>
-	transactions: Map<string, Transaction<any>>
-	valueMap: Map<string, any>
-
-	subject: {
-		atomCreation: Subject<AtomToken<unknown>>
-		selectorCreation: Subject<
-			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
-		>
-		transactionCreation: Subject<TransactionToken<ƒn>>
-		timelineCreation: Subject<TimelineToken>
-		operationStatus: Subject<OperationProgress>
-	}
-
-	operation: OperationProgress
-	transactionStatus: TransactionStatus<ƒn>
-	config: {
-		name: string
-		logger: Logger | null
-		logger__INTERNAL: Logger
-	}
-}
-
-export const createStore = (name: string, store: Store | null = null): Store => {
-	const created = {
-		...(store ??
-			(() => ({
-				atomsThatAreDefault: new Set(),
-				selectorAtoms: new Join({ relationType: `n:n` })
-					.from(`selectorKey`)
-					.to(`atomKey`),
-				selectorGraph: new Join({ relationType: `n:n` }),
-			}))()),
-
-		valueMap: new Map(store?.valueMap),
-		atoms: new Map(),
-		readonlySelectors: new Map(),
-		selectors: new Map(),
-		transactions: new Map(),
-		timelines: new Map(),
-
-		timelineAtoms: new Join({ relationType: `1:n` })
-			.from(`timelineKey`)
-			.to(`atomKey`),
-
-		subject: {
-			atomCreation: new Subject(),
-			selectorCreation: new Subject(),
-			transactionCreation: new Subject(),
-			timelineCreation: new Subject(),
-			operationStatus: new Subject(),
-		},
-
-		operation: {
-			open: false,
-			...store?.operation,
-		},
-		transactionStatus: {
-			phase: `idle`,
-			...store?.transactionStatus,
-		},
-		config: {
-			logger: {
-				...console,
-				info: doNothing,
-				...store?.config?.logger,
-			},
-			logger__INTERNAL: console,
-			...store?.config,
-			name,
-		},
-	} satisfies Store
-
-	store?.atoms.forEach((atom) => {
-		const copiedAtom = { ...atom, subject: new Subject() } satisfies Atom<any>
-		created.atoms.set(atom.key, copiedAtom)
-	})
-	store?.readonlySelectors.forEach((selector) => {
-		selector.install(created)
-	})
-	store?.selectors.forEach((selector) => {
-		selector.install(created)
-	})
-	store?.transactions.forEach((tx) => {
-		tx.install(created)
-	})
-	store?.timelines.forEach((timeline) => {
-		timeline.install(created)
-	})
-
-	return created
-}
-
-export const IMPLICIT = {
-	STORE_INTERNAL: undefined as Store | undefined,
-	get STORE(): Store {
-		return this.STORE_INTERNAL ?? (this.STORE_INTERNAL = createStore(`DEFAULT`))
-	},
-}
-
-export const clearStore = (store: Store = IMPLICIT.STORE): void => {
-	const { config } = store
-	Object.assign(store, createStore(config.name))
-	store.config = config
-}

package/src/internal/subscribe-internal.ts

@@ -1,88 +0,0 @@
-import type { Atom, ReadonlySelector, Selector, Store } from "."
-import {
-	getState__INTERNAL,
-	withdraw,
-	recallState,
-	traceAllSelectorAtoms,
-} from "."
-import type { StateUpdate } from ".."
-
-export const prepareUpdate = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	store: Store,
-): StateUpdate<T> => {
-	const oldValue = recallState(state, store)
-	const newValue = getState__INTERNAL(state, store)
-	return { newValue, oldValue }
-}
-
-export const stowUpdate = <T>(
-	state: Atom<T>,
-	update: StateUpdate<T>,
-	store: Store,
-): void => {
-	const { key } = state
-	const { logger } = store.config
-	if (store.transactionStatus.phase !== `building`) {
-		store.config.logger?.warn(
-			`stowUpdate called outside of a transaction. This is probably a bug.`,
-		)
-		return
-	}
-	store.transactionStatus.atomUpdates.push({ key, ...update })
-	logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
-}
-
-export const emitUpdate = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-	update: StateUpdate<T>,
-	store: Store,
-): void => {
-	const { key } = state
-	const { logger } = store.config
-	logger?.info(
-		`📢 ${state.type} "${key}" went (`,
-		update.oldValue,
-		`->`,
-		update.newValue,
-		`)`,
-	)
-	state.subject.next(update)
-}
-
-export const subscribeToRootAtoms = <T>(
-	state: ReadonlySelector<T> | Selector<T>,
-	store: Store,
-): { unsubscribe: () => 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((atomChange) => {
-						store.config.logger?.info(
-							`📢 selector "${state.key}" saw root "${atomToken.key}" go (`,
-							atomChange.oldValue,
-							`->`,
-							atomChange.newValue,
-							`)`,
-						)
-						const oldValue = recallState(state, store)
-						const newValue = getState__INTERNAL(state, store)
-						store.config.logger?.info(
-							`   <- "${state.key}" went (`,
-							oldValue,
-							`->`,
-							newValue,
-							`)`,
-						)
-						state.subject.next({ newValue, oldValue })
-					})
-			  })
-	return dependencySubscriptions
-}

package/src/internal/time-travel-internal.ts

@@ -1,91 +0,0 @@
-import type { Store } from "."
-import { IMPLICIT } from "."
-import type { TimelineToken } from ".."
-import { setState } from ".."
-
-export const redo__INTERNAL = (
-	token: TimelineToken,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	store.config.logger?.info(`⏩ redo "${token.key}"`)
-	const timelineData = store.timelines.get(token.key)
-	if (!timelineData) {
-		store.config.logger?.error(
-			`Failed to redo on timeline "${token.key}". This timeline has not been initialized.`,
-		)
-		return
-	}
-	if (timelineData.at === timelineData.history.length) {
-		store.config.logger?.warn(
-			`Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`,
-		)
-		return
-	}
-	timelineData.timeTraveling = `into_future`
-	const update = timelineData.history[timelineData.at]
-	switch (update.type) {
-		case `atom_update`: {
-			const { key, newValue } = update
-			setState({ key, type: `atom` }, newValue, store)
-			break
-		}
-		case `selector_update`:
-		case `transaction_update`: {
-			for (const atomUpdate of update.atomUpdates) {
-				const { key, newValue } = atomUpdate
-				setState({ key, type: `atom` }, newValue, store)
-			}
-			break
-		}
-	}
-	++timelineData.at
-	timelineData.subject.next(`redo`)
-	timelineData.timeTraveling = null
-	store.config.logger?.info(
-		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
-	)
-}
-
-export const undo__INTERNAL = (
-	token: TimelineToken,
-	store: Store = IMPLICIT.STORE,
-): void => {
-	store.config.logger?.info(`⏪ undo "${token.key}"`)
-	const timelineData = store.timelines.get(token.key)
-	if (!timelineData) {
-		store.config.logger?.error(
-			`Failed to undo on timeline "${token.key}". This timeline has not been initialized.`,
-		)
-		return
-	}
-	if (timelineData.at === 0) {
-		store.config.logger?.warn(
-			`Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`,
-		)
-		return
-	}
-	timelineData.timeTraveling = `into_past`
-
-	--timelineData.at
-	const update = timelineData.history[timelineData.at]
-	switch (update.type) {
-		case `atom_update`: {
-			const { key, oldValue } = update
-			setState({ key, type: `atom` }, oldValue, store)
-			break
-		}
-		case `selector_update`:
-		case `transaction_update`: {
-			for (const atomUpdate of update.atomUpdates) {
-				const { key, oldValue } = atomUpdate
-				setState({ key, type: `atom` }, oldValue, store)
-			}
-			break
-		}
-	}
-	timelineData.subject.next(`undo`)
-	timelineData.timeTraveling = null
-	store.config.logger?.info(
-		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
-	)
-}

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

@@ -1,168 +0,0 @@
-import { IMPLICIT, withdraw } from ".."
-import type {
-	Timeline,
-	Store,
-	TimelineTransactionUpdate,
-	TimelineAtomUpdate,
-} from ".."
-import type { AtomFamily, AtomToken, TimelineUpdate } from "../.."
-
-export const addAtomToTimeline = (
-	atomToken: AtomToken<any>,
-	atoms: (AtomFamily<any> | 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((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 subscription = currentTransaction.subject.subscribe((update) => {
-						subscription.unsubscribe()
-						if (tl.timeTraveling === null && currentTransactionTime) {
-							if (tl.at !== tl.history.length) {
-								tl.history.splice(tl.at)
-							}
-							const timelineTransactionUpdate: TimelineTransactionUpdate = {
-								type: `transaction_update`,
-								timestamp: currentTransactionTime,
-								...update,
-								atomUpdates: update.atomUpdates.filter((atomUpdate) =>
-									atoms.some((atom) => atom.key === atomUpdate.key),
-								),
-							}
-							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,
-				}
-				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/src/internal/timeline/index.ts

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

package/src/internal/timeline-internal.ts

@@ -1,107 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from "."
-import { Subject, target, IMPLICIT } from "."
-import { addAtomToTimeline } from "./timeline/add-atom-to-timeline"
-import type {
-	StateUpdate,
-	TimelineOptions,
-	TimelineToken,
-	TimelineUpdate,
-	TransactionUpdate,
-} from ".."
-
-export type TimelineAtomUpdate = StateUpdate<unknown> & {
-	key: string
-	type: `atom_update`
-	timestamp: number
-}
-export type TimelineSelectorUpdate = {
-	key: string
-	type: `selector_update`
-	timestamp: number
-	atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
-}
-export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
-	key: string
-	type: `transaction_update`
-	timestamp: number
-}
-
-export type Timeline = {
-	key: string
-	at: number
-	timeTraveling: `into_future` | `into_past` | null
-	history: TimelineUpdate[]
-	selectorTime: number | null
-	transactionKey: string | null
-	install: (store: Store) => void
-	subject: Subject<
-		| TimelineAtomUpdate
-		| TimelineSelectorUpdate
-		| TimelineTransactionUpdate
-		| `redo`
-		| `undo`
-	>
-}
-
-export function timeline__INTERNAL(
-	options: TimelineOptions,
-	store: Store = IMPLICIT.STORE,
-	data: Timeline | null = null,
-): TimelineToken {
-	const tl: Timeline = {
-		key: options.key,
-		at: 0,
-		timeTraveling: null,
-		selectorTime: null,
-		transactionKey: null,
-		...data,
-		history: data?.history.map((update) => ({ ...update })) ?? [],
-		install: (store) => timeline__INTERNAL(options, store, tl),
-		subject: new Subject(),
-	}
-
-	const core = target(store)
-	for (const tokenOrFamily of options.atoms) {
-		const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
-		if (timelineKey) {
-			store.config.logger?.error(
-				`❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`,
-			)
-			continue
-		}
-		if (tokenOrFamily.type === `atom_family`) {
-			const family = tokenOrFamily
-			family.subject.subscribe((token) =>
-				addAtomToTimeline(token, options.atoms, tl, store),
-			)
-		} else {
-			const token = tokenOrFamily
-			if (`family` in token && token.family) {
-				const familyTimelineKey = core.timelineAtoms.getRelatedId(
-					token.family.key,
-				)
-				if (familyTimelineKey) {
-					store.config.logger?.error(
-						`❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`,
-					)
-					continue
-				}
-			}
-			addAtomToTimeline(token, options.atoms, tl, store)
-		}
-		core.timelineAtoms = core.timelineAtoms.set({
-			atomKey: tokenOrFamily.key,
-			timelineKey: options.key,
-		})
-	}
-
-	store.timelines.set(options.key, tl)
-	const token: TimelineToken = {
-		key: options.key,
-		type: `timeline`,
-	}
-	store.subject.timelineCreation.next(token)
-	return token
-}

package/src/internal/transaction/abort-transaction.ts

@@ -1,12 +0,0 @@
-import type { Store } from ".."
-
-export const abortTransaction = (store: Store): void => {
-	if (store.transactionStatus.phase === `idle`) {
-		store.config.logger?.warn(
-			`abortTransaction called outside of a transaction. This is probably a bug.`,
-		)
-		return
-	}
-	store.transactionStatus = { phase: `idle` }
-	store.config.logger?.info(`🪂`, `transaction fail`)
-}

package/src/internal/transaction/apply-transaction.ts

@@ -1,57 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken } from "../.."
-import { setState } from "../.."
-
-export const applyTransaction = <ƒ extends ƒn>(
-	output: ReturnType<ƒ>,
-	store: Store,
-): void => {
-	if (store.transactionStatus.phase !== `building`) {
-		store.config.logger?.warn(
-			`abortTransaction called outside of a transaction. This is probably a bug.`,
-		)
-		return
-	}
-	store.config.logger?.info(
-		`🛃 apply transaction "${store.transactionStatus.key}"`,
-	)
-	store.transactionStatus.phase = `applying`
-	store.transactionStatus.output = output
-	const { atomUpdates } = store.transactionStatus
-
-	for (const { key, newValue } of atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		if (!store.valueMap.has(token.key)) {
-			const newAtom = store.transactionStatus.core.atoms.get(token.key)
-			if (!newAtom) {
-				throw new Error(
-					`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`,
-				)
-			}
-			store.atoms.set(newAtom.key, newAtom)
-			store.valueMap.set(newAtom.key, newAtom.default)
-			store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
-		}
-		setState(token, newValue, store)
-	}
-	const myTransaction = withdraw<ƒ>(
-		{ key: store.transactionStatus.key, type: `transaction` },
-		store,
-	)
-	if (myTransaction === null) {
-		throw new Error(
-			`Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`,
-		)
-	}
-	myTransaction.subject.next({
-		key: store.transactionStatus.key,
-		atomUpdates,
-		output,
-		params: store.transactionStatus.params as Parameters<ƒ>,
-	})
-	store.transactionStatus = { phase: `idle` }
-	store.config.logger?.info(`🛬`, `transaction done`)
-}