atom.io 0.6.8 → 0.7.0

package/internal/dist/index.d.mts

@@ -0,0 +1,342 @@
+import * as AtomIO from 'atom.io';
+import { AtomToken, ReadonlySelectorToken, SelectorToken, Transactors, FamilyMetadata, SelectorOptions, ReadonlySelectorOptions, StateToken, ƒn, TransactionUpdate, TransactionOptions, TransactionToken, MutableAtomToken, StateUpdate, TimelineUpdate, TimelineOptions, TimelineToken, AtomFamily, ReadonlySelectorFamily, SelectorFamily, Logger, AtomOptions, MutableAtomOptions, AtomFamilyOptions, ReadonlySelectorFamilyOptions, SelectorFamilyOptions } from 'atom.io';
+import { Json } from 'atom.io/json';
+
+declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>)[];
+
+declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
+
+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;
+}
+
+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;
+};
+declare function createSelector<T>(options: SelectorOptions<T>, family?: FamilyMetadata, store?: Store): SelectorToken<T>;
+declare function createSelector<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata, store?: Store): ReadonlySelectorToken<T>;
+
+declare const traceSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => AtomToken<unknown>[];
+declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomToken<unknown>[];
+
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => void;
+
+type Transaction<ƒ extends ƒn> = {
+    key: string;
+    type: `transaction`;
+    install: (store: Store) => void;
+    subject: Subject<TransactionUpdate<ƒ>>;
+    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+};
+declare function transaction__INTERNAL<ƒ extends ƒn>(options: TransactionOptions<ƒ>, store?: Store): TransactionToken<ƒ>;
+declare const target: (store?: Store) => StoreCore;
+
+declare const abortTransaction: (store: Store) => void;
+
+declare const applyTransaction: <ƒ extends ƒn>(output: ReturnType<ƒ>, store: Store) => void;
+
+declare const buildTransaction: (key: string, params: any[], store: Store) => void;
+
+declare const redoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
+
+declare const undoTransactionUpdate: <ƒ extends ƒn>(update: TransactionUpdate<ƒ>, store: Store) => void;
+
+declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
+type TransactionPhase = typeof TRANSACTION_PHASES[number];
+type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
+    phase: `applying` | `building`;
+    time: number;
+    core: StoreCore;
+};
+type TransactionIdle = {
+    phase: `idle`;
+};
+type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
+
+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: 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`;
+
+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: (contentKey: string) => 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;
+}
+
+interface Transceiver<Signal extends Json.Serializable> {
+    do: (update: Signal) => void;
+    undo: (update: Signal) => void;
+    subscribe: (key: string, fn: (update: Signal) => void) => () => void;
+}
+declare function isTransceiver(value: unknown): value is Transceiver<Json.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: AtomIO.MutableAtomOptions<Core, SerializableCore>, store?: Store): AtomIO.MutableAtomToken<Core, SerializableCore>;
+
+declare function createMutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Json.Serializable, Key extends string>(options: AtomIO.MutableAtomFamilyOptions<Core, SerializableCore, Key>, store?: Store): AtomIO.MutableAtomFamily<Core, SerializableCore, Key>;
+
+declare const getJsonToken: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.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 function isAtomTokenMutable(token: AtomIO.AtomToken<any>): token is AtomIO.MutableAtomToken<any, any>;
+
+/**
+ * @internal Give the tracker a transceiver state and a store, and it will
+ * subscribe to the transceiver's inner value. When the inner value changes,
+ * the tracker will update its own state to reflect the change.
+ */
+declare class Tracker<Mutable extends Transceiver<any>> {
+    private Update;
+    private initializeState;
+    private unsubscribeFromInnerValue;
+    private observeCore;
+    private updateCore;
+    mutableState: AtomIO.MutableAtomToken<Mutable, Json.Serializable>;
+    latestUpdateState: AtomIO.AtomToken<typeof this$1.Update | null>;
+    constructor(mutableState: AtomIO.MutableAtomToken<Mutable, Json.Serializable>, store?: Store);
+}
+
+declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Json.Serializable> {
+    private readonly Update;
+    readonly findLatestUpdateState: AtomIO.AtomFamily<typeof this$1.Update | null, FamilyMemberKey>;
+    readonly findMutableState: AtomIO.AtomFamily<Core, FamilyMemberKey>;
+    constructor(findMutableState: AtomIO.AtomFamily<Core, FamilyMemberKey>, store?: Store);
+}
+
+interface MutableAtom<T> extends Atom<T> {
+    mutable: true;
+}
+declare const isAtomMutable: <T>(atom: Atom<T>) => atom is MutableAtom<T>;
+
+type OperationProgress = {
+    open: false;
+} | {
+    open: true;
+    done: Set<string>;
+    prev: Map<string, any>;
+    time: number;
+    token: StateToken<any>;
+};
+declare const openOperation: (token: StateToken<any>, store: Store) => void;
+declare const closeOperation: (store: Store) => void;
+declare const isDone: (key: string, store?: Store) => boolean;
+declare const markDone: (key: string, store?: Store) => void;
+
+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`>;
+};
+declare function timeline__INTERNAL(options: TimelineOptions, store?: Store, data?: Timeline | null): TimelineToken;
+
+declare const addAtomToTimeline: (atomToken: AtomToken<any>, tl: Timeline, store?: Store) => void;
+
+declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+
+type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `families` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `trackers` | `transactions` | `valueMap`>;
+declare class Store {
+    valueMap: Map<string, any>;
+    atoms: Map<string, Atom<any> | MutableAtom<any>>;
+    selectors: Map<string, Selector<any>>;
+    readonlySelectors: Map<string, ReadonlySelector<any>>;
+    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>>;
+    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<SelectorToken<unknown> | ReadonlySelectorToken<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);
+}
+declare const IMPLICIT: {
+    STORE_INTERNAL: Store | undefined;
+    readonly STORE: Store;
+};
+declare const clearStore: (store?: Store) => void;
+
+declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>;
+
+declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | null;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | null;
+declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | null;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never> | null;
+declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | null;
+declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | null;
+
+declare function withdrawNewFamilyMember<T>(token: AtomToken<T>, store: Store): Atom<T> | null;
+declare function withdrawNewFamilyMember<T>(token: SelectorToken<T>, store: Store): Selector<T> | null;
+declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | null;
+declare function withdrawNewFamilyMember<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T> | null;
+declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | null;
+
+type Atom<T> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    install: (store: Store) => void;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    default: T;
+};
+declare function createAtom<T>(options: AtomOptions<T> | MutableAtomOptions<any, any>, family?: FamilyMetadata, store?: Store): AtomToken<T>;
+
+declare function deleteAtom(key: string, core?: StoreCore): 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;
+
+declare const cacheValue: (key: string, value: unknown, store?: Store) => void;
+declare const readCachedValue: <T>(key: string, store?: Store) => T;
+declare const isValueCached: (key: string, store?: Store) => boolean;
+
+declare function createAtomFamily<T, K extends Json.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 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 const getState__INTERNAL: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
+
+type Modify<T> = (thing: T) => T;
+declare const become: <T>(nextVersionOfThing: T | Modify<T>) => (originalThing: T) => T;
+
+declare const setState__INTERNAL: <T>(state: Atom<T> | Selector<T>, value: T | ((oldValue: T) => T), store?: Store) => void;
+
+declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>, store: Store) => (() => void)[] | null;
+
+export { Atom, FamilyTracker, IMPLICIT, Modify, MutableAtom, OperationProgress, ReadonlySelector, Selector, Signal, Store, StoreCore, Subject, TRANSACTION_PHASES, Timeline, TimelineAtomUpdate, TimelineSelectorUpdate, TimelineTransactionUpdate, Tracker, Transaction, TransactionIdle, TransactionPhase, TransactionStatus, TransactionUpdateInProgress, Transceiver, TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, deleteAtom, deposit, getJsonToken, getState__INTERNAL, getUpdateToken, isAtomDefault, isAtomMutable, isAtomTokenMutable, isDone, isSelectorDefault, isTransceiver, isValueCached, lookup, lookupSelectorSources, markAtomAsDefault, markAtomAsNotDefault, markDone, openOperation, readCachedValue, redoTransactionUpdate, redo__INTERNAL, registerSelector, setState__INTERNAL, subscribeToRootAtoms, target, timeline__INTERNAL, traceAllSelectorAtoms, traceSelectorAtoms, transaction__INTERNAL, undoTransactionUpdate, undo__INTERNAL, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };