atom.io 0.14.8 → 0.15.1

package/internal/dist/index.d.ts

@@ -1,7 +1,12 @@
-import { FamilyMetadata, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, StateToken, ƒn, TransactionUpdate, TransactionOptions, TransactionToken, AtomToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, StateUpdate, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { FamilyMetadata as FamilyMetadata$1, SelectorOptions, SelectorToken, ReadonlySelectorOptions, ReadonlySelectorToken, Transactors, StateToken, ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRun, AtomToken, MutableAtomOptions, MutableAtomToken, MutableAtomFamilyOptions, MutableAtomFamily, SelectorFamily, AtomFamily, StateUpdate, TimelineUpdate, TimelineOptions, TimelineToken, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json } from 'atom.io/json';
 import { Store as Store$1 } from 'atom.io/internal';
 
+type FamilyMetadata = {
+    key: string;
+    subKey: string;
+};
+
 declare class Subject<T> {
     Subscriber: (value: T) => void;
     subscribers: Map<string, this[`Subscriber`]>;
@@ -18,7 +23,7 @@ declare class StatefulSubject<T> extends Subject<T> {
 type Selector<T> = {
     key: string;
     type: `selector`;
-    family?: FamilyMetadata;
+    family?: FamilyMetadata$1;
     install: (store: Store) => void;
     subject: Subject<{
         newValue: T;
@@ -30,7 +35,7 @@ type Selector<T> = {
 type ReadonlySelector<T> = {
     key: string;
     type: `readonly_selector`;
-    family?: FamilyMetadata;
+    family?: FamilyMetadata$1;
     install: (store: Store) => void;
     subject: Subject<{
         newValue: T;
@@ -38,8 +43,8 @@ type ReadonlySelector<T> = {
     }>;
     get: () => T;
 };
-declare function createSelector<T>(options: SelectorOptions<T>, family: FamilyMetadata | undefined, store: Store): SelectorToken<T>;
-declare function createSelector<T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined, store: Store): ReadonlySelectorToken<T>;
+declare function createSelector<T>(options: SelectorOptions<T>, family: FamilyMetadata$1 | undefined, store: Store): SelectorToken<T>;
+declare function createSelector<T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata$1 | undefined, store: Store): ReadonlySelectorToken<T>;
 
 declare function deleteSelector(selectorToken: ReadonlySelectorToken<unknown> | SelectorToken<unknown>, store: Store): void;
 
@@ -72,36 +77,33 @@ declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySel
 
 declare const abortTransaction: (store: Store) => void;
 
-declare const applyTransaction: <ƒ extends ƒn>(output: ReturnType<ƒ>, store: Store) => void;
+declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
 
 declare const buildTransaction: (key: string, params: any[], store: Store) => void;
 
-type Transaction<ƒ extends ƒn> = {
+type Transaction<ƒ extends _n> = {
     key: string;
     type: `transaction`;
     install: (store: Store) => void;
     subject: Subject<TransactionUpdate<ƒ>>;
     run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
 };
-declare function createTransaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
-
-declare const redoTransactionUpdate: <ƒ extends ƒn>(transactionUpdate: TransactionUpdate<ƒ>, store: Store) => void;
-
-declare const undoTransactionUpdate: <ƒ extends ƒn>(transactionUpdate: TransactionUpdate<ƒ>, store: Store) => void;
+declare function createTransaction<ƒ extends _n>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
-type TransactionMeta<ƒ extends ƒn> = {
+type TransactionMeta<ƒ extends _n> = {
     phase: `applying` | `building`;
     time: number;
     update: TransactionUpdate<ƒ>;
+    transactors: TransactorsWithRun;
 };
 
 declare function deposit<T>(state: Atom<T>): AtomToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: Atom<T> | Selector<T>): StateToken<T>;
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
-declare function deposit<T>(state: Transaction<T extends ƒn ? T : never>): TransactionToken<T>;
+declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
 declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlySelectorToken<T> | StateToken<T>;
 
 type primitive = boolean | number | string | null;
@@ -196,7 +198,7 @@ declare function isTransceiver(value: unknown): value is Transceiver<Json.Serial
 type TransceiverMode = `playback` | `record` | `transaction`;
 type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer Signal> ? Signal : never;
 
-declare function createMutableAtom<Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(options: MutableAtomOptions<Core, SerializableCore>, store: Store): MutableAtomToken<Core, SerializableCore>;
+declare function createMutableAtom<Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(options: MutableAtomOptions<Core, SerializableCore>, family: FamilyMetadata$1 | undefined, store: Store): MutableAtomToken<Core, SerializableCore>;
 
 declare function createMutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Json.Serializable, Key extends string>(options: MutableAtomFamilyOptions<Core, SerializableCore, Key>, store: Store): MutableAtomFamily<Core, SerializableCore, Key>;
 
@@ -253,7 +255,7 @@ type TimelineAtomUpdate = StateUpdate<unknown> & {
     key: string;
     type: `atom_update`;
     timestamp: number;
-    family?: FamilyMetadata;
+    family?: FamilyMetadata$1;
 };
 type TimelineSelectorUpdate = {
     key: string;
@@ -261,7 +263,7 @@ type TimelineSelectorUpdate = {
     timestamp: number;
     atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
 };
-type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+type TimelineTransactionUpdate = TransactionUpdate<_n> & {
     key: string;
     type: `transaction_update`;
     timestamp: number;
@@ -294,7 +296,7 @@ declare class Store implements Lineage {
     trackers: Map<string, Tracker<Transceiver<any>>>;
     families: Map<string, AtomFamily<any, any> | ReadonlySelectorFamily<any, any> | SelectorFamily<any, any>>;
     timelines: Map<string, Timeline>;
-    transactions: Map<string, Transaction<ƒn>>;
+    transactions: Map<string, Transaction<_n>>;
     atomsThatAreDefault: Set<string>;
     timelineAtoms: Junction<"timelineKey", "atomKey", null>;
     selectorAtoms: Junction<"selectorKey", "atomKey", null>;
@@ -304,13 +306,13 @@ declare class Store implements Lineage {
     subject: {
         atomCreation: Subject<AtomToken<unknown>>;
         selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<ƒn>>;
+        transactionCreation: Subject<TransactionToken<_n>>;
         timelineCreation: Subject<TimelineToken>;
-        transactionApplying: StatefulSubject<TransactionMeta<ƒn> | null>;
+        transactionApplying: StatefulSubject<TransactionMeta<_n> | null>;
         operationStatus: Subject<OperationProgress>;
     };
     operation: OperationProgress;
-    transactionMeta: TransactionMeta<ƒn> | null;
+    transactionMeta: TransactionMeta<_n> | null;
     config: {
         name: string;
     };
@@ -328,7 +330,7 @@ declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undef
 declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
 declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
 declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never> | undefined;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
 declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
 declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | undefined;
 
@@ -338,6 +340,16 @@ declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T>, sto
 declare function withdrawNewFamilyMember<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | undefined;
 declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
 
+declare function createAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family: FamilyMetadata$1 | undefined, store: Store): AtomToken<T>;
+
+declare function createRegularAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family: FamilyMetadata$1 | undefined, store: Store): AtomToken<T>;
+
+declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
+
+declare const isAtomDefault: (key: string, store: Store) => boolean;
+declare const markAtomAsDefault: (key: string, store: Store) => void;
+declare const markAtomAsNotDefault: (key: string, store: Store) => void;
+
 type Atom<T> = {
     key: string;
     type: `atom`;
@@ -351,14 +363,6 @@ type Atom<T> = {
     default: T | (() => T);
     cleanup?: () => void;
 };
-declare function createAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family: FamilyMetadata | undefined, store: Store): AtomToken<T>;
-
-declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
-
-declare const isAtomDefault: (key: string, store: Store) => boolean;
-declare const markAtomAsDefault: (key: string, store: Store) => void;
-declare const markAtomAsNotDefault: (key: string, store: Store) => void;
-declare const isSelectorDefault: (key: string, store: Store) => boolean;
 
 /**
  * A Promise that can be canceled.
@@ -377,12 +381,15 @@ declare class Future<T> extends Promise<T> {
 
 declare function cacheValue<T>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): T;
 declare function cacheValue<T extends Promise<any>>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): Future<T>;
-declare const readCachedValue: <T>(key: string, store: Store) => T;
-declare const isValueCached: (key: string, store: Store) => boolean;
-declare const evictCachedValue: (key: string, store: Store) => void;
+declare const readCachedValue: <T>(key: string, target: Store) => T;
+declare const isValueCached: (key: string, target: Store) => boolean;
+declare const evictCachedValue: (key: string, target: Store) => void;
 
+declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
 declare function createAtomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K>, store: Store): AtomFamily<T, K>;
 
+declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K> | MutableAtomFamilyOptions<any, any, K>, store: Store): AtomFamily<T, K>;
+
 declare function createReadonlySelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: SelectorFamilyOptions<T, K>, store: Store): SelectorFamily<T, K>;
@@ -412,10 +419,10 @@ declare const setAtomOrSelector: <T>(state: Atom<T> | Selector<T>, value: T | ((
 
 declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>, store: Store) => (() => void)[] | null;
 
-declare function subscribeToState<T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store$1): () => void;
+declare function subscribeToState<T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
 
 declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update: TimelineUpdate | `redo` | `undo`) => void, key: string, store: Store$1) => (() => void);
 
-declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store$1) => (() => void);
+declare const subscribeToTransaction: <ƒ extends _n>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store$1) => (() => void);
 
-export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };