atom.io 0.13.0 → 0.14.1

package/internal/dist/index.d.cts

@@ -1,5 +1,212 @@
-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 } from 'atom.io';
-import { Json } from 'atom.io/json';
+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 Effectors<T> = {
+    setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
+    onSet: (callback: (options: {
+        newValue: T;
+        oldValue: T;
+    }) => void) => void;
+};
+type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
+type AtomOptions<T> = {
+    key: string;
+    default: T | (() => T);
+    effects?: AtomEffect<T>[];
+};
+type MutableAtomOptions<T extends Transceiver<any>, J extends Serializable> = JsonInterface<T, J> & Omit<AtomOptions<T>, `default`> & {
+    default: () => T;
+    mutable: true;
+};
+type AtomFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    default: T | ((key: K) => T);
+    effects?: (key: K) => AtomEffect<T>[];
+};
+type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
+    key: string;
+    type: `atom_family`;
+    subject: Subject<AtomToken<T>>;
+};
+type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Serializable, K extends Serializable> = AtomFamilyOptions<T, K> & JsonInterface<T, J> & {
+    mutable: true;
+};
+type MutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Serializable, Key extends Serializable> = JsonInterface<Core, SerializableCore> & ((key: Key) => MutableAtomToken<Core, SerializableCore>) & {
+    key: `${string}::mutable`;
+    type: `atom_family`;
+    subject: Subject<MutableAtomToken<Core, SerializableCore>>;
+};
+
+declare const LoggerIconDictionary: {
+    readonly "\u231B": "Timeline event fully captured";
+    readonly "\u23E9": "Timeline redo";
+    readonly "\u23EA": "Timeline undo";
+    readonly "\u23ED\uFE0F": "Transaction redo";
+    readonly "\u23EE\uFE0F": "Transaction undo";
+    readonly "\u23F3": "Timeline event partially captured";
+    readonly "\u23F9\uFE0F": "Time-travel complete";
+    readonly "\uD83D\uDC81": "Notice";
+    readonly "\uD83D\uDD04": "Realtime transaction synchronized";
+    readonly "\u2705": "Realtime transaction success";
+    readonly "\u2728": "Computation complete";
+    readonly "\u274C": "Conflict prevents attempted action";
+    readonly "\u2B55": "Operation start";
+    readonly "\uD83D\uDC1E": "Possible bug in AtomIO";
+    readonly "\uD83D\uDC40": "Subscription added";
+    readonly "\uD83D\uDC6A": "Family member added";
+    readonly "\uD83D\uDCC1": "Stow update";
+    readonly "\uD83D\uDCC3": "Copy mutable";
+    readonly "\uD83D\uDCD6": "Read state";
+    readonly "\uD83D\uDCDD": "Write state";
+    readonly "\uD83D\uDCE2": "Notify subscribers";
+    readonly "\uD83D\uDD0C": "Register dependency";
+    readonly "\uD83D\uDD0D": "Discover root";
+    readonly "\uD83D\uDD25": "Delete state";
+    readonly "\uD83D\uDD27": "Create mutable atom";
+    readonly "\uD83D\uDD28": "Create immutable atom";
+    readonly "\uD83D\uDD34": "Operation complete";
+    readonly "\uD83D\uDDD1": "Evict cached value";
+    readonly "\uD83D\uDCA5": "Caught";
+    readonly "\uD83D\uDE48": "Subscription canceled";
+    readonly "\uD83D\uDEC4": "Apply transaction";
+    readonly "\uD83D\uDEE0\uFE0F": "Install atom into store";
+    readonly "\uD83D\uDEEB": "Begin transaction";
+    readonly "\uD83D\uDEEC": "Complete transaction";
+    readonly "\uD83E\uDDEE": "Computing selector";
+    readonly "\uD83E\uDDF9": "Prepare to evict";
+    readonly "\uD83E\uDE82": "Abort transaction";
+};
+type LoggerIcon = keyof typeof LoggerIconDictionary;
+declare const LOG_LEVELS: readonly ["info", "warn", "error"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogFn = (icon: LoggerIcon, tokenType: `atom` | `readonly_selector` | `selector` | `state` | `timeline` | `transaction` | `unknown`, tokenKey: string, message: string, ...rest: unknown[]) => void;
+type LogFilter = (...params: Parameters<LogFn>) => boolean;
+type Logger = Record<LogLevel, LogFn>;
+declare class AtomIOLogger implements Logger {
+    logLevel: `error` | `info` | `warn` | null;
+    private readonly filter?;
+    private readonly logger;
+    constructor(logLevel: `error` | `info` | `warn` | null, filter?: LogFilter | undefined, logger?: Logger);
+    error: LogFn;
+    info: LogFn;
+    warn: LogFn;
+}
+
+type TransactionToken<_> = {
+    key: string;
+    type: `transaction`;
+    __brand?: _;
+};
+type TransactionUpdate<ƒ extends ƒn> = {
+    key: string;
+    updates: (KeyedStateUpdate<unknown> | TransactionUpdate<ƒn>)[];
+    params: Parameters<ƒ>;
+    output: ReturnType<ƒ>;
+};
+type Transactors = {
+    get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S;
+    set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
+};
+type ReadonlyTransactors = Pick<Transactors, `get`>;
+type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Act<ƒ extends ƒn> = (transactors: Transactors & {
+    run: typeof runTransaction;
+}, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type TransactionOptions<ƒ extends ƒn> = {
+    key: string;
+    do: Act<ƒ>;
+};
+declare const runTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, store?: Store) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+
+type SelectorOptions<T> = {
+    key: string;
+    get: Read<() => T>;
+    set: Write<(newValue: T) => void>;
+};
+type ReadonlySelectorOptions<T> = {
+    key: string;
+    get: Read<() => T>;
+};
+type SelectorFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    get: (key: K) => Read<() => T>;
+    set: (key: K) => Write<(newValue: T) => void>;
+};
+type ReadonlySelectorFamilyOptions<T, K extends Serializable> = {
+    key: string;
+    get: (key: K) => Read<() => T>;
+};
+type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
+    key: string;
+    type: `selector_family`;
+    subject: Subject<SelectorToken<T>>;
+};
+type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
+    key: string;
+    type: `readonly_selector_family`;
+    subject: Subject<ReadonlySelectorToken<T>>;
+};
+
+type StateUpdate<T> = {
+    newValue: T;
+    oldValue: T;
+};
+type KeyedStateUpdate<T> = StateUpdate<T> & {
+    key: string;
+    family?: FamilyMetadata;
+};
+type UpdateHandler<T> = (update: StateUpdate<T>) => void;
+type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
+
+type TimelineToken = {
+    key: string;
+    type: `timeline`;
+};
+type TimelineOptions = {
+    key: string;
+    atoms: (AtomFamily<any, any> | AtomToken<any>)[];
+    shouldCapture?: (update: TimelineUpdate, timeline: Timeline) => boolean;
+};
+type TimelineUpdate = TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate;
+
+type ƒn = (...parameters: any[]) => any;
+type AtomToken<_> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    __brand?: _;
+};
+interface MutableAtomToken<T extends Transceiver<any>, J extends Serializable> extends AtomToken<T> {
+    __asJSON?: J;
+    __update?: T extends Transceiver<infer Update> ? Update : never;
+}
+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;
+};
 
 declare class Subject<T> {
     Subscriber: (value: T) => void;
@@ -103,13 +310,6 @@ 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: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlySelectorToken<T> | StateToken<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 Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
 type Cardinality = `1:1` | `1:n` | `n:n`;
 
@@ -184,26 +384,26 @@ interface Lineage {
 declare function newest<T extends Lineage>(scion: T): T;
 declare function eldest<T extends Lineage>(scion: T): T;
 
-interface Transceiver<Signal extends Json.Serializable> {
+interface Transceiver<Signal extends Serializable> {
     do: (update: Signal) => void;
     undo: (update: Signal) => void;
     subscribe: (key: string, fn: (update: Signal) => void) => () => void;
     cacheUpdateNumber: number;
     getUpdateNumber: (update: Signal) => number;
 }
-declare function isTransceiver(value: unknown): value is Transceiver<Json.Serializable>;
+declare function isTransceiver(value: unknown): value is Transceiver<Serializable>;
 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 Serializable>(options: MutableAtomOptions<Core, SerializableCore>, 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>;
+declare function createMutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Serializable, Key extends string>(options: MutableAtomFamilyOptions<Core, SerializableCore, Key>, store: Store): MutableAtomFamily<Core, SerializableCore, Key>;
 
-declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>, store: Store) => SelectorFamily<SerializableCore, Key>;
+declare const getJsonFamily: <Core extends Transceiver<Serializable>, SerializableCore extends Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>, store: Store) => SelectorFamily<SerializableCore, Key>;
 
-declare const getJsonToken: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => SelectorToken<SerializableCore>;
+declare const getJsonToken: <Core extends Transceiver<Serializable>, SerializableCore extends Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => SelectorToken<SerializableCore>;
 
-declare const getUpdateToken: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => AtomToken<Signal<Core>>;
+declare const getUpdateToken: <Core extends Transceiver<Serializable>, SerializableCore extends Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => AtomToken<Signal<Core>>;
 
 declare function isAtomTokenMutable(token: AtomToken<any>): token is MutableAtomToken<any, any>;
 
@@ -218,12 +418,12 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private unsubscribeFromInnerValue;
     private observeCore;
     private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+    mutableState: MutableAtomToken<Mutable, Serializable>;
     latestUpdateState: AtomToken<typeof this.Update | null>;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+    constructor(mutableState: MutableAtomToken<Mutable, Serializable>, store: Store);
 }
 
-declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Json.Serializable> {
+declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Serializable> {
     private readonly Update;
     readonly findLatestUpdateState: AtomFamily<typeof this.Update | null, FamilyMemberKey>;
     readonly findMutableState: AtomFamily<Core, FamilyMemberKey>;
@@ -380,12 +580,12 @@ 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 function createAtomFamily<T, K extends Json.Serializable>(options: AtomFamilyOptions<T, K>, store: Store): AtomFamily<T, K>;
+declare function createAtomFamily<T, K extends Serializable>(options: AtomFamilyOptions<T, 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 createReadonlySelectorFamily<T, K extends 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>;
-declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store: Store): SelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
 declare class LazyMap<K, V> extends Map<K, V> {
     protected readonly source: Map<K, V>;
@@ -411,4 +611,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;
 
-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, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+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) => (() => void);
+
+declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store) => (() => 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, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, 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 };