atom.io 0.6.4 → 0.6.6

package/src/internal/index.ts

@@ -2,7 +2,6 @@ export * from "./atom-internal"
 export * from "./families-internal"
 export * from "./get"
 export * from "./is-default"
-export * as META from "./meta"
 export * from "./operation"
 export * from "./selector-internal"
 export * from "./selector"

package/src/internal/operation.ts

@@ -42,6 +42,7 @@ export const closeOperation = (store: Store): void => {
 	const core = target(store)
 	core.operation = { open: false }
 	store.config.logger?.info(`🔴 operation done`)
+	store.subject.operationStatus.next(core.operation)
 }
 
 export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {

package/src/internal/store.ts

@@ -56,8 +56,9 @@ export interface Store {
 		selectorCreation: Subject<
 			ReadonlySelectorToken<unknown> | SelectorToken<unknown>
 		>
-		transactionCreation: Subject<TransactionToken<unknown>>
+		transactionCreation: Subject<TransactionToken<ƒn>>
 		timelineCreation: Subject<TimelineToken>
+		operationStatus: Subject<OperationProgress>
 	}
 
 	operation: OperationProgress
@@ -96,7 +97,7 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 			selectorCreation: new Subject(),
 			transactionCreation: new Subject(),
 			timelineCreation: new Subject(),
-			...store?.subject,
+			operationStatus: new Subject(),
 		},
 
 		operation: {

package/src/internal/time-travel-internal.ts

@@ -39,6 +39,7 @@ export const redo__INTERNAL = (
 		}
 	}
 	++timelineData.at
+	timelineData.subject.next(`redo`)
 	timelineData.timeTraveling = false
 	store.config.logger?.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
@@ -82,6 +83,7 @@ export const undo__INTERNAL = (
 			break
 		}
 	}
+	timelineData.subject.next(`undo`)
 	timelineData.timeTraveling = false
 	store.config.logger?.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,

package/src/internal/timeline/add-atom-to-timeline.ts

@@ -1,6 +1,5 @@
 import { IMPLICIT, withdraw } from ".."
 import type {
-	TimelineSelectorUpdate,
 	Timeline,
 	Store,
 	TimelineTransactionUpdate,
@@ -58,9 +57,6 @@ export const addAtomToTimeline = (
 						`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
 					)
 				}
-				if (mostRecentUpdate.type === `selector_update`) {
-					tl.subject.next(mostRecentUpdate)
-				}
 			}
 			if (
 				currentTransactionKey &&
@@ -83,6 +79,7 @@ export const addAtomToTimeline = (
 					}
 					tl.transactionKey = currentTransactionKey
 					const subscription = currentTransaction.subject.subscribe((update) => {
+						subscription.unsubscribe()
 						if (tl.timeTraveling === false && currentTransactionTime) {
 							if (tl.at !== tl.history.length) {
 								tl.history.splice(tl.at)
@@ -96,10 +93,9 @@ export const addAtomToTimeline = (
 								),
 							}
 							tl.history.push(timelineTransactionUpdate)
+							tl.at = tl.history.length
 							tl.subject.next(timelineTransactionUpdate)
 						}
-						tl.at = tl.history.length
-						subscription.unsubscribe()
 						tl.transactionKey = null
 						store.config.logger?.info(
 							`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
@@ -107,14 +103,16 @@ export const addAtomToTimeline = (
 					})
 				}
 			} else if (currentSelectorKey && currentSelectorTime) {
+				let latestUpdate: TimelineUpdate | undefined = tl.history.at(-1)
+
 				if (currentSelectorTime !== tl.selectorTime) {
-					const newSelectorUpdate: TimelineSelectorUpdate = {
+					latestUpdate = {
 						type: `selector_update`,
 						timestamp: currentSelectorTime,
 						key: currentSelectorKey,
 						atomUpdates: [],
 					}
-					newSelectorUpdate.atomUpdates.push({
+					latestUpdate.atomUpdates.push({
 						key: atom.key,
 						type: `atom_update`,
 						...update,
@@ -122,16 +120,16 @@ export const addAtomToTimeline = (
 					if (tl.at !== tl.history.length) {
 						tl.history.splice(tl.at)
 					}
-					tl.history.push(newSelectorUpdate)
+					tl.history.push(latestUpdate)
 
 					store.config.logger?.info(
 						`⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
-						newSelectorUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
+						latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
 					)
+
 					tl.at = tl.history.length
 					tl.selectorTime = currentSelectorTime
 				} else {
-					const latestUpdate = tl.history.at(-1)
 					if (latestUpdate?.type === `selector_update`) {
 						latestUpdate.atomUpdates.push({
 							key: atom.key,
@@ -144,6 +142,7 @@ export const addAtomToTimeline = (
 						)
 					}
 				}
+				if (latestUpdate) tl.subject.next(latestUpdate)
 			} else {
 				const timestamp = Date.now()
 				tl.selectorTime = null
@@ -160,7 +159,7 @@ export const addAtomToTimeline = (
 				tl.history.push(atomUpdate)
 				tl.subject.next(atomUpdate)
 				store.config.logger?.info(
-					`⌛ timeline "${tl.key}" got a state_update to "${atom.key}"`,
+					`⌛ timeline "${tl.key}" got an atom_update to "${atom.key}"`,
 				)
 				tl.at = tl.history.length
 			}

package/src/internal/timeline-internal.ts

@@ -39,7 +39,11 @@ export type Timeline = {
 	transactionKey: string | null
 	install: (store: Store) => void
 	subject: Subject<
-		TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate
+		| TimelineAtomUpdate
+		| TimelineSelectorUpdate
+		| TimelineTransactionUpdate
+		| `redo`
+		| `undo`
 	>
 }
 

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

@@ -0,0 +1,73 @@
+import type { AtomToken, ReadonlySelectorToken } from "atom.io"
+import { __INTERNAL__ } from "atom.io"
+
+import type { StateTokenIndex } from "."
+
+export type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>
+
+export const attachAtomIndex = (
+	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
+): ReadonlySelectorToken<AtomTokenIndex> => {
+	const atomTokenIndexState__INTERNAL =
+		__INTERNAL__.atom__INTERNAL<AtomTokenIndex>(
+			{
+				key: `👁‍🗨 Atom Token Index (Internal)`,
+				default: () =>
+					[...store.atoms]
+						.filter(([key]) => !key.includes(`👁‍🗨`))
+						.reduce<AtomTokenIndex>((acc, [key]) => {
+							acc[key] = { key, type: `atom` }
+							return acc
+						}, {}),
+				effects: [
+					({ setSelf }) => {
+						store.subject.atomCreation.subscribe((atomToken) => {
+							if (store.operation.open) {
+								return
+							}
+							if (atomToken.key.includes(`👁‍🗨`)) {
+								return
+							}
+							setSelf((state) => {
+								const { key, family } = atomToken
+								if (family) {
+									const { key: familyKey, subKey } = family
+									const current = state[familyKey]
+									if (current === undefined || `familyMembers` in current) {
+										const familyKeyState = current || {
+											key: familyKey,
+											familyMembers: {},
+										}
+										return {
+											...state,
+											[familyKey]: {
+												...familyKeyState,
+												familyMembers: {
+													...familyKeyState.familyMembers,
+													[subKey]: atomToken,
+												},
+											},
+										}
+									}
+								}
+								return {
+									...state,
+									[key]: atomToken,
+								}
+							})
+						})
+					},
+				],
+			},
+			undefined,
+			store,
+		)
+	return __INTERNAL__.selector__INTERNAL(
+		{
+			key: `👁‍🗨 Atom Token Index`,
+			get: ({ get }) => get(atomTokenIndexState__INTERNAL),
+		},
+		undefined,
+		store,
+	)
+}

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

@@ -0,0 +1,42 @@
+import { __INTERNAL__ } from "atom.io"
+import type {
+	ReadonlySelectorFamily,
+	ReadonlySelectorToken,
+	TimelineToken,
+	TimelineUpdate,
+	TransactionToken,
+	TransactionUpdate,
+} from "atom.io"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+
+import { attachAtomIndex, type AtomTokenIndex } from "./attach-atom-index"
+import {
+	attachSelectorIndex,
+	type SelectorTokenIndex,
+} from "./attach-selector-index"
+import { attachTimelineFamily } from "./attach-timeline-family"
+import { attachTimelineIndex } from "./attach-timeline-index"
+import { attachTransactionIndex } from "./attach-transaction-index"
+import { attachTransactionLogs } from "./attach-transaction-logs"
+import type { Timeline } from "../internal"
+
+export const attachIntrospectionStates = (
+	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
+): {
+	atomIndex: ReadonlySelectorToken<AtomTokenIndex>
+	selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>
+	transactionIndex: ReadonlySelectorToken<TransactionToken<ƒn>[]>
+	findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate<ƒn>[]>
+	timelineIndex: ReadonlySelectorToken<TimelineToken[]>
+	findTimelineState: ReadonlySelectorFamily<Timeline>
+} => {
+	return {
+		atomIndex: attachAtomIndex(store),
+		selectorIndex: attachSelectorIndex(store),
+		transactionIndex: attachTransactionIndex(store),
+		findTransactionLogState: attachTransactionLogs(store),
+		timelineIndex: attachTimelineIndex(store),
+		findTimelineState: attachTimelineFamily(store),
+	}
+}

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

@@ -0,0 +1,77 @@
+import { __INTERNAL__ } from "atom.io"
+import type { ReadonlySelectorToken, SelectorToken } from "atom.io"
+
+import type { StateTokenIndex } from "."
+
+export type SelectorTokenIndex = StateTokenIndex<
+	ReadonlySelectorToken<unknown> | SelectorToken<unknown>
+>
+
+export const attachSelectorIndex = (
+	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
+): ReadonlySelectorToken<SelectorTokenIndex> => {
+	const readonlySelectorTokenIndexState__INTERNAL =
+		__INTERNAL__.atom__INTERNAL<SelectorTokenIndex>(
+			{
+				key: `👁‍🗨 Selector Token Index (Internal)`,
+				default: () =>
+					Object.assign(
+						[...store.readonlySelectors]
+							.filter(([key]) => !key.includes(`👁‍🗨`))
+							.reduce<SelectorTokenIndex>((acc, [key]) => {
+								acc[key] = { key, type: `readonly_selector` }
+								return acc
+							}, {}),
+						[...store.selectors].reduce<SelectorTokenIndex>((acc, [key]) => {
+							acc[key] = { key, type: `selector` }
+							return acc
+						}, {}),
+					),
+				effects: [
+					({ setSelf }) => {
+						store.subject.selectorCreation.subscribe((selectorToken) => {
+							if (store.operation.open) {
+								return
+							}
+							if (selectorToken.key.includes(`👁‍🗨`)) {
+								return
+							}
+							setSelf((state) => {
+								const { key, family } = selectorToken
+								if (family) {
+									const { key: familyKey, subKey } = family
+									const current = state[familyKey]
+									if (current === undefined || `familyMembers` in current) {
+										const familyKeyState = current || {
+											key: familyKey,
+											familyMembers: {},
+										}
+										return {
+											...state,
+											[familyKey]: {
+												...familyKeyState,
+												familyMembers: {
+													...familyKeyState.familyMembers,
+													[subKey]: selectorToken,
+												},
+											},
+										}
+									}
+								}
+								return {
+									...state,
+									[key]: selectorToken,
+								}
+							})
+						})
+					},
+				],
+			},
+			undefined,
+			store,
+		)
+	return __INTERNAL__.selector__INTERNAL({
+		key: `👁‍🗨 Selector Token Index`,
+		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
+	})
+}

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

@@ -0,0 +1,49 @@
+import type { ReadonlySelectorFamily, Store } from "atom.io"
+import { __INTERNAL__ } from "atom.io"
+
+import type { Timeline } from "../internal"
+
+export const attachTimelineFamily = (
+	store: Store = __INTERNAL__.IMPLICIT.STORE,
+): ReadonlySelectorFamily<Timeline> => {
+	const findTimelineLogState__INTERNAL = __INTERNAL__.atomFamily__INTERNAL<
+		Timeline,
+		string
+	>(
+		{
+			key: `👁‍🗨 Timeline Update Log (Internal)`,
+			default: (key) => store.timelines.get(key),
+			effects: (key) => [
+				({ setSelf }) => {
+					const tl = store.timelines.get(key)
+					tl.subject.subscribe((_) => {
+						if (store.operation.open === true) {
+							const subscription = store.subject.operationStatus.subscribe(
+								(operationStatus) => {
+									if (operationStatus.open === false) {
+										subscription.unsubscribe()
+										setSelf({ ...tl })
+									}
+								},
+							)
+						} else {
+							setSelf({ ...tl })
+						}
+					})
+				},
+			],
+		},
+		store,
+	)
+	const findTimelineLogState = __INTERNAL__.selectorFamily__INTERNAL<
+		Timeline,
+		string
+	>(
+		{
+			key: `👁‍🗨 Timeline Update Log`,
+			get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL(key)),
+		},
+		store,
+	)
+	return findTimelineLogState
+}

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

@@ -0,0 +1,36 @@
+import type { ReadonlySelectorToken, Store, TimelineToken } from "atom.io"
+import { __INTERNAL__ } from "atom.io"
+
+export const attachTimelineIndex = (
+	store: Store = __INTERNAL__.IMPLICIT.STORE,
+): ReadonlySelectorToken<TimelineToken[]> => {
+	const timelineTokenIndexState__INTERNAL = __INTERNAL__.atom__INTERNAL<
+		TimelineToken[]
+	>(
+		{
+			key: `👁‍🗨 Timeline Token Index (Internal)`,
+			default: () =>
+				[...store.timelines].map(([key]) => {
+					return { key, type: `timeline` }
+				}),
+			effects: [
+				({ setSelf }) => {
+					store.subject.timelineCreation.subscribe((timelineToken) => {
+						setSelf((state) => [...state, timelineToken])
+					})
+				},
+			],
+		},
+		undefined,
+		store,
+	)
+	const timelineTokenIndex = __INTERNAL__.selector__INTERNAL(
+		{
+			key: `👁‍🗨 Timeline Token Index`,
+			get: ({ get }) => get(timelineTokenIndexState__INTERNAL),
+		},
+		undefined,
+		store,
+	)
+	return timelineTokenIndex
+}

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

@@ -0,0 +1,38 @@
+import type { ReadonlySelectorToken, TransactionToken } from "atom.io"
+import { __INTERNAL__ } from "atom.io"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+
+export const attachTransactionIndex = (
+	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
+): ReadonlySelectorToken<TransactionToken<ƒn>[]> => {
+	const transactionTokenIndexState__INTERNAL = __INTERNAL__.atom__INTERNAL<
+		TransactionToken<ƒn>[]
+	>(
+		{
+			key: `👁‍🗨 Transaction Token Index (Internal)`,
+			default: () =>
+				[...store.transactions].map(([key]) => {
+					return { key, type: `transaction` }
+				}),
+			effects: [
+				({ setSelf }) => {
+					store.subject.transactionCreation.subscribe((transactionToken) => {
+						setSelf((state) => [...state, transactionToken])
+					})
+				},
+			],
+		},
+		undefined,
+		store,
+	)
+	const transactionTokenIndex = __INTERNAL__.selector__INTERNAL(
+		{
+			key: `👁‍🗨 Transaction Token Index`,
+			get: ({ get }) => get(transactionTokenIndexState__INTERNAL),
+		},
+		undefined,
+		store,
+	)
+	return transactionTokenIndex
+}

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

@@ -0,0 +1,40 @@
+import type { ReadonlySelectorFamily, TransactionUpdate } from "atom.io"
+import { __INTERNAL__ } from "atom.io"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+
+export const attachTransactionLogs = (
+	store: __INTERNAL__.Store = __INTERNAL__.IMPLICIT.STORE,
+): ReadonlySelectorFamily<TransactionUpdate<ƒn>[]> => {
+	const findTransactionUpdateLog = __INTERNAL__.atomFamily__INTERNAL<
+		TransactionUpdate<ƒn>[],
+		string
+	>(
+		{
+			key: `👁‍🗨 Transaction Update Log (Internal)`,
+			default: () => [],
+			effects: (key) => [
+				({ setSelf }) => {
+					const tx = store.transactions.get(key)
+					tx.subject.subscribe((transactionUpdate) => {
+						if (transactionUpdate.key === key) {
+							setSelf((state) => [...state, transactionUpdate])
+						}
+					})
+				},
+			],
+		},
+		store,
+	)
+	const findTransactionUpdateLogState = __INTERNAL__.selectorFamily__INTERNAL<
+		TransactionUpdate<ƒn>[],
+		string
+	>(
+		{
+			key: `👁‍🗨 Transaction Update Log`,
+			get: (key) => ({ get }) => get(findTransactionUpdateLog(key)),
+		},
+		store,
+	)
+	return findTransactionUpdateLogState
+}

package/src/introspection/index.ts

@@ -0,0 +1,20 @@
+import type { AtomToken, ReadonlySelectorToken, SelectorToken } from "atom.io"
+
+export * from "./attach-introspection-states"
+
+export type FamilyNode<
+	Token extends
+		| AtomToken<unknown>
+		| ReadonlySelectorToken<unknown>
+		| SelectorToken<unknown>,
+> = {
+	key: string
+	familyMembers: Record<string, Token>
+}
+
+export type StateTokenIndex<
+	Token extends
+		| AtomToken<unknown>
+		| ReadonlySelectorToken<unknown>
+		| SelectorToken<unknown>,
+> = Record<string, FamilyNode<Token> | Token>