atom.io 0.17.0 → 0.18.1

package/internal/src/arbitrary.ts

@@ -0,0 +1,3 @@
+export function arbitrary(random: () => number = Math.random): string {
+	return random().toString(36).slice(2)
+}

package/internal/src/atom/delete-atom.ts

@@ -1,12 +1,9 @@
-import type { RegularAtomToken } from "atom.io"
+import type { AtomToken } from "atom.io"
 
 import type { Store } from ".."
-import { deleteSelector, newest } from ".."
+import { deleteSelector, getUpdateToken, newest } from ".."
 
-export function deleteAtom(
-	atomToken: RegularAtomToken<unknown>,
-	store: Store,
-): void {
+export function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void {
 	const target = newest(store)
 	const { key } = atomToken
 	const atom = target.atoms.get(key)
@@ -35,5 +32,9 @@ export function deleteAtom(
 	target.selectorAtoms.delete(key)
 	target.atomsThatAreDefault.delete(key)
 	target.timelineAtoms.delete(key)
+	if (atomToken.type === `mutable_atom`) {
+		const updateToken = getUpdateToken(atomToken)
+		deleteAtom(updateToken, store)
+	}
 	store.logger.info(`🔥`, `atom`, `${key}`, `deleted`)
 }

package/internal/src/caching.ts

@@ -1,7 +1,7 @@
 import type { StateUpdate } from "atom.io"
-import type { ReadableState } from "."
+import { type ReadableState, isChildStore } from "."
 import { Future } from "./future"
-import { copyMutableIfWithinTransaction } from "./set-state/copy-mutable-in-transaction"
+import { copyMutableIfNeeded } from "./set-state/copy-mutable-if-needed"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
 
@@ -54,8 +54,10 @@ export const readCachedValue = <T>(
 	target: Store,
 ): T => {
 	let value = target.valueMap.get(token.key) as T
-	if (token.type === `atom`) {
-		value = copyMutableIfWithinTransaction(value, token, target)
+	if (token.type === `mutable_atom` && isChildStore(target)) {
+		const { parent } = target
+		const copiedValue = copyMutableIfNeeded(token, parent, target)
+		value = copiedValue
 	}
 	return value
 }

package/internal/src/families/find-in-store.ts

@@ -1,6 +1,8 @@
 import type { Json } from "atom.io/json"
 
 import type {
+	AtomFamilyToken,
+	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -9,6 +11,8 @@ import type {
 	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
+	SelectorFamilyToken,
+	SelectorToken,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
@@ -35,6 +39,12 @@ export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	store: Store,
 ): RegularAtomToken<T>
 
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T>
+
 export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
@@ -47,6 +57,12 @@ export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	store: Store,
 ): ReadonlySelectorToken<T>
 
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T>
+
 export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,

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

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

package/internal/src/index.ts

@@ -6,6 +6,7 @@ import type { Store } from "./store"
 import type { Subject } from "./subject"
 
 export * from "./atom"
+export * from "./arbitrary"
 export * from "./caching"
 export * from "./lineage"
 export * from "./families"
@@ -26,14 +27,14 @@ export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
 
-export type BaseStateData = {
+export type AtomIOState = {
 	key: string
 	family?: FamilyMetadata
 	install: (store: Store) => void
 	subject: Subject<{ newValue: any; oldValue: any }>
 }
 
-export type RegularAtom<T> = BaseStateData & {
+export type RegularAtom<T> = AtomIOState & {
 	type: `atom`
 	default: T | (() => T)
 	cleanup?: () => void
@@ -41,7 +42,7 @@ export type RegularAtom<T> = BaseStateData & {
 export type MutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-> = BaseStateData &
+> = AtomIOState &
 	JsonInterface<T, J> & {
 		type: `mutable_atom`
 		default: T | (() => T)
@@ -51,12 +52,12 @@ export type Atom<T> =
 	| RegularAtom<T>
 	| (T extends Transceiver<any> ? MutableAtom<T, any> : never)
 
-export type WritableSelector<T> = BaseStateData & {
+export type WritableSelector<T> = AtomIOState & {
 	type: `selector`
 	get: () => T
 	set: (newValue: T | ((oldValue: T) => T)) => void
 }
-export type ReadonlySelector<T> = BaseStateData & {
+export type ReadonlySelector<T> = AtomIOState & {
 	type: `readonly_selector`
 	get: () => T
 }

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

@@ -1,4 +1,4 @@
-import type { KeyedStateUpdate } from "atom.io"
+import type { KeyedStateUpdate, RegularAtomToken } from "atom.io"
 
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
@@ -10,5 +10,9 @@ export function ingestAtomUpdate(
 ): void {
 	const { key, newValue, oldValue } = atomUpdate
 	const value = applying === `newValue` ? newValue : oldValue
-	setIntoStore({ key, type: `atom` }, value, store)
+	const token: RegularAtomToken<unknown> = { key, type: `atom` }
+	if (atomUpdate.family) {
+		Object.assign(token, { family: atomUpdate.family })
+	}
+	setIntoStore(token, value, store)
 }

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

@@ -1,7 +1,6 @@
 import type { TransactionUpdate } from "atom.io"
 
 import type { Store } from "../store"
-import { isRootStore } from "../transaction/is-root-store"
 import { ingestAtomUpdate } from "./ingest-atom-update"
 
 export function ingestTransactionUpdate(

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

@@ -1,5 +1,4 @@
 import type {
-	FamilyMetadata,
 	ReadonlySelectorOptions,
 	ReadonlySelectorToken,
 	WritableSelectorOptions,
@@ -7,7 +6,6 @@ import type {
 } from "atom.io"
 
 import type { Store } from "../store"
-import type { Subject } from "../subject"
 import { createReadonlySelector } from "./create-readonly-selector"
 import { createWritableSelector } from "./create-writable-selector"
 

package/internal/src/set-state/copy-mutable-if-needed.ts

@@ -9,7 +9,12 @@ export function copyMutableIfNeeded<T extends Transceiver<any>>(
 ): T {
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)
+
 	if (originValue === targetValue) {
+		if (originValue === undefined) {
+			return typeof atom.default === `function` ? atom.default() : atom.default
+		}
+
 		origin.logger.info(`📃`, `atom`, `${atom.key}`, `copying`)
 		const jsonValue = atom.toJson(originValue)
 		const copiedValue = atom.fromJson(jsonValue)

package/internal/src/set-state/emit-update.ts

@@ -8,16 +8,30 @@ export const emitUpdate = <T>(
 	update: StateUpdate<T>,
 	store: Store,
 ): void => {
-	store.logger.info(
-		`📢`,
-		state.type,
-		state.key,
-		`went (`,
-		update.oldValue,
-		`->`,
-		update.newValue,
-		`) subscribers:`,
-		state.subject.subscribers,
-	)
+	switch (state.type) {
+		case `mutable_atom`:
+			store.logger.info(
+				`📢`,
+				state.type,
+				state.key,
+				`is now (`,
+				update.newValue,
+				`) subscribers:`,
+				state.subject.subscribers,
+			)
+			break
+		default:
+			store.logger.info(
+				`📢`,
+				state.type,
+				state.key,
+				`went (`,
+				update.oldValue,
+				`->`,
+				update.newValue,
+				`) subscribers:`,
+				state.subject.subscribers,
+			)
+	}
 	state.subject.next(update)
 }

package/internal/src/set-state/set-atom.ts

@@ -5,9 +5,9 @@ import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import type { Transceiver } from "../mutable"
 import { markDone } from "../operation"
 import type { Store } from "../store"
-import { isRootStore } from "../transaction/is-root-store"
+import { isChildStore, isRootStore } from "../transaction/is-root-store"
 import { become } from "./become"
-import { copyMutableIfWithinTransaction } from "./copy-mutable-in-transaction"
+import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 import { emitUpdate } from "./emit-update"
 import { evictDownStream } from "./evict-downstream"
 import { stowUpdate } from "./stow-update"
@@ -18,7 +18,12 @@ export const setAtom = <T>(
 	target: Store,
 ): void => {
 	const oldValue = readOrComputeValue(atom, target)
-	let newValue = copyMutableIfWithinTransaction(oldValue, atom, target)
+	let newValue = oldValue
+	if (atom.type === `mutable_atom` && isChildStore(target)) {
+		const { parent } = target
+		const copiedValue = copyMutableIfNeeded(atom, parent, target)
+		newValue = copiedValue
+	}
 	newValue = become(next)(newValue)
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
 	newValue = cacheValue(atom.key, newValue, atom.subject, target)
@@ -36,22 +41,14 @@ export const setAtom = <T>(
 		} else if (atom.key.startsWith(`*`)) {
 			const mutableKey = atom.key.slice(1)
 			const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
-			let mutable: Transceiver<any> = target.valueMap.get(mutableKey)
-			mutable = copyMutableIfWithinTransaction(mutable, mutableAtom, target)
-			const output = mutable.do(update.newValue)
-			if (output !== null) {
-				target.logger.warn(
-					`❌`,
-					`mutable_atom`,
-					mutableKey,
-					`could not be updated.`,
-					typeof output === `number`
-						? `Expected update number ${
-								mutable.cacheUpdateNumber + 1
-						  }, but got ${output}`
-						: output,
-				)
+			let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
+			if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
+				const { parent } = target
+				const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target)
+				transceiver = copiedValue
 			}
+			const accepted = transceiver.do(update.newValue) === null
+			if (accepted) evictDownStream(mutableAtom, target)
 		}
 	}
 }

package/internal/src/store/store.ts

@@ -32,6 +32,7 @@ import type {
 	TransactionEpoch,
 	TransactionProgress,
 } from "../transaction"
+import { isRootStore } from "../transaction/is-root-store"
 
 export class Store implements Lineage {
 	public parent: Store | null = null
@@ -93,7 +94,11 @@ export class Store implements Lineage {
 	}
 	public operation: OperationProgress = { open: false }
 	public transactionMeta: TransactionEpoch | TransactionProgress<ƒn> = {
-		epoch: -1,
+		epoch: new Map<string, number>(),
+		actionContinuities: new Junction({
+			between: [`continuity`, `action`],
+			cardinality: `1:n`,
+		}),
 	}
 
 	public config: {
@@ -121,7 +126,14 @@ export class Store implements Lineage {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
-			this.transactionMeta = { ...store?.transactionMeta }
+			if (isRootStore(store)) {
+				this.transactionMeta = {
+					epoch: new Map(store?.transactionMeta.epoch),
+					actionContinuities: new Junction(
+						store?.transactionMeta.actionContinuities.toJSON(),
+					),
+				}
+			}
 
 			this.config = {
 				...store?.config,

package/internal/src/store/withdraw.ts

@@ -1,18 +1,31 @@
 import type {
+	AtomFamily,
+	AtomFamilyToken,
 	AtomToken,
+	MutableAtomFamily,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableToken,
+	ReadonlySelectorFamily,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
+	RegularAtomFamily,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
+	SelectorFamily,
+	SelectorFamilyToken,
 	SelectorToken,
 	TimelineManageable,
 	TimelineToken,
 	TransactionToken,
+	WritableSelectorFamily,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 	ƒn,
 } from "atom.io"
 
+import type { Json } from "atom.io/json"
 import type {
 	Atom,
 	MutableAtom,
@@ -28,7 +41,24 @@ import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-export type Withdrawable = ReadableState<any> | Timeline<any> | Transaction<any>
+export type Withdrawable =
+	| Atom<any>
+	| AtomFamily<any, any>
+	| MutableAtom<any, any>
+	| MutableAtomFamily<any, any, any>
+	| ReadableState<any>
+	| ReadableState<any>
+	| ReadonlySelector<any>
+	| ReadonlySelectorFamily<any, any>
+	| RegularAtom<any>
+	| RegularAtomFamily<any, any>
+	| Selector<any>
+	| SelectorFamily<any, any>
+	| Timeline<any>
+	| Transaction<any>
+	| WritableSelector<any>
+	| WritableSelectorFamily<any, any>
+	| WritableState<any>
 
 export function withdraw<T>(
 	token: RegularAtomToken<T>,
@@ -62,6 +92,36 @@ export function withdraw<T>(
 	token: ReadableToken<T>,
 	store: Store,
 ): ReadableState<T> | undefined
+
+export function withdraw<T, K extends Json.Serializable>(
+	token: RegularAtomFamilyToken<T, K>,
+	store: Store,
+): RegularAtomFamily<T, K> | undefined
+export function withdraw<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	store: Store,
+): MutableAtomFamily<T, J, K> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: AtomFamilyToken<T>,
+	store: Store,
+): AtomFamily<T, any> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	store: Store,
+): ReadonlySelectorFamily<T, any> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: WritableSelectorFamilyToken<T, K>,
+	store: Store,
+): WritableSelectorFamily<T, any> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: SelectorFamilyToken<T, K>,
+	store: Store,
+): SelectorFamily<T, any> | undefined
+
 export function withdraw<T>(
 	token: TransactionToken<T>,
 	store: Store,
@@ -72,11 +132,15 @@ export function withdraw<T>(
 ): Timeline<T extends TimelineManageable ? T : never> | undefined
 export function withdraw<T>(
 	token:
+		| RegularAtomFamilyToken<T, any>
 		| RegularAtomToken<T>
+		| SelectorFamilyToken<T, any>
 		| SelectorToken<T>
 		| TimelineToken<T>
 		| TransactionToken<T>
-		| (T extends Transceiver<any> ? MutableAtomToken<T, any> : never),
+		| (T extends Transceiver<any>
+				? MutableAtomFamilyToken<T, any, any> | MutableAtomToken<T, any>
+				: never),
 	store: Store,
 ): Withdrawable | undefined {
 	let withdrawn: Withdrawable | undefined
@@ -93,6 +157,12 @@ export function withdraw<T>(
 			case `readonly_selector`:
 				withdrawn = target.readonlySelectors.get(token.key)
 				break
+			case `atom_family`:
+			case `mutable_atom_family`:
+			case `selector_family`:
+			case `readonly_selector_family`:
+				withdrawn = target.families.get(token.key)
+				break
 			case `timeline`:
 				withdrawn = target.timelines.get(token.key)
 				break

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

@@ -1,6 +1,6 @@
 import type { TimelineManageable, TimelineToken, TimelineUpdate } from "atom.io"
-import type { Store } from "atom.io/internal"
-import { withdraw } from "atom.io/internal"
+import type { Store } from ".."
+import { withdraw } from ".."
 
 export const subscribeToTimeline = <ManagedAtom extends TimelineManageable>(
 	token: TimelineToken<ManagedAtom>,

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

@@ -1,6 +1,6 @@
 import type { TransactionToken, TransactionUpdateHandler, ƒn } from "atom.io"
-import type { Store } from "atom.io/internal"
-import { withdraw } from "atom.io/internal"
+import type { Store } from ".."
+import { withdraw } from ".."
 
 export const subscribeToTransaction = <ƒ extends ƒn>(
 	token: TransactionToken<ƒ>,

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

@@ -1,5 +1,6 @@
 import type {
 	AtomFamily,
+	AtomFamilyToken,
 	FamilyMetadata,
 	StateUpdate,
 	TimelineManageable,
@@ -86,7 +87,17 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 			tokenOrFamily.type === `atom_family` ||
 			tokenOrFamily.type === `mutable_atom_family`
 		) {
-			const family: AtomFamily<any> = tokenOrFamily
+			const familyToken: AtomFamilyToken<any> = tokenOrFamily
+			const family = withdraw(familyToken, store)
+			if (family === undefined) {
+				store.logger.error(
+					`❌`,
+					`timeline`,
+					options.key,
+					`Failed to add family "${familyToken.key}" because it does not exist in the store`,
+				)
+				continue
+			}
 			const familyKey = family.key
 			target.timelineAtoms.set({ atomKey: familyKey, timelineKey })
 			family.subject.subscribe(`timeline:${options.key}`, (token) => {

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

@@ -0,0 +1,19 @@
+import type { TransactionToken, ƒn } from "atom.io"
+
+import { NotFoundError } from "../not-found-error"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+
+export function actUponStore<ƒ extends ƒn>(
+	token: TransactionToken<ƒ>,
+	id: string,
+	store: Store,
+): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
+	return (...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
+		const tx = withdraw(token, store)
+		if (tx) {
+			return tx.run(parameters, id)
+		}
+		throw new NotFoundError(token, store)
+	}
+}

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

@@ -5,6 +5,7 @@ import { newest } from "../lineage"
 import { withdraw } from "../store"
 import type { Store } from "../store"
 import { isChildStore, isRootStore } from "./is-root-store"
+import { setEpochNumberOfAction } from "./set-epoch-number"
 
 export const applyTransaction = <ƒ extends ƒn>(
 	output: ReturnType<ƒ>,
@@ -59,7 +60,11 @@ export const applyTransaction = <ƒ extends ƒn>(
 	}
 	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent)
 	if (isRootStore(parent)) {
-		parent.transactionMeta.epoch = child.transactionMeta.update.epoch
+		setEpochNumberOfAction(
+			child.transactionMeta.update.key,
+			child.transactionMeta.update.epoch,
+			parent,
+		)
 		const myTransaction = withdraw<ƒ>(
 			{ key: child.transactionMeta.update.key, type: `transaction` },
 			store,

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

@@ -0,0 +1,18 @@
+import type { Store } from "../store"
+import { isRootStore } from "./is-root-store"
+
+export function assignTransactionToContinuity(
+	continuityKey: string,
+	transactionKey: string,
+	store: Store,
+): void {
+	const isRoot = isRootStore(store)
+	if (!isRoot) {
+		return
+	}
+	const { epoch, actionContinuities } = store.transactionMeta
+	actionContinuities.set(continuityKey, transactionKey)
+	if (!epoch.has(continuityKey)) {
+		epoch.set(continuityKey, -1)
+	}
+}

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

@@ -1,9 +1,10 @@
-import { runTransaction } from "atom.io"
 import type { findState, ƒn } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
 import type { TransactionProgress } from "."
+import { actUponStore, getEpochNumberOfAction } from "."
+import { arbitrary } from "../arbitrary"
 import { findInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
 import { getFromStore } from "../get-state"
@@ -12,13 +13,12 @@ import { newest } from "../lineage"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 import type { ChildStore, RootStore } from "./is-root-store"
-import { isRootStore } from "./is-root-store"
 
 export const buildTransaction = (
 	key: string,
 	params: any[],
 	store: Store,
-	id?: string,
+	id: string,
 ): ChildStore => {
 	const parent = newest(store) as ChildStore | RootStore
 	const childBase: Omit<ChildStore, `transactionMeta`> = {
@@ -44,12 +44,13 @@ export const buildTransaction = (
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
 	}
+	const epoch = getEpochNumberOfAction(key, store)
 	const transactionMeta: TransactionProgress<ƒn> = {
 		phase: `building` as const,
 		update: {
 			key,
-			id: id ?? Math.random().toString(36).slice(2),
-			epoch: isRootStore(parent) ? parent.transactionMeta.epoch + 1 : NaN,
+			id,
+			epoch: epoch === undefined ? NaN : epoch + 1,
 			updates: [],
 			params,
 			output: undefined,
@@ -57,7 +58,7 @@ export const buildTransaction = (
 		transactors: {
 			get: (token) => getFromStore(token, child),
 			set: (token, value) => setIntoStore(token, value, child),
-			run: (token, id) => runTransaction(token, id, child),
+			run: (token, id = arbitrary()) => actUponStore(token, id, child),
 			find: ((token, key) => findInStore(token, key, child)) as typeof findState,
 			env: () => getEnvironmentData(child),
 		},

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

@@ -28,7 +28,7 @@ export function createTransaction<ƒ extends ƒn>(
 	const newTransaction: Transaction<ƒ> = {
 		key: options.key,
 		type: `transaction`,
-		run: (params: Parameters<ƒ>, id?: string) => {
+		run: (params: Parameters<ƒ>, id: string) => {
 			const childStore = buildTransaction(options.key, params, store, id)
 			try {
 				const target = newest(store)