atom.io 0.6.7 → 0.6.9

package/src/internal/timeline-internal.ts

@@ -1,107 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from "."
-import { Subject, target, IMPLICIT } from "."
-import { addAtomToTimeline } from "./timeline/add-atom-to-timeline"
-import type {
-	StateUpdate,
-	TimelineOptions,
-	TimelineToken,
-	TimelineUpdate,
-	TransactionUpdate,
-} from ".."
-
-export type TimelineAtomUpdate = StateUpdate<unknown> & {
-	key: string
-	type: `atom_update`
-	timestamp: number
-}
-export type TimelineSelectorUpdate = {
-	key: string
-	type: `selector_update`
-	timestamp: number
-	atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[]
-}
-export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
-	key: string
-	type: `transaction_update`
-	timestamp: number
-}
-
-export type Timeline = {
-	key: string
-	at: number
-	timeTraveling: boolean
-	history: TimelineUpdate[]
-	selectorTime: number | null
-	transactionKey: string | null
-	install: (store: Store) => void
-	subject: Subject<
-		| TimelineAtomUpdate
-		| TimelineSelectorUpdate
-		| TimelineTransactionUpdate
-		| `redo`
-		| `undo`
-	>
-}
-
-export function timeline__INTERNAL(
-	options: TimelineOptions,
-	store: Store = IMPLICIT.STORE,
-	data: Timeline | null = null,
-): TimelineToken {
-	const tl: Timeline = {
-		key: options.key,
-		at: 0,
-		timeTraveling: false,
-		selectorTime: null,
-		transactionKey: null,
-		...data,
-		history: data?.history.map((update) => ({ ...update })) ?? [],
-		install: (store) => timeline__INTERNAL(options, store, tl),
-		subject: new Subject(),
-	}
-
-	const core = target(store)
-	for (const tokenOrFamily of options.atoms) {
-		const timelineKey = core.timelineAtoms.getRelatedId(tokenOrFamily.key)
-		if (timelineKey) {
-			store.config.logger?.error(
-				`❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`,
-			)
-			continue
-		}
-		if (tokenOrFamily.type === `atom_family`) {
-			const family = tokenOrFamily
-			family.subject.subscribe((token) =>
-				addAtomToTimeline(token, options.atoms, tl, store),
-			)
-		} else {
-			const token = tokenOrFamily
-			if (`family` in token && token.family) {
-				const familyTimelineKey = core.timelineAtoms.getRelatedId(
-					token.family.key,
-				)
-				if (familyTimelineKey) {
-					store.config.logger?.error(
-						`❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`,
-					)
-					continue
-				}
-			}
-			addAtomToTimeline(token, options.atoms, tl, store)
-		}
-		core.timelineAtoms = core.timelineAtoms.set({
-			atomKey: tokenOrFamily.key,
-			timelineKey: options.key,
-		})
-	}
-
-	store.timelines.set(options.key, tl)
-	const token: TimelineToken = {
-		key: options.key,
-		type: `timeline`,
-	}
-	store.subject.timelineCreation.next(token)
-	return token
-}

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

@@ -1,12 +0,0 @@
-import type { Store } from ".."
-
-export const abortTransaction = (store: Store): void => {
-	if (store.transactionStatus.phase === `idle`) {
-		store.config.logger?.warn(
-			`abortTransaction called outside of a transaction. This is probably a bug.`,
-		)
-		return
-	}
-	store.transactionStatus = { phase: `idle` }
-	store.config.logger?.info(`🪂`, `transaction fail`)
-}

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

@@ -1,57 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken } from "../.."
-import { setState } from "../.."
-
-export const applyTransaction = <ƒ extends ƒn>(
-	output: ReturnType<ƒ>,
-	store: Store,
-): void => {
-	if (store.transactionStatus.phase !== `building`) {
-		store.config.logger?.warn(
-			`abortTransaction called outside of a transaction. This is probably a bug.`,
-		)
-		return
-	}
-	store.config.logger?.info(
-		`🛃 apply transaction "${store.transactionStatus.key}"`,
-	)
-	store.transactionStatus.phase = `applying`
-	store.transactionStatus.output = output
-	const { atomUpdates } = store.transactionStatus
-
-	for (const { key, newValue } of atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		if (!store.valueMap.has(token.key)) {
-			const newAtom = store.transactionStatus.core.atoms.get(token.key)
-			if (!newAtom) {
-				throw new Error(
-					`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`,
-				)
-			}
-			store.atoms.set(newAtom.key, newAtom)
-			store.valueMap.set(newAtom.key, newAtom.default)
-			store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
-		}
-		setState(token, newValue, store)
-	}
-	const myTransaction = withdraw<ƒ>(
-		{ key: store.transactionStatus.key, type: `transaction` },
-		store,
-	)
-	if (myTransaction === null) {
-		throw new Error(
-			`Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`,
-		)
-	}
-	myTransaction.subject.next({
-		key: store.transactionStatus.key,
-		atomUpdates,
-		output,
-		params: store.transactionStatus.params as Parameters<ƒ>,
-	})
-	store.transactionStatus = { phase: `idle` }
-	store.config.logger?.info(`🛬`, `transaction done`)
-}

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

@@ -1,33 +0,0 @@
-import type { Store } from ".."
-
-export const buildTransaction = (
-	key: string,
-	params: any[],
-	store: Store,
-): void => {
-	store.transactionStatus = {
-		key,
-		phase: `building`,
-		time: Date.now(),
-		core: {
-			atoms: new Map(store.atoms),
-			atomsThatAreDefault: store.atomsThatAreDefault,
-			operation: { open: false },
-			readonlySelectors: new Map(store.readonlySelectors),
-			timelines: new Map(store.timelines),
-			timelineAtoms: store.timelineAtoms,
-			transactions: new Map(store.transactions),
-			selectorAtoms: store.selectorAtoms,
-			selectorGraph: store.selectorGraph,
-			selectors: new Map(store.selectors),
-			valueMap: new Map(store.valueMap),
-		},
-		atomUpdates: [],
-		params,
-		output: undefined,
-	}
-	store.config.logger?.info(
-		`🛫`,
-		`transaction "${key}" started in store "${store.config.name}"`,
-	)
-}

package/src/internal/transaction/index.ts

@@ -1,25 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { StoreCore } from ".."
-import type { StateUpdate, TransactionUpdate } from "../.."
-
-export * from "./abort-transaction"
-export * from "./apply-transaction"
-export * from "./build-transaction"
-export * from "./redo-transaction"
-export * from "./undo-transaction"
-
-export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
-export type TransactionPhase = typeof TRANSACTION_PHASES[number]
-
-export type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
-	phase: `applying` | `building`
-	time: number
-	core: StoreCore
-}
-export type TransactionIdle = {
-	phase: `idle`
-}
-export type TransactionStatus<ƒ extends ƒn> =
-	| TransactionIdle
-	| TransactionUpdateInProgress<ƒ>

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

@@ -1,23 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken, TransactionUpdate } from "../.."
-import { setState } from "../.."
-
-export const redoTransactionUpdate = <ƒ extends ƒn>(
-	update: TransactionUpdate<ƒ>,
-	store: Store,
-): void => {
-	store.config.logger?.info(` ⏭ redo transaction "${update.key}" (redo)`)
-	for (const { key, newValue } of update.atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		const state = withdraw(token, store)
-		if (state === null) {
-			throw new Error(
-				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
-			)
-		}
-		setState(state, newValue, store)
-	}
-}

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

@@ -1,23 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken, TransactionUpdate } from "../.."
-import { setState } from "../.."
-
-export const undoTransactionUpdate = <ƒ extends ƒn>(
-	update: TransactionUpdate<ƒ>,
-	store: Store,
-): void => {
-	store.config.logger?.info(` ⏮ undo transaction "${update.key}" (undo)`)
-	for (const { key, oldValue } of update.atomUpdates) {
-		const token: AtomToken<unknown> = { key, type: `atom` }
-		const state = withdraw(token, store)
-		if (state === null) {
-			throw new Error(
-				`State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`,
-			)
-		}
-		setState(state, oldValue, store)
-	}
-}

package/src/internal/transaction-internal.ts

@@ -1,61 +0,0 @@
-import type { ƒn } from "~/packages/anvl/src/function"
-
-import type { Store, StoreCore } from "."
-import {
-	Subject,
-	abortTransaction,
-	applyTransaction,
-	buildTransaction,
-	deposit,
-	IMPLICIT,
-} from "."
-import type { TransactionOptions, TransactionToken, TransactionUpdate } from ".."
-import { getState, setState } from ".."
-
-export type Transaction<ƒ extends ƒn> = {
-	key: string
-	type: `transaction`
-	install: (store: Store) => void
-	subject: Subject<TransactionUpdate<ƒ>>
-	run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
-}
-
-export function transaction__INTERNAL<ƒ extends ƒn>(
-	options: TransactionOptions<ƒ>,
-	store: Store = IMPLICIT.STORE,
-): TransactionToken<ƒ> {
-	const newTransaction: Transaction<ƒ> = {
-		key: options.key,
-		type: `transaction`,
-		run: (...params: Parameters<ƒ>) => {
-			buildTransaction(options.key, params, store)
-			try {
-				const output = options.do(
-					{
-						get: (token) => getState(token, store),
-						set: (token, value) => setState(token, value, store),
-					},
-					...params,
-				)
-				applyTransaction(output, store)
-				return output
-			} catch (thrown) {
-				abortTransaction(store)
-				store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
-				throw thrown
-			}
-		},
-		install: (store) => transaction__INTERNAL(options, store),
-		subject: new Subject(),
-	}
-	const core = target(store)
-	core.transactions.set(newTransaction.key, newTransaction)
-	const token = deposit(newTransaction)
-	store.subject.transactionCreation.next(token)
-	return token
-}
-
-export const target = (store: Store = IMPLICIT.STORE): StoreCore =>
-	store.transactionStatus.phase === `building`
-		? store.transactionStatus.core
-		: store

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

@@ -1,73 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,59 +0,0 @@
-import type { ReadonlySelectorFamily, Store } from "atom.io"
-import { __INTERNAL__, timeline } from "atom.io"
-
-import { withdraw, type Timeline, Subject } 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) ?? {
-					key: ``,
-					at: 0,
-					timeTraveling: false,
-					history: [],
-					selectorTime: null,
-					transactionKey: null,
-					install: () => {},
-					subject: new Subject(),
-				},
-			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

@@ -1,36 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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
-}