atom.io 0.31.0 → 0.32.0

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

@@ -17,7 +17,6 @@ import type {
 	TransactionUpdate,
 	TransactionUpdateContent,
 } from "atom.io"
-import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
@@ -78,8 +77,8 @@ export type Timeline<ManagedAtom extends TimelineManageable> = {
 }
 
 export function createTimeline<ManagedAtom extends TimelineManageable>(
-	options: TimelineOptions<ManagedAtom>,
 	store: Store,
+	options: TimelineOptions<ManagedAtom>,
 	data?: Timeline<ManagedAtom>,
 ): TimelineToken<ManagedAtom> {
 	const tl: Timeline<ManagedAtom> = {
@@ -92,7 +91,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 		transactionKey: null,
 		...data,
 		history: data?.history.map((update) => ({ ...update })) ?? [],
-		install: (s) => createTimeline(options, s, tl),
+		install: (s) => createTimeline(s, options, tl),
 		subject: new Subject(),
 		subscriptions: new Map(),
 	}
@@ -131,7 +130,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 						)
 						continue
 					}
-					addAtomToTimeline(atomToken, tl, store)
+					addAtomToTimeline(store, atomToken, tl)
 				}
 				break
 
@@ -151,28 +150,9 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 						)
 						continue
 					}
-					addAtomFamilyToTimeline(familyToken, tl, store)
+					addAtomFamilyToTimeline(store, familyToken, tl)
 				}
 				break
-
-			// case `molecule_family`:
-			// 	{
-			// 		const familyToken: MoleculeFamilyToken<any> = initialTopic
-			// 		const familyKey = familyToken.key
-			// 		const existingTimelineKey =
-			// 			target.timelineTopics.getRelatedKey(familyKey)
-			// 		if (existingTimelineKey) {
-			// 			store.logger.error(
-			// 				`❌`,
-			// 				`timeline`,
-			// 				options.key,
-			// 				`Failed to add molecule family "${familyKey}" because it already belongs to timeline "${existingTimelineKey}"`,
-			// 			)
-			// 			continue
-			// 		}
-			// 		addMoleculeFamilyToTimeline(familyToken, tl, store)
-			// 	}
-			// 	break
 		}
 	}
 
@@ -186,14 +166,14 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 }
 
 function addAtomToTimeline(
+	store: Store,
 	atomToken: AtomToken<any>,
 	tl: Timeline<any>,
-	store: Store,
 ): void {
-	let maybeAtom = withdraw(atomToken, store)
+	let maybeAtom = withdraw(store, atomToken)
 	if (maybeAtom.type === `mutable_atom`) {
 		const updateToken = getUpdateToken(maybeAtom)
-		maybeAtom = withdraw(updateToken, store)
+		maybeAtom = withdraw(store, updateToken)
 	}
 	const atom = maybeAtom
 	store.timelineTopics.set(
@@ -236,7 +216,7 @@ function addAtomToTimeline(
 				)
 				if (tl.timeTraveling === null) {
 					if (txUpdateInProgress) {
-						joinTransaction(tl, txUpdateInProgress, store)
+						joinTransaction(store, tl, txUpdateInProgress)
 					} else if (currentSelectorKey && currentSelectorTime) {
 						let latestUpdate: TimelineUpdate<any> | undefined = tl.history.at(-1)
 
@@ -330,11 +310,11 @@ function addAtomToTimeline(
 }
 
 function addAtomFamilyToTimeline(
+	store: Store,
 	atomFamilyToken: AtomFamilyToken<any, any>,
 	tl: Timeline<any>,
-	store: Store,
 ): void {
-	const family = withdraw(atomFamilyToken, store)
+	const family = withdraw(store, atomFamilyToken)
 	store.timelineTopics.set(
 		{ topicKey: family.key, timelineKey: tl.key },
 		{ topicType: `atom_family` },
@@ -344,21 +324,21 @@ function addAtomFamilyToTimeline(
 		family.subject.subscribe(
 			`timeline`,
 			function timelineCapturesStateLifecycleEvent(creationOrDisposal) {
-				handleStateLifecycleEvent(creationOrDisposal, tl, store)
+				handleStateLifecycleEvent(store, creationOrDisposal, tl)
 			},
 		),
 	)
 	for (const atom of store.atoms.values()) {
 		if (atom.family?.key === family.key) {
-			addAtomToTimeline(atom, tl, store)
+			addAtomToTimeline(store, atom, tl)
 		}
 	}
 }
 
 function joinTransaction(
+	store: Store,
 	tl: Timeline<any>,
 	txUpdateInProgress: TransactionUpdate<Func>,
-	store: Store,
 ) {
 	const currentTxKey = txUpdateInProgress.key
 	const currentTxInstanceId = txUpdateInProgress.id
@@ -366,7 +346,7 @@ function joinTransaction(
 		key: currentTxKey,
 		type: `transaction`,
 	}
-	const currentTransaction = withdraw(currentTxToken, store)
+	const currentTransaction = withdraw(store, currentTxToken)
 	if (currentTxKey && tl.transactionKey === null) {
 		tl.transactionKey = currentTxKey
 		const unsubscribe = currentTransaction.subject.subscribe(
@@ -453,9 +433,9 @@ function filterTransactionUpdates(
 }
 
 function handleStateLifecycleEvent(
+	store: Store,
 	event: StateCreation<any> | StateDisposal<any>,
 	tl: Timeline<any>,
-	store: Store,
 ): void {
 	const timestamp = Date.now()
 	const timelineEvent = Object.assign(event, {
@@ -468,7 +448,7 @@ function handleStateLifecycleEvent(
 		} else {
 			const txUpdateInProgress = target.on.transactionApplying.state
 			if (txUpdateInProgress) {
-				joinTransaction(tl, txUpdateInProgress.update, store)
+				joinTransaction(store, tl, txUpdateInProgress.update)
 			} else {
 				tl.history.push(timelineEvent)
 				tl.at = tl.history.length
@@ -478,7 +458,7 @@ function handleStateLifecycleEvent(
 	}
 	switch (event.type) {
 		case `state_creation`:
-			addAtomToTimeline(event.token, tl, store)
+			addAtomToTimeline(store, event.token, tl)
 			break
 		case `state_disposal`:
 			tl.subscriptions.get(event.token.key)?.()

package/internal/src/transaction/act-upon-store.ts

@@ -6,12 +6,12 @@ import { withdraw } from "../store"
 import type { Func } from "../utility-types"
 
 export function actUponStore<F extends Func>(
+	store: Store,
 	token: TransactionToken<F>,
 	id: string,
-	store: Store,
 ): (...parameters: Parameters<F>) => ReturnType<F> {
 	return (...parameters: Parameters<F>): ReturnType<F> => {
-		const tx = withdraw(token, store)
+		const tx = withdraw(store, token)
 		if (tx) {
 			return tx.run(parameters, id)
 		}

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

@@ -42,14 +42,14 @@ export const applyTransaction = <F extends Func>(
 
 	if (isRootStore(parent)) {
 		setEpochNumberOfAction(
+			parent,
 			child.transactionMeta.update.key,
 			child.transactionMeta.update.epoch,
-			parent,
-		)
-		const myTransaction = withdraw<F>(
-			{ key: child.transactionMeta.update.key, type: `transaction` },
-			store,
 		)
+		const myTransaction = withdraw<F>(store, {
+			key: child.transactionMeta.update.key,
+			type: `transaction`,
+		})
 		myTransaction?.subject.next(child.transactionMeta.update)
 		store.logger.info(
 			`🛬`,

package/internal/src/transaction/assign-transaction-to-continuity.ts

@@ -2,9 +2,9 @@ import type { Store } from "../store"
 import { isRootStore } from "./is-root-store"
 
 export function assignTransactionToContinuity(
+	store: Store,
 	continuityKey: string,
 	transactionKey: string,
-	store: Store,
 ): void {
 	const isRoot = isRootStore(store)
 	if (!isRoot) {

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

@@ -1,9 +1,7 @@
-import type { disposeState, getState, setState } from "atom.io"
-import type { findState } from "atom.io/ephemeral"
-import type { seekState } from "atom.io/immortal"
+import type { disposeState, findState, getState, setState } from "atom.io"
 
 import { arbitrary } from "../arbitrary"
-import { disposeFromStore, findInStore, seekInStore } from "../families"
+import { disposeFromStore, findInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
 import { getFromStore } from "../get-state"
 import { Junction } from "../junction"
@@ -18,9 +16,9 @@ import { actUponStore, getEpochNumberOfAction } from "."
 import type { ChildStore, RootStore } from "./is-root-store"
 
 export const buildTransaction = (
+	store: Store,
 	key: string,
 	params: any[],
-	store: Store,
 	id: string,
 ): ChildStore => {
 	const parent = newest(store) as ChildStore | RootStore
@@ -61,7 +59,7 @@ export const buildTransaction = (
 		}),
 		miscResources: new LazyMap(parent.miscResources),
 	}
-	const epoch = getEpochNumberOfAction(key, store)
+	const epoch = getEpochNumberOfAction(store, key)
 	const transactionMeta: TransactionProgress<Func> = {
 		phase: `building`,
 		update: {
@@ -80,9 +78,8 @@ export const buildTransaction = (
 				setIntoStore(child, ...ps)
 			}) as typeof setState,
 			run: (token, identifier = arbitrary()) =>
-				actUponStore(token, identifier, child),
+				actUponStore(child, token, identifier),
 			find: ((token, k) => findInStore(child, token, k)) as typeof findState,
-			seek: ((token, k) => seekInStore(child, token, k)) as typeof seekState,
 			json: (token) => getJsonToken(child, token),
 			dispose: ((...ps: Parameters<typeof disposeState>) => {
 				disposeFromStore(child, ...ps)

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

@@ -22,14 +22,14 @@ export type Transaction<F extends Func> = {
 }
 
 export function createTransaction<F extends Func>(
-	options: TransactionOptions<F>,
 	store: Store,
+	options: TransactionOptions<F>,
 ): TransactionToken<F> {
 	const newTransaction: Transaction<F> = {
 		key: options.key,
 		type: `transaction`,
 		run: (params: Parameters<F>, id: string) => {
-			const childStore = buildTransaction(options.key, params, store, id)
+			const childStore = buildTransaction(store, options.key, params, id)
 			try {
 				const target = newest(store)
 				const { toolkit } = childStore.transactionMeta
@@ -42,7 +42,7 @@ export function createTransaction<F extends Func>(
 				throw thrown
 			}
 		},
-		install: (s) => createTransaction(options, s),
+		install: (s) => createTransaction(s, options),
 		subject: new Subject(),
 	}
 	const target = newest(store)

package/internal/src/transaction/get-epoch-number.ts

@@ -2,8 +2,8 @@ import type { Store } from "../store"
 import { isRootStore } from "./is-root-store"
 
 export function getContinuityKey(
-	transactionKey: string,
 	store: Store,
+	transactionKey: string,
 ): string | undefined {
 	const isRoot = isRootStore(store)
 	const continuity = isRoot
@@ -13,8 +13,8 @@ export function getContinuityKey(
 }
 
 export function getEpochNumberOfContinuity(
-	continuityKey: string,
 	store: Store,
+	continuityKey: string,
 ): number | undefined {
 	const isRoot = isRootStore(store)
 	const epoch =
@@ -25,8 +25,8 @@ export function getEpochNumberOfContinuity(
 }
 
 export function getEpochNumberOfAction(
-	transactionKey: string,
 	store: Store,
+	transactionKey: string,
 ): number | undefined {
 	const isRoot = isRootStore(store)
 	const continuity = isRoot

package/internal/src/transaction/set-epoch-number.ts

@@ -2,9 +2,9 @@ import type { Store } from "../store"
 import { isRootStore } from "./is-root-store"
 
 export function setEpochNumberOfContinuity(
+	store: Store,
 	continuityKey: string,
 	newEpoch: number,
-	store: Store,
 ): void {
 	const isRoot = isRootStore(store)
 	if (isRoot && continuityKey) {
@@ -13,9 +13,9 @@ export function setEpochNumberOfContinuity(
 }
 
 export function setEpochNumberOfAction(
+	store: Store,
 	transactionKey: string,
 	newEpoch: number,
-	store: Store,
 ): void {
 	const isRoot = isRootStore(store)
 	if (!isRoot) {