atom.io 0.6.9 → 0.7.0

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

@@ -0,0 +1,91 @@
+import type { TimelineToken } from "atom.io"
+import { setState } from "atom.io"
+
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+
+export const redo__INTERNAL = (
+	token: TimelineToken,
+	store: Store = IMPLICIT.STORE,
+): void => {
+	store.config.logger?.info(`⏩ redo "${token.key}"`)
+	const timelineData = store.timelines.get(token.key)
+	if (!timelineData) {
+		store.config.logger?.error(
+			`Failed to redo on timeline "${token.key}". This timeline has not been initialized.`,
+		)
+		return
+	}
+	if (timelineData.at === timelineData.history.length) {
+		store.config.logger?.warn(
+			`Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`,
+		)
+		return
+	}
+	timelineData.timeTraveling = `into_future`
+	const update = timelineData.history[timelineData.at]
+	switch (update.type) {
+		case `atom_update`: {
+			const { key, newValue } = update
+			setState({ key, type: `atom` }, newValue, store)
+			break
+		}
+		case `selector_update`:
+		case `transaction_update`: {
+			for (const atomUpdate of update.atomUpdates) {
+				const { key, newValue } = atomUpdate
+				setState({ key, type: `atom` }, newValue, store)
+			}
+			break
+		}
+	}
+	++timelineData.at
+	timelineData.subject.next(`redo`)
+	timelineData.timeTraveling = null
+	store.config.logger?.info(
+		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
+	)
+}
+
+export const undo__INTERNAL = (
+	token: TimelineToken,
+	store: Store = IMPLICIT.STORE,
+): void => {
+	store.config.logger?.info(`⏪ undo "${token.key}"`)
+	const timelineData = store.timelines.get(token.key)
+	if (!timelineData) {
+		store.config.logger?.error(
+			`Failed to undo on timeline "${token.key}". This timeline has not been initialized.`,
+		)
+		return
+	}
+	if (timelineData.at === 0) {
+		store.config.logger?.warn(
+			`Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`,
+		)
+		return
+	}
+	timelineData.timeTraveling = `into_past`
+	--timelineData.at
+	const update = timelineData.history[timelineData.at]
+	switch (update.type) {
+		case `atom_update`: {
+			const { key, oldValue } = update
+			setState({ key, type: `atom` }, oldValue, store)
+			break
+		}
+		case `selector_update`:
+		case `transaction_update`: {
+			for (const atomUpdate of [...update.atomUpdates].reverse()) {
+				const { key, oldValue } = atomUpdate
+				setState({ key, type: `atom` }, oldValue, store)
+			}
+			break
+		}
+	}
+	timelineData.subject.next(`undo`)
+	timelineData.timeTraveling = null
+	store.config.logger?.info(
+		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
+	)
+}

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

@@ -0,0 +1,115 @@
+import type {
+	FamilyMetadata,
+	StateUpdate,
+	TimelineOptions,
+	TimelineToken,
+	TimelineUpdate,
+	TransactionUpdate,
+	ƒn,
+} from "atom.io"
+
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
+import { Subject } from "../subject"
+import { target } from "../transaction"
+import { addAtomToTimeline } from "./add-atom-to-timeline"
+
+export type TimelineAtomUpdate = StateUpdate<unknown> & {
+	key: string
+	type: `atom_update`
+	timestamp: number
+	family?: FamilyMetadata
+}
+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 = {
+	type: `timeline`
+	key: string
+	at: number
+	timeTraveling: `into_future` | `into_past` | null
+	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 = {
+		type: `timeline`,
+		key: options.key,
+		at: 0,
+		timeTraveling: null,
+		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.getRelatedKey(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(`timeline:${options.key}`, (token) => {
+				if (!core.atoms.has(token.key)) {
+					addAtomToTimeline(token, tl, store)
+				}
+			})
+		} else {
+			const token = tokenOrFamily
+			if (`family` in token && token.family) {
+				const familyTimelineKey = core.timelineAtoms.getRelatedKey(
+					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, 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/internal/src/transaction/abort-transaction.ts

@@ -0,0 +1,12 @@
+import type { Store } from "../store"
+
+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/internal/src/transaction/apply-transaction.ts

@@ -0,0 +1,64 @@
+import type { AtomToken, ƒn } from "atom.io"
+import { setState, transaction } from "atom.io"
+
+import { withdraw } from "../store"
+import type { Store } from "../store"
+
+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.transactionStatus.phase = `applying`
+	store.transactionStatus.output = output
+	const { atomUpdates } = store.transactionStatus
+	store.config.logger?.info(
+		`🛃 applying transaction "${store.transactionStatus.key}" with ${atomUpdates.length} updates.`,
+	)
+	store.config.logger?.info(`🛃 the updates are:`, atomUpdates)
+	for (const { key, newValue } of atomUpdates) {
+		const token: AtomToken<unknown> = { key, type: `atom` }
+		if (!store.valueMap.has(token.key)) {
+			if (token.family) {
+				const family = store.families.get(token.family.key)
+				if (family) {
+					family(token.family.subKey)
+				}
+			} else {
+				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}"`)
+			}
+		}
+		// if (store.transactionStatus.key === `dealCards`) debugger
+		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 "${myTransaction.key}" applied`)
+}

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

@@ -0,0 +1,39 @@
+import { Junction } from "~/packages/rel8/junction/src"
+
+import type { Store } from "../store"
+
+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: new Set(store.atomsThatAreDefault),
+			families: new Map(store.families),
+			operation: { open: false },
+			readonlySelectors: new Map(store.readonlySelectors),
+			timelines: new Map(store.timelines),
+			timelineAtoms: new Junction(store.timelineAtoms.toJSON()),
+			trackers: new Map(),
+			transactions: new Map(store.transactions),
+			selectorAtoms: new Junction(store.selectorAtoms.toJSON()),
+			selectorGraph: new Junction(store.selectorGraph.toJSON(), {
+				makeContentKey: (...keys) => keys.sort().join(`:`),
+			}),
+			selectors: new Map(store.selectors),
+			valueMap: new Map(store.valueMap),
+		},
+		atomUpdates: [],
+		params,
+		output: undefined,
+	}
+	store.config.logger?.info(
+		`🛫`,
+		`transaction "${key}" building in store "${store.config.name}"`,
+	)
+}

package/internal/src/transaction/index.ts

@@ -0,0 +1,26 @@
+import type { TransactionUpdate, ƒn } from "atom.io"
+
+import type { StoreCore } from ".."
+
+export * from "./transaction-internal"
+
+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/internal/src/transaction/redo-transaction.ts

@@ -0,0 +1,22 @@
+import type { AtomToken, TransactionUpdate, ƒn } from "atom.io"
+import { setState } from "atom.io"
+
+import { withdraw } from "../store"
+import type { Store } from "../store"
+
+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/internal/src/transaction/transaction-internal.ts

@@ -0,0 +1,64 @@
+import type {
+	TransactionOptions,
+	TransactionToken,
+	TransactionUpdate,
+	ƒn,
+} from "atom.io"
+import { getState, setState } from "atom.io"
+
+import { IMPLICIT, type Store, type StoreCore, deposit } from "../store"
+import { Subject } from "../subject"
+import { abortTransaction } from "./abort-transaction"
+import { applyTransaction } from "./apply-transaction"
+import { buildTransaction } from "./build-transaction"
+
+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 in store "${store.config.name}":`,
+					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/internal/src/transaction/undo-transaction.ts

@@ -0,0 +1,22 @@
+import type { AtomToken, TransactionUpdate, ƒn } from "atom.io"
+import { setState } from "atom.io"
+
+import { withdraw } from "../store"
+import type { Store } from "../store"
+
+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/introspection/dist/index.d.mts

@@ -1,200 +1,6 @@
-import { StateToken, FamilyMetadata, TimelineUpdate, StateUpdate, TransactionUpdate, ƒn, AtomToken, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, Logger, __INTERNAL__, ReadonlySelectorFamily } from 'atom.io';
-
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
-    readonly relations: [string, string[]][];
-    readonly contents: [string, Content][];
-}
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
-    readonly between: [a: ASide, b: BSide];
-    readonly cardinality: Cardinality;
-}
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
-    externalStore?: (Content extends null ? {
-        getContent?: undefined;
-        setContent?: undefined;
-        deleteContent?: undefined;
-    } : {
-        getContent: (contentKey: string) => Content | undefined;
-        setContent: (contentKey: string, content: Content) => void;
-        deleteContent: (g: any) => void;
-    }) & {
-        addRelation: (a: string, b: string) => void;
-        deleteRelation: (a: string, b: string) => void;
-        getRelatedKeys: (key: string) => Set<string> | undefined;
-        has: (a: string, b?: string) => boolean;
-    };
-    isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: string, b: string) => string;
-};
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<ASide extends string, BSide extends string, Content extends Object$1 | null = null> {
-    readonly a: ASide;
-    readonly b: BSide;
-    readonly cardinality: Cardinality;
-    readonly relations: Map<string, Set<string>>;
-    readonly contents: Map<string, Content>;
-    isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: string, b: string) => string;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    protected addRelation(a: string, b: string): void;
-    protected deleteRelation(a: string, b: string): void;
-    protected getContentInternal(contentKey: string): Content | undefined;
-    protected setContent(contentKey: string, content: Content): void;
-    protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
-    toJSON(): JunctionJSON<ASide, BSide, Content>;
-    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
-    set(relation: {
-        [Key in ASide | BSide]: string;
-    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
-    delete(a: string, b?: string): this;
-    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
-    getRelatedKey(key: string): string | undefined;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
-}
-
-type OperationProgress = {
-    open: false;
-} | {
-    open: true;
-    done: Set<string>;
-    prev: Map<string, any>;
-    time: number;
-    token: StateToken<any>;
-};
-
-type Subscriber<T> = (value: T) => void;
-declare class Subject<T> {
-    subscribers: Map<string, Subscriber<T>>;
-    subscribe(key: string, subscriber: Subscriber<T>): () => void;
-    private unsubscribe;
-    next(value: T): void;
-}
-
-type Selector<T> = {
-    key: string;
-    type: `selector`;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-    set: (newValue: T | ((oldValue: T) => T)) => void;
-};
-type ReadonlySelector<T> = {
-    key: string;
-    type: `readonly_selector`;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-};
-
-type TimelineAtomUpdate = StateUpdate<unknown> & {
-    key: string;
-    type: `atom_update`;
-    timestamp: number;
-    family?: FamilyMetadata;
-};
-type TimelineSelectorUpdate = {
-    key: string;
-    type: `selector_update`;
-    timestamp: number;
-    atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
-};
-type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
-    key: string;
-    type: `transaction_update`;
-    timestamp: number;
-};
-type Timeline = {
-    type: `timeline`;
-    key: string;
-    at: number;
-    timeTraveling: `into_future` | `into_past` | null;
-    history: TimelineUpdate[];
-    selectorTime: number | null;
-    transactionKey: string | null;
-    install: (store: Store) => void;
-    subject: Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate | `redo` | `undo`>;
-};
-
-type Transaction<ƒ extends ƒn> = {
-    key: string;
-    type: `transaction`;
-    install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<ƒ>>;
-    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-};
-
-type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
-    phase: `applying` | `building`;
-    time: number;
-    core: StoreCore;
-};
-type TransactionIdle = {
-    phase: `idle`;
-};
-type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
-
-type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
-declare class Store {
-    valueMap: Map<string, any>;
-    atoms: Map<string, Atom<any>>;
-    selectors: Map<string, Selector<any>>;
-    readonlySelectors: Map<string, ReadonlySelector<any>>;
-    timelines: Map<string, Timeline>;
-    transactions: Map<string, Transaction<ƒn>>;
-    atomsThatAreDefault: Set<string>;
-    timelineAtoms: Junction<"timelineKey", "atomKey", null>;
-    selectorAtoms: Junction<"selectorKey", "atomKey", null>;
-    selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
-        source: string;
-    }>;
-    subject: {
-        atomCreation: Subject<AtomToken<unknown>>;
-        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<ƒn>>;
-        timelineCreation: Subject<TimelineToken>;
-        operationStatus: Subject<OperationProgress>;
-    };
-    operation: OperationProgress;
-    transactionStatus: TransactionStatus<ƒn>;
-    config: {
-        name: string;
-        logger: Logger | null;
-        logger__INTERNAL: Logger;
-    };
-    constructor(name: string, store?: Store | null);
-}
-
-type Atom<T> = {
-    key: string;
-    type: `atom`;
-    family?: FamilyMetadata;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    default: T;
-};
+import { AtomToken, ReadonlySelectorToken, SelectorToken, TransactionToken, ƒn, ReadonlySelectorFamily, TransactionUpdate, TimelineToken } from 'atom.io';
+import * as __INTERNAL__ from 'atom.io/internal';
+import { Timeline } from 'atom.io/internal';
 
 type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>;