atom.io 0.6.8 → 0.7.0

package/{src/internal → internal/src}/transaction/apply-transaction.ts

@@ -1,9 +1,8 @@
-import type { ƒn } from "~/packages/anvl/src/function"
+import type { AtomToken, ƒn } from "atom.io"
+import { setState, transaction } from "atom.io"
 
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken } from "../.."
-import { setState } from "../.."
+import { withdraw } from "../store"
+import type { Store } from "../store"
 
 export const applyTransaction = <ƒ extends ƒn>(
 	output: ReturnType<ƒ>,
@@ -15,26 +14,34 @@ export const applyTransaction = <ƒ extends ƒn>(
 		)
 		return
 	}
-	store.config.logger?.info(
-		`🛃 apply transaction "${store.transactionStatus.key}"`,
-	)
 	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)) {
-			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}"`,
-				)
+			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}"`)
 			}
-			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<ƒ>(
@@ -53,5 +60,5 @@ export const applyTransaction = <ƒ extends ƒn>(
 		params: store.transactionStatus.params as Parameters<ƒ>,
 	})
 	store.transactionStatus = { phase: `idle` }
-	store.config.logger?.info(`🛬`, `transaction done`)
+	store.config.logger?.info(`🛬`, `transaction "${myTransaction.key}" applied`)
 }

package/{src/internal → internal/src}/transaction/build-transaction.ts

@@ -1,4 +1,6 @@
-import type { Store } from ".."
+import { Junction } from "~/packages/rel8/junction/src"
+
+import type { Store } from "../store"
 
 export const buildTransaction = (
 	key: string,
@@ -11,14 +13,18 @@ export const buildTransaction = (
 		time: Date.now(),
 		core: {
 			atoms: new Map(store.atoms),
-			atomsThatAreDefault: store.atomsThatAreDefault,
+			atomsThatAreDefault: new Set(store.atomsThatAreDefault),
+			families: new Map(store.families),
 			operation: { open: false },
 			readonlySelectors: new Map(store.readonlySelectors),
 			timelines: new Map(store.timelines),
-			timelineAtoms: store.timelineAtoms,
+			timelineAtoms: new Junction(store.timelineAtoms.toJSON()),
+			trackers: new Map(),
 			transactions: new Map(store.transactions),
-			selectorAtoms: store.selectorAtoms,
-			selectorGraph: store.selectorGraph,
+			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),
 		},
@@ -28,6 +34,6 @@ export const buildTransaction = (
 	}
 	store.config.logger?.info(
 		`🛫`,
-		`transaction "${key}" started in store "${store.config.name}"`,
+		`transaction "${key}" building in store "${store.config.name}"`,
 	)
 }

package/{src/internal → internal/src}/transaction/index.ts

@@ -1,7 +1,8 @@
-import type { ƒn } from "~/packages/anvl/src/function"
+import type { TransactionUpdate, ƒn } from "atom.io"
 
 import type { StoreCore } from ".."
-import type { StateUpdate, TransactionUpdate } from "../.."
+
+export * from "./transaction-internal"
 
 export * from "./abort-transaction"
 export * from "./apply-transaction"

package/{src/internal → internal/src}/transaction/redo-transaction.ts

@@ -1,9 +1,8 @@
-import type { ƒn } from "~/packages/anvl/src/function"
+import type { AtomToken, TransactionUpdate, ƒn } from "atom.io"
+import { setState } from "atom.io"
 
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken, TransactionUpdate } from "../.."
-import { setState } from "../.."
+import { withdraw } from "../store"
+import type { Store } from "../store"
 
 export const redoTransactionUpdate = <ƒ extends ƒn>(
 	update: TransactionUpdate<ƒ>,

package/{src/internal → internal/src/transaction}/transaction-internal.ts

@@ -1,16 +1,16 @@
-import type { ƒn } from "~/packages/anvl/src/function"
+import type {
+	TransactionOptions,
+	TransactionToken,
+	TransactionUpdate,
+	ƒn,
+} from "atom.io"
+import { getState, setState } from "atom.io"
 
-import type { Store, StoreCore } from "."
-import {
-	Subject,
-	abortTransaction,
-	applyTransaction,
-	buildTransaction,
-	deposit,
-	IMPLICIT,
-} from "."
-import type { TransactionOptions, TransactionToken, TransactionUpdate } from ".."
-import { getState, setState } from ".."
+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
@@ -41,7 +41,10 @@ export function transaction__INTERNAL<ƒ extends ƒn>(
 				return output
 			} catch (thrown) {
 				abortTransaction(store)
-				store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
+				store.config.logger?.error(
+					`Transaction "${options.key}" failed in store "${store.config.name}":`,
+					thrown,
+				)
 				throw thrown
 			}
 		},

package/{src/internal → internal/src}/transaction/undo-transaction.ts

@@ -1,9 +1,8 @@
-import type { ƒn } from "~/packages/anvl/src/function"
+import type { AtomToken, TransactionUpdate, ƒn } from "atom.io"
+import { setState } from "atom.io"
 
-import type { Store } from ".."
-import { withdraw } from ".."
-import type { AtomToken, TransactionUpdate } from "../.."
-import { setState } from "../.."
+import { withdraw } from "../store"
+import type { Store } from "../store"
 
 export const undoTransactionUpdate = <ƒ extends ƒn>(
 	update: TransactionUpdate<ƒ>,

package/introspection/dist/index.d.mts

@@ -1,272 +1,24 @@
-import { AtomToken as AtomToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, SelectorToken as SelectorToken$1, __INTERNAL__, TransactionToken as TransactionToken$1, ReadonlySelectorFamily, TransactionUpdate as TransactionUpdate$1, TimelineToken as TimelineToken$1 } from 'atom.io';
-import { Refinement } from 'fp-ts/Refinement';
+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 ƒn = (...parameters: any[]) => any;
+type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>;
 
-type AtomTokenIndex = StateTokenIndex<AtomToken$1<unknown>>;
-
-type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>>;
-
-type JsonInterface<T, J extends Serializable = Serializable> = {
-    toJson: (t: T) => J;
-    fromJson: (json: J) => T;
-};
-
-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 Identified = {
-    id: string;
-};
-
-declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
-type RelationType = typeof RELATION_TYPES[number];
-type RelationData<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
-    contents: Object$1<string, CONTENT>;
-    relations: Object$1<string, string[]>;
-    relationType: RelationType;
-    a: A;
-    b: B;
-};
-type IsRelationDataOptions<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
-    from?: A;
-    to?: B;
-    isContent?: (json: Serializable) => json is CONTENT;
-};
-
-type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
-type NullSafeRest<MaybeArg, IfArg = MaybeArg> = MaybeArg extends null ? [] | [undefined] : [IfArg];
-
-declare class Join<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> implements RelationData<CONTENT, A, B> {
-    readonly relationType: `1:1` | `1:n` | `n:n`;
-    readonly a: A;
-    readonly b: B;
-    readonly relations: Record<string, string[]>;
-    readonly contents: Record<string, CONTENT>;
-    constructor(json?: Partial<RelationData<CONTENT, A, B>>);
-    toJSON(): RelationData<CONTENT, A, B>;
-    static fromJSON<CONTENT extends Object$1 | null, A extends string, B extends string>(json: Serializable, options?: IsRelationDataOptions<CONTENT, A, B>): Join<CONTENT, A, B>;
-    from<AA extends string>(newA: AA): Join<CONTENT, AA, B>;
-    to<BB extends string>(newB: BB): Join<CONTENT, A, BB>;
-    makeJsonInterface: (...params: CONTENT extends null ? [
-    ] : [Refinement<unknown, CONTENT>]) => JsonInterface<Join<CONTENT, A, B>, RelationData<CONTENT, A, B>>;
-    getRelatedId(id: string): string | undefined;
-    getRelatedIds(id: string): string[];
-    getContent(idA: string, idB: string): CONTENT | undefined;
-    getRelationEntries(id: string): [string, CONTENT][];
-    getRelationRecord(id: string): Record<string, CONTENT>;
-    getRelation(id: string): NullSafeUnion<Identified, CONTENT> | undefined;
-    getRelations(id: string): NullSafeUnion<Identified, CONTENT>[];
-    setRelations(subject: {
-        [from in A]: string;
-    } | {
-        [to in B]: string;
-    }, relations: NullSafeUnion<Identified, CONTENT>[]): Join<CONTENT, A, B>;
-    set(relation: {
-        [key in A | B]: string;
-    }, ...rest: NullSafeRest<CONTENT>): Join<CONTENT, A, B>;
-    remove(relation: Partial<Record<A | B, string>>): Join<CONTENT, A, B>;
-}
-
-type Logger = Pick<Console, `error` | `info` | `warn`>;
-
-type TransactionToken<_> = {
-    key: string;
-    type: `transaction`;
-    __brand?: _;
-};
-type TransactionUpdate<ƒ extends ƒn> = {
-    key: string;
-    atomUpdates: KeyedStateUpdate<unknown>[];
-    params: Parameters<ƒ>;
-    output: ReturnType<ƒ>;
-};
-
-type StateUpdate<T> = {
-    newValue: T;
-    oldValue: T;
-};
-type KeyedStateUpdate<T> = StateUpdate<T> & {
-    key: string;
-};
-
-type TimelineToken = {
-    key: string;
-    type: `timeline`;
-};
-type TimelineUpdate = TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate;
-
-type AtomToken<_> = {
-    key: string;
-    type: `atom`;
-    family?: FamilyMetadata;
-    __brand?: _;
-};
-type SelectorToken<_> = {
-    key: string;
-    type: `selector`;
-    family?: FamilyMetadata;
-    __brand?: _;
-};
-type StateToken<T> = AtomToken<T> | SelectorToken<T>;
-type ReadonlySelectorToken<_> = {
-    key: string;
-    type: `readonly_selector`;
-    family?: FamilyMetadata;
-    __brand?: _;
-};
-type FamilyMetadata = {
-    key: string;
-    subKey: string;
-};
-
-type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
-interface Store {
-    atoms: Map<string, Atom<any>>;
-    atomsThatAreDefault: Set<string>;
-    readonlySelectors: Map<string, ReadonlySelector<any>>;
-    selectorAtoms: Join<null, `selectorKey`, `atomKey`>;
-    selectorGraph: Join<{
-        source: string;
-    }>;
-    selectors: Map<string, Selector<any>>;
-    timelineAtoms: Join<null, `timelineKey`, `atomKey`>;
-    timelines: Map<string, Timeline>;
-    transactions: Map<string, Transaction<any>>;
-    valueMap: Map<string, any>;
-    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;
-    };
-}
-
-type Atom<T> = {
-    key: string;
-    type: `atom`;
-    family?: FamilyMetadata;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    default: T;
-};
-
-type OperationProgress = {
-    open: false;
-} | {
-    open: true;
-    done: Set<string>;
-    prev: Map<string, any>;
-    time: number;
-    token: StateToken<any>;
-};
-
-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 Subscriber<T> = (value: T) => void;
-declare class Subject<T> {
-    subscribers: Subscriber<T>[];
-    subscribe(subscriber: Subscriber<T>): {
-        unsubscribe: () => void;
-    };
-    private unsubscribe;
-    next(value: T): void;
-}
-
-type TimelineAtomUpdate = StateUpdate<unknown> & {
-    key: string;
-    type: `atom_update`;
-    timestamp: number;
-};
-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 = {
-    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 SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
 
 declare const attachIntrospectionStates: (store?: __INTERNAL__.Store) => {
-    atomIndex: ReadonlySelectorToken$1<AtomTokenIndex>;
-    selectorIndex: ReadonlySelectorToken$1<SelectorTokenIndex>;
-    transactionIndex: ReadonlySelectorToken$1<TransactionToken$1<ƒn>[]>;
-    findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate$1<ƒn>[]>;
-    timelineIndex: ReadonlySelectorToken$1<TimelineToken$1[]>;
+    atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
+    selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
+    transactionIndex: ReadonlySelectorToken<TransactionToken<ƒn>[]>;
+    findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate<ƒn>[]>;
+    timelineIndex: ReadonlySelectorToken<TimelineToken[]>;
     findTimelineState: ReadonlySelectorFamily<Timeline>;
 };
 
-type FamilyNode<Token extends AtomToken$1<unknown> | ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>> = {
+type FamilyNode<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = {
     key: string;
     familyMembers: Record<string, Token>;
 };
-type StateTokenIndex<Token extends AtomToken$1<unknown> | ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>> = Record<string, FamilyNode<Token> | Token>;
+type StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
 
 export { FamilyNode, StateTokenIndex, attachIntrospectionStates };