atom.io 0.15.4 → 0.15.6

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"
 
 /**

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) {

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,

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
 	}

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/set-state/set-atom.ts

@@ -1,6 +1,8 @@
+import { setState } from "atom.io"
 import type { Atom } from "../atom"
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
+import type { Transceiver } from "../mutable"
 import { markDone } from "../operation"
 import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
@@ -28,9 +30,12 @@ export const setAtom = <T>(
 	const update = { oldValue, newValue }
 	if (target.transactionMeta === null) {
 		emitUpdate(atom, update, target)
-	} else if (target.transactionMeta.phase === `applying` && target.parent) {
-		emitUpdate(atom, update, target.parent)
-	} else {
+	} else if (target.on.transactionApplying && target.parent) {
 		stowUpdate(atom, update, target)
+		if (atom.key.startsWith(`*`)) {
+			const mutableKey = atom.key.slice(1)
+			const mutable: Transceiver<any> = target.valueMap.get(mutableKey)
+			mutable.do(update.newValue)
+		}
 	}
 }

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/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

@@ -3,13 +3,14 @@ import type {
 	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"
@@ -32,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>(
@@ -46,7 +47,7 @@ export function withdraw<T>(
 export function withdraw<T>(
 	token: ReadableToken<T>,
 	store: Store,
-): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined
+): StateNode<T> | undefined
 export function withdraw<T>(
 	token: TimelineToken<T>,
 	store: Store,

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/timeline/time-travel.ts

@@ -1,21 +1,23 @@
-import type { KeyedStateUpdate, TimelineToken, TransactionUpdate } from "atom.io"
-import { setState } from "atom.io"
+import type { TimelineToken } from "atom.io"
 
+import {
+	ingestAtomUpdate,
+	ingestSelectorUpdate,
+	ingestTransactionUpdate,
+} from "../ingest-updates"
 import type { Store } from "../store"
 
 export const timeTravel = (
-	direction: `backward` | `forward`,
+	action: `redo` | `undo`,
 	token: TimelineToken<any>,
 	store: Store,
 ): void => {
-	const action = direction === `forward` ? `redo` : `undo`
 	store.logger.info(
-		direction === `forward` ? `⏩` : `⏪`,
+		action === `redo` ? `⏩` : `⏪`,
 		`timeline`,
 		token.key,
 		action,
 	)
-
 	const timelineData = store.timelines.get(token.key)
 	if (!timelineData) {
 		store.logger.error(
@@ -26,73 +28,45 @@ export const timeTravel = (
 		)
 		return
 	}
-
 	if (
-		(direction === `forward` &&
-			timelineData.at === timelineData.history.length) ||
-		(direction === `backward` && timelineData.at === 0)
+		(action === `redo` && timelineData.at === timelineData.history.length) ||
+		(action === `undo` && timelineData.at === 0)
 	) {
 		store.logger.warn(
 			`💁`,
 			`timeline`,
 			token.key,
 			`Failed to ${action} at the ${
-				direction === `forward` ? `end` : `beginning`
+				action === `redo` ? `end` : `beginning`
 			} of timeline "${token.key}". There is nothing to ${action}.`,
 		)
 		return
 	}
 
-	timelineData.timeTraveling =
-		direction === `forward` ? `into_future` : `into_past`
-	if (direction === `backward`) {
+	timelineData.timeTraveling = action === `redo` ? `into_future` : `into_past`
+	if (action === `undo`) {
 		--timelineData.at
 	}
 
 	const update = timelineData.history[timelineData.at]
-	const updateValues = (atomUpdate: KeyedStateUpdate<any>) => {
-		const { key, newValue, oldValue } = atomUpdate
-		const value = direction === `forward` ? newValue : oldValue
-		setState({ key, type: `atom` }, value, store)
-	}
-	const updateValuesFromTransactionUpdate = (
-		transactionUpdate: TransactionUpdate<any>,
-	) => {
-		const updates =
-			direction === `forward`
-				? transactionUpdate.updates
-				: [...transactionUpdate.updates].reverse()
-		for (const updateFromTransaction of updates) {
-			if (`newValue` in updateFromTransaction) {
-				updateValues(updateFromTransaction)
-			} else {
-				updateValuesFromTransactionUpdate(updateFromTransaction)
-			}
-		}
-	}
+	const applying = action === `redo` ? `newValue` : `oldValue`
 
 	switch (update.type) {
 		case `atom_update`: {
-			updateValues(update)
+			ingestAtomUpdate(applying, update, store)
 			break
 		}
 		case `selector_update`: {
-			const updates =
-				direction === `forward`
-					? update.atomUpdates
-					: [...update.atomUpdates].reverse()
-			for (const atomUpdate of updates) {
-				updateValues(atomUpdate)
-			}
+			ingestSelectorUpdate(applying, update, store)
 			break
 		}
 		case `transaction_update`: {
-			updateValuesFromTransactionUpdate(update)
+			ingestTransactionUpdate(applying, update, store)
 			break
 		}
 	}
 
-	if (direction === `forward`) {
+	if (action === `redo`) {
 		++timelineData.at
 	}
 

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

@@ -1,56 +1,10 @@
-import type { AtomToken, KeyedStateUpdate, TransactionUpdate, ƒn } from "atom.io"
-import { setState } from "atom.io"
+import type { ƒn } from "atom.io"
 
+import { ingestTransactionUpdate } from "../ingest-updates"
 import { newest } from "../lineage"
 import { withdraw } from "../store"
 import type { Store } from "../store"
 
-function ingestAtomUpdate(
-	update: KeyedStateUpdate<any>,
-	parent: Store,
-	child: Store,
-): void {
-	const { key, newValue } = update
-	const token: AtomToken<unknown> = { key, type: `atom` }
-	if (!parent.valueMap.has(token.key)) {
-		if (token.family) {
-			const family = parent.families.get(token.family.key)
-			if (family) {
-				family(token.family.subKey)
-			}
-		} else {
-			const newAtom = child.atoms.get(token.key)
-			if (!newAtom) {
-				throw new Error(
-					`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${child.transactionMeta?.update.key}" to store "${parent.config.name}"`,
-				)
-			}
-			parent.atoms.set(newAtom.key, newAtom)
-			parent.valueMap.set(newAtom.key, newAtom.default)
-			parent.logger.info(
-				`🔨`,
-				`transaction`,
-				child.transactionMeta?.update.key ?? `???`,
-				`Adding atom "${newAtom.key}"`,
-			)
-		}
-	}
-	setState(token, newValue, parent)
-}
-function ingestTransactionUpdate(
-	transactionUpdate: TransactionUpdate<any>,
-	parent: Store,
-	child: Store,
-): void {
-	for (const update of transactionUpdate.updates) {
-		if (`newValue` in update) {
-			ingestAtomUpdate(update, parent, child)
-		} else {
-			ingestTransactionUpdate(update, parent, child)
-		}
-	}
-}
-
 export const applyTransaction = <ƒ extends ƒn>(
 	output: ReturnType<ƒ>,
 	store: Store,
@@ -102,7 +56,7 @@ export const applyTransaction = <ƒ extends ƒn>(
 			)
 		}
 	}
-	ingestTransactionUpdate(child.transactionMeta.update, parent, child)
+	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent)
 	if (parent.transactionMeta === null) {
 		const myTransaction = withdraw<ƒ>(
 			{ key: child.transactionMeta.update.key, type: `transaction` },

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

@@ -1,6 +1,9 @@
+import { findInStore, getState, runTransaction, setState } from "atom.io"
+import type { findState } from "atom.io"
+
 import { Junction } from "~/packages/rel8/junction/src"
 
-import { getState, runTransaction, setState } from "~/packages/atom.io/src"
+import { getEnvironmentData } from "../get-environment-data"
 import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -9,6 +12,7 @@ export const buildTransaction = (
 	key: string,
 	params: any[],
 	store: Store,
+	id?: string,
 ): void => {
 	const parent = newest(store)
 	const child: Store = {
@@ -40,6 +44,7 @@ export const buildTransaction = (
 		time: Date.now(),
 		update: {
 			key,
+			id: id ?? Math.random().toString(36).slice(2),
 			updates: [],
 			params,
 			output: undefined,
@@ -48,6 +53,8 @@ export const buildTransaction = (
 			get: (token) => getState(token, child),
 			set: (token, value) => setState(token, value, child),
 			run: (token) => runTransaction(token, child),
+			find: ((token, key) => findInStore(token, key, child)) as typeof findState,
+			env: () => getEnvironmentData(child),
 		},
 	}
 	parent.child = child

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

@@ -18,7 +18,7 @@ export type Transaction<ƒ extends ƒn> = {
 	type: `transaction`
 	install: (store: Store) => void
 	subject: Subject<TransactionUpdate<ƒ>>
-	run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
+	run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>
 }
 
 export function createTransaction<ƒ extends ƒn>(
@@ -28,8 +28,8 @@ export function createTransaction<ƒ extends ƒn>(
 	const newTransaction: Transaction<ƒ> = {
 		key: options.key,
 		type: `transaction`,
-		run: (...params: Parameters<ƒ>) => {
-			buildTransaction(options.key, params, store)
+		run: (params: Parameters<ƒ>, id?: string) => {
+			buildTransaction(options.key, params, store, id)
 			try {
 				const target = newest(store)
 				// biome-ignore lint/style/noNonNullAssertion: this happens right above

package/internal/src/transaction/index.ts

@@ -1,4 +1,4 @@
-import type { TransactionUpdate, TransactorsWithRun, ƒn } from "atom.io"
+import type { TransactionUpdate, TransactorsWithRunAndEnv, ƒn } from "atom.io"
 
 export * from "./abort-transaction"
 export * from "./apply-transaction"
@@ -12,5 +12,5 @@ export type TransactionMeta<ƒ extends ƒn> = {
 	phase: `applying` | `building`
 	time: number
 	update: TransactionUpdate<ƒ>
-	transactors: TransactorsWithRun
+	transactors: TransactorsWithRunAndEnv
 }