atom.io 0.39.1 → 0.40.1

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

@@ -15,19 +15,18 @@ import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
 import { MapOverlay } from "../overlays/map-overlay"
 import { resetInStore, setIntoStore } from "../set-state"
-import type { Store } from "../store"
 import type { Fn } from "../utility-types"
 import type { TransactionProgress } from "."
 import { actUponStore, getEpochNumberOfAction } from "."
 import type { ChildStore, RootStore } from "./is-root-store"
 
 export const buildTransaction = (
-	store: Store,
+	store: RootStore,
 	token: TransactionToken<any>,
 	params: any[],
 	id: string,
 ): ChildStore => {
-	const parent = newest(store) as ChildStore | RootStore
+	const parent = newest(store)
 	const childBase: Omit<ChildStore, `transactionMeta`> = {
 		parent,
 		child: null,
@@ -97,7 +96,7 @@ export const buildTransaction = (
 		`🛫`,
 		`transaction`,
 		token.key,
-		`Building transaction with params:`,
+		`building with params:`,
 		params,
 	)
 	return child

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

@@ -5,24 +5,24 @@ import type {
 } from "atom.io"
 
 import { newest } from "../lineage"
-import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
 import type { Fn } from "../utility-types"
 import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"
 import { buildTransaction } from "./build-transaction"
+import type { RootStore } from "./is-root-store"
 
 export type Transaction<F extends Fn> = {
 	key: string
 	type: `transaction`
-	install: (store: Store) => void
+	install: (store: RootStore) => void
 	subject: Subject<TransactionOutcomeEvent<TransactionToken<F>>>
 	run: (parameters: Parameters<F>, id?: string) => ReturnType<F>
 }
 
 export function createTransaction<F extends Fn>(
-	store: Store,
+	store: RootStore,
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {
 	const { key } = options
@@ -32,10 +32,9 @@ export function createTransaction<F extends Fn>(
 		type: `transaction`,
 		run: (params: Parameters<F>, id: string) => {
 			const token = deposit(newTransaction)
-			const childStore = buildTransaction(store, token, params, id)
+			const target = buildTransaction(store, token, params, id)
 			try {
-				const target = newest(store)
-				const { toolkit } = childStore.transactionMeta
+				const { toolkit } = target.transactionMeta
 				const output = options.do(toolkit, ...params)
 				applyTransaction<F>(target, output)
 				return output

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

@@ -1,6 +1,4 @@
-import type { Store } from "../store"
 import type { RootStore } from "./is-root-store"
-import { isRootStore } from "./is-root-store"
 
 export function getContinuityKey(
 	store: RootStore,
@@ -21,13 +19,9 @@ export function getEpochNumberOfContinuity(
 }
 
 export function getEpochNumberOfAction(
-	store: Store,
+	store: RootStore,
 	transactionKey: string,
 ): number | undefined {
-	const isRoot = isRootStore(store)
-	if (!isRoot) {
-		return undefined
-	}
 	const continuityKey = getContinuityKey(store, transactionKey)
 	if (continuityKey === undefined) {
 		return undefined

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

@@ -1,27 +1,19 @@
-import type { Store } from "../store"
 import { getContinuityKey } from "./get-epoch-number"
-import { isRootStore } from "./is-root-store"
+import type { RootStore } from "./is-root-store"
 
 export function setEpochNumberOfContinuity(
-	store: Store,
+	store: RootStore,
 	continuityKey: string,
 	newEpoch: number,
 ): void {
-	const isRoot = isRootStore(store)
-	if (isRoot && continuityKey) {
-		store.transactionMeta.epoch.set(continuityKey, newEpoch)
-	}
+	store.transactionMeta.epoch.set(continuityKey, newEpoch)
 }
 
 export function setEpochNumberOfAction(
-	store: Store,
+	store: RootStore,
 	transactionKey: string,
 	newEpoch: number,
 ): void {
-	const isRoot = isRootStore(store)
-	if (!isRoot) {
-		return
-	}
 	const continuityKey = getContinuityKey(store, transactionKey)
 
 	if (continuityKey !== undefined) {

package/src/introspection/attach-introspection-states.ts

@@ -6,7 +6,7 @@ import type {
 	TransactionOutcomeEvent,
 	TransactionToken,
 } from "atom.io"
-import type { Fn, Store, Timeline } from "atom.io/internal"
+import type { Fn, RootStore, Store, Timeline } from "atom.io/internal"
 
 import { type AtomTokenIndex, attachAtomIndex } from "./attach-atom-index"
 import type { SelectorTokenIndex } from "./attach-selector-index"
@@ -30,7 +30,9 @@ export type IntrospectionStates = {
 	typeSelectors: ReadonlyPureSelectorFamilyToken<Loadable<string>, string>
 }
 
-export const attachIntrospectionStates = (store: Store): IntrospectionStates => {
+export const attachIntrospectionStates = (
+	store: RootStore,
+): IntrospectionStates => {
 	return {
 		atomIndex: attachAtomIndex(store),
 		selectorIndex: attachSelectorIndex(store),

package/src/introspection/attach-timeline-family.ts

@@ -1,5 +1,5 @@
 import type { ReadonlyPureSelectorFamilyToken } from "atom.io"
-import type { Store, Timeline } from "atom.io/internal"
+import type { RootStore, Timeline } from "atom.io/internal"
 import {
 	createRegularAtomFamily,
 	createSelectorFamily,
@@ -7,7 +7,7 @@ import {
 } from "atom.io/internal"
 
 export const attachTimelineFamily = (
-	store: Store,
+	store: RootStore,
 ): ReadonlyPureSelectorFamilyToken<Timeline<any>, string> => {
 	const findTimelineLogState__INTERNAL = createRegularAtomFamily<
 		Timeline<any>,

package/src/introspection/attach-transaction-logs.ts

@@ -3,11 +3,11 @@ import type {
 	TransactionOutcomeEvent,
 	TransactionToken,
 } from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { createRegularAtomFamily, createSelectorFamily } from "atom.io/internal"
 
 export const attachTransactionLogs = (
-	store: Store,
+	store: RootStore,
 ): ReadonlyPureSelectorFamilyToken<
 	TransactionOutcomeEvent<TransactionToken<any>>[],
 	string

package/src/introspection/attach-type-selectors.ts

@@ -1,11 +1,11 @@
 import type { Loadable, ReadonlyPureSelectorFamilyToken } from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { createReadonlyPureSelectorFamily } from "atom.io/internal"
 
 import { discoverType } from "./refinery"
 
 export const attachTypeSelectors = (
-	store: Store,
+	store: RootStore,
 ): ReadonlyPureSelectorFamilyToken<Loadable<string>, string> => {
 	const typeSelectors = createReadonlyPureSelectorFamily<
 		Loadable<string>,

package/src/main/dispose-state.ts

@@ -30,9 +30,5 @@ export function disposeState(
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): void {
-	if (params.length === 2) {
-		disposeFromStore(IMPLICIT.STORE, ...params)
-	} else {
-		disposeFromStore(IMPLICIT.STORE, ...params)
-	}
+	disposeFromStore(IMPLICIT.STORE, ...params)
 }

package/src/main/events.ts

@@ -23,10 +23,13 @@ export type AtomUpdateEvent<A extends AtomToken<any>> = {
 	timestamp: number
 }
 
+export type SelectorUpdateSubEvent<A extends AtomToken<any>> =
+	| AtomUpdateEvent<A>
+	| StateCreationEvent<any>
 export type TimelineSelectorUpdateEvent<A extends TimelineManageable> = {
 	type: `selector_update`
 	token: SelectorToken<any>
-	atomUpdates: AtomUpdateEvent<AtomOnly<A>>[]
+	subEvents: SelectorUpdateSubEvent<AtomOnly<A>>[]
 	timestamp: number
 }
 
@@ -110,11 +113,12 @@ export type TransactionOutcomeEvent<T extends TransactionToken<any>> = {
 	output: ReturnType<TokenType<T>>
 }
 
-export type TimelineEvent<ManagedAtom extends TimelineManageable> =
+export type TimelineEvent<ManagedAtom extends TimelineManageable> = {
+	checkpoint?: true
+} & (
 	| AtomUpdateEvent<AtomOnly<ManagedAtom>>
-	| MoleculeCreationEvent
-	| MoleculeDisposalEvent
 	| StateCreationEvent<AtomOnly<ManagedAtom>>
 	| StateDisposalEvent<AtomOnly<ManagedAtom>>
 	| TimelineSelectorUpdateEvent<ManagedAtom>
 	| TransactionOutcomeEvent<TransactionToken<any>>
+)

package/src/main/get-state.ts

@@ -25,13 +25,10 @@ export function getState<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): ViewOf<T>
 
-export function getState(
+export function getState<T, K extends Canonical, Key extends K>(
 	...params:
-		| [token: ReadableFamilyToken<any, any>, key: Canonical]
-		| [token: ReadableToken<any>]
+		| [token: ReadableFamilyToken<T, K>, key: Key]
+		| [token: ReadableToken<T>]
 ): any {
-	if (params.length === 2) {
-		return getFromStore(IMPLICIT.STORE, ...params)
-	}
 	return getFromStore(IMPLICIT.STORE, ...params)
 }

package/src/main/logger.ts

@@ -37,7 +37,7 @@ const LOGGER_ICON_DICTIONARY = {
 	"⏭️": `Transaction redo`,
 	"⏮️": `Transaction undo`,
 	"⏳": `Timeline event partially captured`,
-	"⏹️": `Time-travel complete`,
+	"⏸️": `Time-travel complete`,
 	// Problems
 	"💣": `Dangerous action likely to cause bad errors down the line`,
 	"❗": `Dangerous action unless in development mode`,

package/src/main/realm.ts

@@ -1,24 +1,39 @@
-import type { Each, Store } from "atom.io/internal"
+import type { Each, RootStore } from "atom.io/internal"
 import {
+	actUponStore,
 	allocateIntoStore,
+	arbitrary,
 	claimWithinStore,
-	deallocateFromStore,
+	createClaimTX,
+	createDeallocateTX,
 	fuseWithinStore,
 	IMPLICIT,
 	makeRootMoleculeInStore,
 } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
+import type { TransactionToken } from "./tokens"
+
 export const $claim: unique symbol = Symbol.for(`claim`)
 export type Claim<K extends Canonical> = K & { [$claim]?: true }
 
 export class Realm<H extends Hierarchy> {
-	public store: Store
+	public store: RootStore
+	public deallocateTX: TransactionToken<(claim: Claim<Vassal<H>>) => void>
+	public claimTX: TransactionToken<
+		<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(
+			newProvenance: A,
+			claim: Claim<V>,
+			exclusive?: `exclusive`,
+		) => void
+	>
 	/**
 	 * @param store - The store to which the realm will be attached
 	 */
-	public constructor(store: Store = IMPLICIT.STORE) {
+	public constructor(store: RootStore = IMPLICIT.STORE) {
 		this.store = store
+		this.deallocateTX = createDeallocateTX(store)
+		this.claimTX = createClaimTX(store)
 		makeRootMoleculeInStore(`root`, store)
 	}
 	/**
@@ -66,7 +81,7 @@ export class Realm<H extends Hierarchy> {
 	 * @param claim - The subject to be deallocated
 	 */
 	public deallocate<V extends Vassal<H>>(claim: Claim<V>): void {
-		deallocateFromStore<H, V>(this.store, claim)
+		actUponStore(this.store, this.deallocateTX, arbitrary())(claim)
 	}
 	/**
 	 * Transfer a subject of the realm from one owner to another
@@ -79,21 +94,30 @@ export class Realm<H extends Hierarchy> {
 	public claim<
 		V extends Exclude<Vassal<H>, CompoundTypedKey>,
 		A extends Above<V, H>,
-	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V> {
-		return claimWithinStore<H, V, A>(this.store, newProvenance, claim, exclusive)
+	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): void {
+		actUponStore(this.store, this.claimTX, arbitrary())(
+			newProvenance,
+			claim,
+			exclusive,
+		)
 	}
 }
 
 export class Anarchy {
-	public store: Store
-	public realm: Realm<any>
+	public store: RootStore
+	public deallocateTX: TransactionToken<(key: Canonical) => void>
+	public claimTX: TransactionToken<
+		(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`) => void
+	>
 
 	/**
 	 * @param store - The store to which the anarchy-realm will be attached
 	 */
-	public constructor(store: Store = IMPLICIT.STORE) {
+	public constructor(store: RootStore = IMPLICIT.STORE) {
 		this.store = store
-		this.realm = new Realm(store)
+		this.deallocateTX = createDeallocateTX(store)
+		this.claimTX = createClaimTX(store)
+		makeRootMoleculeInStore(`root`, store)
 	}
 	/**
 	 * Declare a new entity
@@ -118,7 +142,7 @@ export class Anarchy {
 	 * @param key - The entity to be deallocated
 	 */
 	public deallocate(key: Canonical): void {
-		deallocateFromStore<any, any>(this.store, key)
+		actUponStore(this.store, this.deallocateTX, arbitrary())(key)
 	}
 	/**
 	 * Transfer an entity from one owner to another

package/src/main/reset-state.ts

@@ -25,9 +25,5 @@ export function resetState(
 		| [token: WritableFamilyToken<any, Canonical>, key: Canonical]
 		| [token: WritableToken<any>]
 ): void {
-	if (params.length === 2) {
-		resetInStore(IMPLICIT.STORE, ...params)
-	} else {
-		resetInStore(IMPLICIT.STORE, ...params)
-	}
+	resetInStore(IMPLICIT.STORE, ...params)
 }

package/src/main/set-state.ts

@@ -35,18 +35,11 @@ export function setState<T, K extends Canonical, New extends T, Key extends K>(
 	key: Key,
 	value: New | Setter<T, New>,
 ): void
-export function setState<T, New extends T>(
+
+export function setState<T, K extends Canonical, New extends T, Key extends K>(
 	...params:
-		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
-				value: New | Setter<T, New>,
-		  ]
+		| [token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>]
 		| [token: WritableToken<T>, value: New | Setter<T, New>]
 ): void {
-	if (params.length === 2) {
-		setIntoStore(IMPLICIT.STORE, ...params)
-	} else {
-		setIntoStore(IMPLICIT.STORE, ...params)
-	}
+	setIntoStore(IMPLICIT.STORE, ...params)
 }

package/src/main/silo.ts

@@ -1,4 +1,5 @@
 import type { findState } from "atom.io"
+import type { RootStore } from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
@@ -38,7 +39,7 @@ import type { selector, selectorFamily } from "./selector"
 import type { runTransaction, transaction } from "./transaction"
 
 export class Silo {
-	public store: Store
+	public store: RootStore
 	public atom: typeof atom
 	public mutableAtom: typeof mutableAtom
 	public atomFamily: typeof atomFamily
@@ -56,10 +57,10 @@ export class Silo {
 	public undo: typeof undo
 	public redo: typeof redo
 	public runTransaction: typeof runTransaction
-	public install: (tokens: AtomIOToken[], store?: Store) => void
+	public install: (tokens: AtomIOToken[], store?: RootStore) => void
 
 	public constructor(config: Store[`config`], fromStore: Store | null = null) {
-		const s = (this.store = new Store(config, fromStore))
+		const s = (this.store = new Store(config, fromStore) as RootStore)
 		this.atom = ((options: Parameters<typeof atom>[0]) =>
 			createRegularAtom(s, options, undefined)) as typeof atom
 		this.mutableAtom = ((options: Parameters<typeof mutableAtom>[0]) =>

package/src/main/timeline.ts

@@ -1,7 +1,6 @@
-import type { Timeline } from "atom.io/internal"
 import { createTimeline, IMPLICIT, timeTravel } from "atom.io/internal"
 
-import type { AtomFamilyToken, AtomToken, TimelineEvent, TimelineToken } from "."
+import type { AtomFamilyToken, AtomToken, TimelineToken } from "."
 
 export type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>
 export type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<
@@ -33,11 +32,6 @@ export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 	key: string
 	/** The managed atoms (and families of atoms) to record */
 	scope: ManagedAtom[]
-	/** A function that determines whether a given update should be recorded */
-	shouldCapture?: (
-		update: TimelineEvent<ManagedAtom>,
-		timeline: Timeline<TimelineManageable>,
-	) => boolean
 }
 
 /**

package/src/react/store-context.tsx

@@ -1,14 +1,14 @@
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { IMPLICIT } from "atom.io/internal"
 import * as React from "react"
 
-export const StoreContext: React.Context<Store> = React.createContext(
+export const StoreContext: React.Context<RootStore> = React.createContext(
 	IMPLICIT.STORE,
 )
 
 export const StoreProvider: React.FC<{
 	children: React.ReactNode
-	store?: Store
+	store?: RootStore
 }> = ({ children, store = IMPLICIT.STORE }) => (
 	<StoreContext.Provider value={store}>{children}</StoreContext.Provider>
 )

package/src/react-devtools/Button.tsx

@@ -1,9 +1,10 @@
-import type { Modify } from "atom.io/internal"
 import type { FC } from "react"
 
 export const OpenClose: FC<{
 	isOpen: boolean
-	setIsOpen?: ((next: Modify<boolean> | boolean) => void) | undefined
+	setIsOpen?:
+		| ((next: boolean | ((prev: boolean) => boolean)) => void)
+		| undefined
 	onShiftClick?: (
 		event: React.MouseEvent<HTMLButtonElement, MouseEvent>,
 	) => boolean

package/src/react-devtools/TimelineIndex.tsx

@@ -64,8 +64,6 @@ export const TimelineLog: FC<{
 			{isOpen ? (
 				<main>
 					{timeline.history.map((update, index) =>
-						update.type !== `molecule_creation` &&
-						update.type !== `molecule_disposal` &&
 						update.type !== `state_creation` &&
 						update.type !== `state_disposal` ? (
 							<Fragment key={update.token.key + index + timeline.at}>

package/src/react-devtools/Updates.tsx

@@ -192,18 +192,23 @@ export const TimelineUpdateFC: React.FC<{
 							}
 						})
 				) : timelineUpdate.type === `selector_update` ? (
-					timelineUpdate.atomUpdates
+					timelineUpdate.subEvents
 						.filter(
 							(atomUpdateEvent) => !atomUpdateEvent.token.key.startsWith(`👁‍🗨`),
 						)
-						.map((atomUpdate, index) => {
-							return (
-								<article.AtomUpdate
-									key={`${timelineUpdate.token.key}:${index}:${atomUpdate.token.key}`}
-									serialNumber={index}
-									atomUpdate={atomUpdate}
-								/>
-							)
+						.map((event, index) => {
+							switch (event.type) {
+								case `atom_update`:
+									return (
+										<article.AtomUpdate
+											key={`${timelineUpdate.token.key}:${index}:${event.token.key}`}
+											serialNumber={index}
+											atomUpdate={event}
+										/>
+									)
+								case `state_creation`:
+									return null
+							}
 						})
 				) : timelineUpdate.type === `atom_update` ? (
 					<article.AtomUpdate

package/src/react-devtools/store.ts

@@ -5,11 +5,11 @@ import type {
 	SelectorToken,
 	TransactionToken,
 } from "atom.io"
+import type { RootStore, Store } from "atom.io/internal"
 import {
 	createRegularAtom,
 	createRegularAtomFamily,
 	createTransaction,
-	type Store,
 } from "atom.io/internal"
 import type {
 	IntrospectionStates,
@@ -34,7 +34,7 @@ export type DevtoolsStates = {
 }
 
 export function attachDevtoolsStates(
-	store: Store,
+	store: RootStore,
 	hideByDefault = false,
 ): DevtoolsStates & IntrospectionStates & { store: Store } {
 	const introspectionStates = attachIntrospectionStates(store)

package/src/realtime-client/continuity/register-and-attempt-confirmed-update.ts

@@ -1,10 +1,9 @@
 import type * as AtomIO from "atom.io"
-import type { Fn, Store } from "atom.io/internal"
+import type { Fn, RootStore } from "atom.io/internal"
 import {
 	actUponStore,
 	getEpochNumberOfContinuity,
 	ingestTransactionOutcomeEvent,
-	isRootStore,
 	setEpochNumberOfContinuity,
 	setIntoStore,
 } from "atom.io/internal"
@@ -16,7 +15,7 @@ import type { Socket } from "atom.io/realtime-server"
 
 export const useRegisterAndAttemptConfirmedUpdate =
 	(
-		store: Store,
+		store: RootStore,
 		continuityKey: string,
 		socket: Socket,
 		optimisticUpdates: AtomIO.TransactionOutcomeEvent<
@@ -187,11 +186,8 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				continuityKey,
 				`has no optimistic updates to deal with`,
 			)
-			const isRoot = isRootStore(store)
 			let continuityEpoch: number | undefined
-			if (isRoot) {
-				continuityEpoch = getEpochNumberOfContinuity(store, continuityKey)
-			}
+			continuityEpoch = getEpochNumberOfContinuity(store, continuityKey)
 
 			if (continuityEpoch === confirmed.epoch - 1) {
 				store.logger.info(
@@ -203,7 +199,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				ingestTransactionOutcomeEvent(store, confirmed, `newValue`)
 				socket.emit(`ack:${continuityKey}`, confirmed.epoch)
 				setEpochNumberOfContinuity(store, continuityKey, confirmed.epoch)
-			} else if (isRoot && continuityEpoch !== undefined) {
+			} else if (continuityEpoch !== undefined) {
 				store.logger.info(
 					`🧑‍⚖️`,
 					`continuity`,

package/src/realtime-client/sync-continuity.ts

@@ -1,4 +1,4 @@
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import {
 	assignTransactionToContinuity,
 	getFromStore,
@@ -20,7 +20,7 @@ import { useConcealState } from "./continuity/use-conceal-state"
 import { useRevealState } from "./continuity/use-reveal-state"
 
 export function syncContinuity(
-	store: Store,
+	store: RootStore,
 	socket: Socket,
 	continuity: ContinuityToken,
 ): () => void {

package/src/realtime-server/index.ts

@@ -1,4 +1,4 @@
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
 export * from "./continuity/prepare-to-sync-realtime-continuity"
@@ -25,5 +25,5 @@ export type Socket = {
 }
 export type ServerConfig = {
 	socket: Socket
-	store?: Store
+	store?: RootStore
 }