atom.io 0.16.3 → 0.18.0

package/internal/dist/index.d.ts

@@ -1,64 +1,5 @@
-import { ƒn as _n, TransactionUpdate, TransactionOptions, TransactionToken, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, SelectorToken, MutableAtomOptions, MutableAtomFamilyOptions, AtomFamily, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MutableAtomFamilyToken, RegularAtomFamilyToken, WritableSelectorFamilyToken, ReadonlySelectorFamilyToken, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { ƒn as _n, TransactionToken, TransactionUpdate, TransactionOptions, TransactorsWithRunAndEnv, RegularAtomToken, MutableAtomToken, WritableSelectorToken, ReadonlySelectorToken, WritableToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, TimelineUpdate, TimelineOptions, TimelineToken, AtomToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, SelectorFamily, SelectorToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, WritableFamilyToken, ReadableFamilyToken, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, Transactors, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, JsonInterface } from 'atom.io/json';
-import { Store as Store$1 } from 'atom.io/internal';
-
-declare const abortTransaction: (store: Store) => void;
-
-declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
-
-interface RootStore extends Store {
-    transactionMeta: TransactionEpoch;
-    parent: null;
-    child: ChildStore | null;
-}
-interface ChildStore extends Store {
-    transactionMeta: TransactionProgress<_n>;
-    parent: ChildStore | RootStore;
-    child: ChildStore | null;
-}
-
-declare const buildTransaction: (key: string, params: any[], store: Store, id?: string) => ChildStore;
-
-declare class Subject<T> {
-    Subscriber: (value: T) => void;
-    subscribers: Map<string, this[`Subscriber`]>;
-    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
-    private unsubscribe;
-    next(value: T): void;
-}
-declare class StatefulSubject<T> extends Subject<T> {
-    state: T;
-    constructor(initialState: T);
-    next(value: T): void;
-}
-
-type Transaction<ƒ extends _n> = {
-    key: string;
-    type: `transaction`;
-    install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<ƒ>>;
-    run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>;
-};
-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 TransactionProgress<ƒ extends _n> = {
-    phase: `applying` | `building`;
-    update: TransactionUpdate<ƒ>;
-    transactors: TransactorsWithRunAndEnv;
-};
-type TransactionEpoch = {
-    epoch: number;
-};
-
-declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
-declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
-declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
-declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
-declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
-declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 
 type primitive = boolean | number | string | null;
 
@@ -134,6 +75,78 @@ declare class Junction<const ASide extends string, const BSide extends string, c
     has(a: string, b?: string): boolean;
 }
 
+declare const abortTransaction: (store: Store) => void;
+
+declare function actUponStore<ƒ extends _n>(token: TransactionToken<ƒ>, id: string, store: Store): (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+
+declare const applyTransaction: <ƒ extends _n>(output: ReturnType<ƒ>, store: Store) => void;
+
+declare function assignTransactionToContinuity(continuityKey: string, transactionKey: string, store: Store): void;
+
+interface RootStore extends Store {
+    transactionMeta: TransactionEpoch;
+    parent: null;
+    child: ChildStore | null;
+}
+interface ChildStore extends Store {
+    transactionMeta: TransactionProgress<_n>;
+    parent: ChildStore | RootStore;
+    child: ChildStore | null;
+}
+declare function isRootStore(store: Store): store is RootStore;
+declare function isChildStore(store: Store): store is ChildStore;
+
+declare const buildTransaction: (key: string, params: any[], store: Store, id: string) => ChildStore;
+
+declare class Subject<T> {
+    Subscriber: (value: T) => void;
+    subscribers: Map<string, this[`Subscriber`]>;
+    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
+    private unsubscribe;
+    next(value: T): void;
+}
+declare class StatefulSubject<T> extends Subject<T> {
+    state: T;
+    constructor(initialState: T);
+    next(value: T): void;
+}
+
+type Transaction<ƒ extends _n> = {
+    key: string;
+    type: `transaction`;
+    install: (store: Store) => void;
+    subject: Subject<TransactionUpdate<ƒ>>;
+    run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>;
+};
+declare function createTransaction<ƒ extends _n>(options: TransactionOptions<ƒ>, store: Store): TransactionToken<ƒ>;
+
+declare function getContinuityKey(transactionKey: string, store: Store): string | undefined;
+declare function getEpochNumberOfContinuity(continuityKey: string, store: Store): number | undefined;
+declare function getEpochNumberOfAction(transactionKey: string, store: Store): number | undefined;
+
+declare function setEpochNumberOfContinuity(continuityKey: string, newEpoch: number, store: Store): void;
+declare function setEpochNumberOfAction(transactionKey: string, newEpoch: number, store: Store): void;
+
+declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
+type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
+type TransactionProgress<ƒ extends _n> = {
+    phase: `applying` | `building`;
+    update: TransactionUpdate<ƒ>;
+    transactors: TransactorsWithRunAndEnv;
+};
+type TransactionEpoch = {
+    epoch: Map<string, number>;
+    actionContinuities: Junction<`continuity`, `action`>;
+};
+
+declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
+declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
+declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
+declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
+declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
+declare function deposit<T>(state: Transaction<T extends _n ? T : never>): TransactionToken<T>;
+declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
+
 interface Lineage {
     parent: typeof this | null;
     child: typeof this | null;
@@ -229,7 +242,7 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = ReadableState<any> | Timeline<any> | Transaction<any>;
+type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
 declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T> | undefined;
 declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any> | undefined;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
@@ -238,6 +251,12 @@ declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): Rea
 declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
 declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
 declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K> | undefined;
+declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any> | undefined;
+declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any> | undefined;
 declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
 declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never> | undefined;
 
@@ -307,6 +326,8 @@ 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 function arbitrary(random?: () => number): string;
+
 /**
  * A Promise that can be canceled.
  * @internal
@@ -339,17 +360,24 @@ declare function createSelectorFamily<T, K extends Json.Serializable>(options: R
 
 declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
+declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
+declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
 declare function findInStore<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
 
 type EnvironmentData = {
-    runtime: `browser` | `node` | `unknown`;
+    window: typeof window | undefined;
+    global: typeof global | undefined;
     store: Store;
 };
 declare function getEnvironmentData(store: Store): EnvironmentData;
 
+declare function getFromStore<T>(token: ReadableToken<T>, store: Store): T;
+
+declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
+
 declare function ingestAtomUpdate(applying: `newValue` | `oldValue`, atomUpdate: KeyedStateUpdate<any>, store: Store): void;
 
 declare function ingestSelectorUpdate(applying: `newValue` | `oldValue`, selectorUpdate: TimelineSelectorUpdate<any>, store: Store): void;
@@ -390,8 +418,6 @@ declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
 }
 
-declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
-
 declare const createReadonlySelector: <T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => ReadonlySelectorToken<T>;
 
 declare function createStandaloneSelector<T>(options: WritableSelectorOptions<T>, store: Store): WritableSelectorToken<T>;
@@ -415,15 +441,17 @@ declare const become: <T>(nextVersionOfThing: T | Modify<T>) => (originalThing:
 
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
+declare function setIntoStore<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New), store: Store): void;
+
 declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[] | null;
 
 declare function subscribeToState<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store): () => void;
 
-declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store$1) => (() => void);
+declare const subscribeToTimeline: <ManagedAtom extends TimelineManageable>(token: TimelineToken<ManagedAtom>, handleUpdate: (update: TimelineUpdate<any> | `redo` | `undo`) => void, key: string, store: Store) => (() => 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) => (() => void);
 
-type BaseStateData = {
+type AtomIOState = {
     key: string;
     family?: FamilyMetadata;
     install: (store: Store) => void;
@@ -432,23 +460,23 @@ type BaseStateData = {
         oldValue: any;
     }>;
 };
-type RegularAtom<T> = BaseStateData & {
+type RegularAtom<T> = AtomIOState & {
     type: `atom`;
     default: T | (() => T);
     cleanup?: () => void;
 };
-type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = BaseStateData & JsonInterface<T, J> & {
+type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
     type: `mutable_atom`;
     default: T | (() => T);
     cleanup?: () => void;
 };
 type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
-type WritableSelector<T> = BaseStateData & {
+type WritableSelector<T> = AtomIOState & {
     type: `selector`;
     get: () => T;
     set: (newValue: T | ((oldValue: T) => T)) => void;
 };
-type ReadonlySelector<T> = BaseStateData & {
+type ReadonlySelector<T> = AtomIOState & {
     type: `readonly_selector`;
     get: () => T;
 };
@@ -456,4 +484,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomKey, type BaseStateData, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, 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 TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getEnvironmentData, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isDone, isMutable, isReadonlySelectorKey, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, 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 TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };