atom.io 0.33.12 → 0.33.14

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

@@ -25,11 +25,13 @@ export function createTransaction<F extends Func>(
 	store: Store,
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {
+	const { key } = options
+	const transactionAlreadyExists = store.transactions.has(key)
 	const newTransaction: Transaction<F> = {
-		key: options.key,
+		key,
 		type: `transaction`,
 		run: (params: Parameters<F>, id: string) => {
-			const childStore = buildTransaction(store, options.key, params, id)
+			const childStore = buildTransaction(store, key, params, id)
 			try {
 				const target = newest(store)
 				const { toolkit } = childStore.transactionMeta
@@ -38,7 +40,7 @@ export function createTransaction<F extends Func>(
 				return output
 			} catch (thrown) {
 				abortTransaction(target)
-				store.logger.warn(`💥`, `transaction`, options.key, `caught:`, thrown)
+				store.logger.warn(`💥`, `transaction`, key, `caught:`, thrown)
 				throw thrown
 			}
 		},
@@ -46,8 +48,10 @@ export function createTransaction<F extends Func>(
 		subject: new Subject(),
 	}
 	const target = newest(store)
-	target.transactions.set(newTransaction.key, newTransaction)
+	target.transactions.set(key, newTransaction)
 	const token = deposit(newTransaction)
-	store.on.transactionCreation.next(token)
+	if (!transactionAlreadyExists) {
+		store.on.transactionCreation.next(token)
+	}
 	return token
 }

package/src/introspection/attach-atom-index.ts

@@ -1,8 +1,7 @@
-import type { AtomToken, ReadonlyPureSelectorToken } from "atom.io"
+import type { AtomToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createRegularAtom,
-	createStandaloneSelector,
 	deposit,
 	isReservedIntrospectionKey,
 } from "atom.io/internal"
@@ -11,13 +10,11 @@ import type { WritableTokenIndex } from "."
 
 export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>
 
-export const attachAtomIndex = (
-	store: Store,
-): ReadonlyPureSelectorToken<AtomTokenIndex> => {
-	const atomTokenIndexState__INTERNAL = createRegularAtom<AtomTokenIndex>(
+export const attachAtomIndex = (store: Store): AtomToken<AtomTokenIndex> => {
+	return createRegularAtom<AtomTokenIndex>(
 		store,
 		{
-			key: `🔍 Atom Token Index (Internal)`,
+			key: `🔍 Atom Token Index`,
 			default: () => {
 				const base: AtomTokenIndex = new Map()
 				for (const [key, val] of store.atoms) {
@@ -66,7 +63,7 @@ export const attachAtomIndex = (
 							} else {
 								self.set(atomToken.key, atomToken)
 							}
-							return self
+							return new Map(self)
 						})
 					})
 					store.on.atomDisposal.subscribe(`introspection`, (atomToken) => {
@@ -80,10 +77,8 @@ export const attachAtomIndex = (
 										self.delete(familyKey)
 									}
 								}
-							} else {
-								self.delete(atomToken.key)
 							}
-							return self
+							return new Map(self)
 						})
 					})
 				},
@@ -91,8 +86,4 @@ export const attachAtomIndex = (
 		},
 		undefined,
 	)
-	return createStandaloneSelector(store, {
-		key: `🔍 Atom Token Index`,
-		get: ({ get }) => get(atomTokenIndexState__INTERNAL),
-	})
 }

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

@@ -1,7 +1,7 @@
 import type {
+	AtomToken,
 	Loadable,
 	ReadonlyPureSelectorFamilyToken,
-	ReadonlyPureSelectorToken,
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
@@ -18,14 +18,14 @@ import { attachTransactionLogs } from "./attach-transaction-logs"
 import { attachTypeSelectors } from "./attach-type-selectors"
 
 export type IntrospectionStates = {
-	atomIndex: ReadonlyPureSelectorToken<AtomTokenIndex>
-	selectorIndex: ReadonlyPureSelectorToken<SelectorTokenIndex>
-	transactionIndex: ReadonlyPureSelectorToken<TransactionToken<Func>[]>
+	atomIndex: AtomToken<AtomTokenIndex>
+	selectorIndex: AtomToken<SelectorTokenIndex>
+	transactionIndex: AtomToken<TransactionToken<Func>[]>
 	transactionLogSelectors: ReadonlyPureSelectorFamilyToken<
 		TransactionUpdate<Func>[],
 		string
 	>
-	timelineIndex: ReadonlyPureSelectorToken<TimelineToken<any>[]>
+	timelineIndex: AtomToken<TimelineToken<any>[]>
 	timelineSelectors: ReadonlyPureSelectorFamilyToken<Timeline<any>, string>
 	typeSelectors: ReadonlyPureSelectorFamilyToken<Loadable<string>, string>
 }

package/src/introspection/attach-selector-index.ts

@@ -1,8 +1,7 @@
-import type { ReadonlyPureSelectorToken, SelectorToken } from "atom.io"
+import type { AtomToken, SelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createRegularAtom,
-	createStandaloneSelector,
 	deposit,
 	isReservedIntrospectionKey,
 } from "atom.io/internal"
@@ -13,97 +12,91 @@ export type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>
 
 export const attachSelectorIndex = (
 	store: Store,
-): ReadonlyPureSelectorToken<SelectorTokenIndex> => {
-	const readonlySelectorTokenIndexState__INTERNAL =
-		createRegularAtom<SelectorTokenIndex>(
-			store,
-
-			{
-				key: `🔍 Selector Token Index (Internal)`,
-				default: () => {
-					const base: SelectorTokenIndex = new Map()
-					for (const map of [store.readonlySelectors, store.writableSelectors]) {
-						for (const [key, val] of map) {
-							if (isReservedIntrospectionKey(key)) {
-								continue
-							}
-							const token = deposit(val)
-							if (val.family) {
-								let familyNode = base.get(val.family.key)
-								if (!familyNode || !(`familyMembers` in familyNode)) {
-									familyNode = {
-										key: val.family.key,
-										familyMembers: new Map(),
-									}
-									base.set(val.family.key, familyNode)
+): AtomToken<SelectorTokenIndex> => {
+	return createRegularAtom<SelectorTokenIndex>(
+		store,
+		{
+			key: `🔍 Selector Token Index`,
+			default: () => {
+				const base: SelectorTokenIndex = new Map()
+				for (const map of [store.readonlySelectors, store.writableSelectors]) {
+					for (const [key, val] of map) {
+						if (isReservedIntrospectionKey(key)) {
+							continue
+						}
+						const token = deposit(val)
+						if (val.family) {
+							let familyNode = base.get(val.family.key)
+							if (!familyNode || !(`familyMembers` in familyNode)) {
+								familyNode = {
+									key: val.family.key,
+									familyMembers: new Map(),
 								}
-								familyNode.familyMembers.set(val.family.subKey, token)
-							} else {
-								base.set(key, token)
+								base.set(val.family.key, familyNode)
 							}
+							familyNode.familyMembers.set(val.family.subKey, token)
+						} else {
+							base.set(key, token)
 						}
 					}
-					return base
-				},
-				effects: [
-					({ setSelf }) => {
-						store.on.selectorCreation.subscribe(
-							`introspection`,
-							(selectorToken) => {
-								if (isReservedIntrospectionKey(selectorToken.key)) {
-									return
-								}
+				}
+				return base
+			},
+			effects: [
+				({ setSelf }) => {
+					store.on.selectorCreation.subscribe(
+						`introspection`,
+						(selectorToken) => {
+							if (isReservedIntrospectionKey(selectorToken.key)) {
+								return
+							}
 
-								setSelf((self) => {
-									if (selectorToken.family) {
-										const { key: familyKey, subKey } = selectorToken.family
-										let familyNode = self.get(familyKey)
-										if (
-											familyNode === undefined ||
-											!(`familyMembers` in familyNode)
-										) {
-											familyNode = {
-												key: familyKey,
-												familyMembers: new Map(),
-											}
-											self.set(familyKey, familyNode)
+							setSelf((self) => {
+								if (selectorToken.family) {
+									const { key: familyKey, subKey } = selectorToken.family
+									let familyNode = self.get(familyKey)
+									if (
+										familyNode === undefined ||
+										!(`familyMembers` in familyNode)
+									) {
+										familyNode = {
+											key: familyKey,
+											familyMembers: new Map(),
 										}
-										familyNode.familyMembers.set(subKey, selectorToken)
-									} else {
-										self.set(selectorToken.key, selectorToken)
+										self.set(familyKey, familyNode)
 									}
-									return self
-								})
-							},
-						)
+									familyNode.familyMembers.set(subKey, selectorToken)
+								} else {
+									self.set(selectorToken.key, selectorToken)
+								}
+								return new Map(self)
+							})
+						},
+					)
 
-						store.on.selectorDisposal.subscribe(
-							`introspection`,
-							(selectorToken) => {
-								setSelf((self) => {
-									if (selectorToken.family) {
-										const { key: familyKey, subKey } = selectorToken.family
-										const familyNode = self.get(familyKey)
-										if (familyNode && `familyMembers` in familyNode) {
-											familyNode.familyMembers.delete(subKey)
-											if (familyNode.familyMembers.size === 0) {
-												self.delete(familyKey)
-											}
+					store.on.selectorDisposal.subscribe(
+						`introspection`,
+						(selectorToken) => {
+							setSelf((self) => {
+								if (selectorToken.family) {
+									const { key: familyKey, subKey } = selectorToken.family
+									const familyNode = self.get(familyKey)
+									if (familyNode && `familyMembers` in familyNode) {
+										familyNode.familyMembers.delete(subKey)
+										if (familyNode.familyMembers.size === 0) {
+											self.delete(familyKey)
 										}
-									} else {
-										self.delete(selectorToken.key)
 									}
-									return self
-								})
-							},
-						)
-					},
-				],
-			},
-			undefined,
-		)
-	return createStandaloneSelector(store, {
-		key: `🔍 Selector Token Index`,
-		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
-	})
+								} else {
+									self.delete(selectorToken.key)
+								}
+								return new Map(self)
+							})
+						},
+					)
+				},
+			],
+		},
+		undefined,
+	)
 }

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

@@ -1,16 +1,14 @@
-import type { ReadonlyPureSelectorToken, TimelineToken } from "atom.io"
+import type { AtomToken, TimelineToken } from "atom.io"
 import type { Store } from "atom.io/internal"
-import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
+import { createRegularAtom } from "atom.io/internal"
 
 export const attachTimelineIndex = (
 	store: Store,
-): ReadonlyPureSelectorToken<TimelineToken<any>[]> => {
-	const timelineTokenIndexState__INTERNAL = createRegularAtom<
-		TimelineToken<any>[]
-	>(
+): AtomToken<TimelineToken<any>[]> => {
+	return createRegularAtom<TimelineToken<any>[]>(
 		store,
 		{
-			key: `🔍 Timeline Token Index (Internal)`,
+			key: `🔍 Timeline Token Index`,
 			default: () =>
 				[...store.timelines].map(([key]): TimelineToken<any> => {
 					return { key, type: `timeline` }
@@ -28,9 +26,4 @@ export const attachTimelineIndex = (
 		},
 		undefined,
 	)
-	const timelineTokenIndex = createStandaloneSelector(store, {
-		key: `🔍 Timeline Token Index`,
-		get: ({ get }) => get(timelineTokenIndexState__INTERNAL),
-	})
-	return timelineTokenIndex
 }

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

@@ -1,25 +1,32 @@
-import type { ReadonlyPureSelectorToken, TransactionToken } from "atom.io"
+import type { AtomToken, TransactionToken } from "atom.io"
 import type { Func, Store } from "atom.io/internal"
-import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
+import { createRegularAtom, isReservedIntrospectionKey } from "atom.io/internal"
 
 export const attachTransactionIndex = (
 	store: Store,
-): ReadonlyPureSelectorToken<TransactionToken<Func>[]> => {
-	const transactionTokenIndexState__INTERNAL = createRegularAtom<
-		TransactionToken<Func>[]
-	>(
+): AtomToken<TransactionToken<Func>[]> => {
+	return createRegularAtom<TransactionToken<Func>[]>(
 		store,
 		{
-			key: `🔍 Transaction Token Index (Internal)`,
-			default: () =>
-				[...store.transactions].map(([key]): TransactionToken<Func> => {
-					return { key, type: `transaction` }
-				}),
+			key: `🔍 Transaction Token Index`,
+			default: () => {
+				const tokens: TransactionToken<Func>[] = []
+				for (const [key] of store.transactions) {
+					if (isReservedIntrospectionKey(key)) {
+						continue
+					}
+					tokens.push({ key, type: `transaction` })
+				}
+				return tokens
+			},
 			effects: [
 				({ setSelf }) => {
 					store.on.transactionCreation.subscribe(
 						`introspection`,
 						(transactionToken) => {
+							if (isReservedIntrospectionKey(transactionToken.key)) {
+								return
+							}
 							setSelf((state) => [...state, transactionToken])
 						},
 					)
@@ -28,9 +35,4 @@ export const attachTransactionIndex = (
 		},
 		undefined,
 	)
-	const transactionTokenIndex = createStandaloneSelector(store, {
-		key: `🔍 Transaction Token Index`,
-		get: ({ get }) => get(transactionTokenIndexState__INTERNAL),
-	})
-	return transactionTokenIndex
 }

package/src/introspection/auditor.ts

@@ -2,7 +2,6 @@ import {
 	type AtomToken,
 	getState,
 	type ReadableToken,
-	type ReadonlyPureSelectorToken,
 	type SelectorToken,
 } from "atom.io"
 import * as Internal from "atom.io/internal"
@@ -26,8 +25,8 @@ export class Auditor {
 	public readonly store: Internal.Store
 	public auditorCreatedAt: number = performance.now()
 	public statesCreatedAt: Map<string, number> = new Map()
-	public readonly atomIndex: ReadonlyPureSelectorToken<AtomTokenIndex>
-	public readonly selectorIndex: ReadonlyPureSelectorToken<SelectorTokenIndex>
+	public readonly atomIndex: AtomToken<AtomTokenIndex>
+	public readonly selectorIndex: AtomToken<SelectorTokenIndex>
 	public disposed = false
 
 	private readonly unsubscribeFromAtomCreation: () => void

package/src/react-devtools/Button.tsx

@@ -3,17 +3,25 @@ import type { FC } from "react"
 
 export const OpenClose: FC<{
 	isOpen: boolean
-	setIsOpen: (next: Modify<boolean> | boolean) => void
+	setIsOpen?: ((next: Modify<boolean> | boolean) => void) | undefined
+	onShiftClick?: (
+		event: React.MouseEvent<HTMLButtonElement, MouseEvent>,
+	) => boolean
 	disabled?: boolean
 	testid: string
-}> = ({ isOpen, setIsOpen, disabled, testid }) => {
+}> = ({ isOpen, setIsOpen, onShiftClick, disabled, testid }) => {
 	return (
 		<button
 			type="button"
 			data-testid={testid}
 			className={`carat ${isOpen ? `open` : `closed`}`}
-			onClick={() => {
-				setIsOpen((prev) => !prev)
+			onClick={(event) => {
+				if (onShiftClick && event.shiftKey) {
+					if (!onShiftClick(event)) {
+						return
+					}
+				}
+				setIsOpen?.((prev) => !prev)
 			}}
 			disabled={disabled}
 		>

package/src/react-devtools/StateEditor.tsx

@@ -9,8 +9,16 @@ export const StateEditor: FC<{
 }> = ({ token }) => {
 	const set = useI(token)
 	const data = useO(token)
+	const metaPath = token.family
+		? [token.family.key, token.family.subKey]
+		: [token.key]
 	return (
-		<JsonEditor testid={`${token.key}-state-editor`} data={data} set={set} />
+		<JsonEditor
+			testid={`${token.key}-state-editor`}
+			data={data}
+			set={set}
+			path={metaPath}
+		/>
 	)
 }
 
@@ -18,12 +26,16 @@ export const ReadonlySelectorViewer: FC<{
 	token: ReadonlySelectorToken<unknown>
 }> = ({ token }) => {
 	const data = useO(token)
+	const metaPath = token.family
+		? [token.family.key, token.family.subKey]
+		: [token.key]
 	return (
 		<JsonEditor
 			testid={`${token.key}-state-editor`}
 			data={data}
 			set={() => null}
 			isReadonly={() => true}
+			path={metaPath}
 		/>
 	)
 }