atom.io 0.14.6 → 0.14.7

package/internal/dist/index.d.cts

@@ -1,421 +0,0 @@
-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 { Json } from 'atom.io/json';
-import { Store as Store$1 } from 'atom.io/internal';
-
-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 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 | undefined, store: Store): SelectorToken<T>;
-declare function createSelector<T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined, store: Store): ReadonlySelectorToken<T>;
-
-declare function deleteSelector(selectorToken: ReadonlySelectorToken<unknown> | SelectorToken<unknown>, store: Store): void;
-
-type AtomKey<T> = string & {
-    __atomKey?: never;
-    __brand?: T;
-};
-type SelectorKey<T> = string & {
-    __selectorKey?: never;
-    __brand?: T;
-};
-type ReadonlySelectorKey<T> = string & {
-    __readonlySelectorKey?: never;
-    __brand?: T;
-};
-declare const isAtomKey: (key: string, store: Store) => key is AtomKey<unknown>;
-declare const isSelectorKey: (key: string, store: Store) => key is SelectorKey<unknown>;
-declare const isReadonlySelectorKey: (key: string, store: Store) => key is ReadonlySelectorKey<unknown>;
-type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>;
-declare const isStateKey: (key: string, store: Store) => key is StateKey<unknown>;
-
-declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
-
-declare const registerSelector: (selectorKey: string, store: Store) => Transactors;
-
-declare const traceSelectorAtoms: (selectorKey: string, directDependencyKey: StateKey<unknown>, store: Store) => AtomKey<unknown>[];
-declare const traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomKey<unknown>[];
-
-declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => void;
-
-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;
-
-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 const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
-type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
-type TransactionMeta<ƒ extends ƒn> = {
-    phase: `applying` | `building`;
-    time: number;
-    update: TransactionUpdate<ƒ>;
-};
-
-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 BaseExternalStoreConfiguration = {
-    addRelation: (a: string, b: string) => void;
-    deleteRelation: (a: string, b: string) => void;
-    replaceRelationsSafely: (a: string, bs: string[]) => void;
-    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys: (key: string) => Set<string> | undefined;
-    has: (a: string, b?: string) => boolean;
-};
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
-    getContent: (contentKey: string) => Content | undefined;
-    setContent: (contentKey: string, content: Content) => void;
-    deleteContent: (contentKey: string) => void;
-};
-type Empty<Obj extends object> = {
-    [Key in keyof Obj]?: undefined;
-};
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
-    externalStore?: ExternalStoreConfiguration<Content>;
-    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<const ASide extends string, const BSide extends string, const 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 replaceRelationsUnsafely(a: string, bs: string[]): void;
-    protected replaceRelationsSafely(a: string, bs: 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;
-    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
-}
-
-interface Lineage {
-    parent: typeof this | null;
-    child: typeof this | null;
-}
-declare function newest<T extends Lineage>(scion: T): T;
-declare function eldest<T extends Lineage>(scion: T): T;
-
-interface Transceiver<Signal extends Json.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>;
-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 createMutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Json.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 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 const getUpdateFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core> | null, Key>;
-
-/**
- * @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: MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: AtomToken<typeof this.Update | null>;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
-}
-
-declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey extends Json.Serializable> {
-    private readonly Update;
-    readonly findLatestUpdateState: AtomFamily<typeof this.Update | null, FamilyMemberKey>;
-    readonly findMutableState: AtomFamily<Core, FamilyMemberKey>;
-    constructor(findMutableState: AtomFamily<Core, FamilyMemberKey>, store: Store);
-}
-
-interface MutableAtom<T> extends Atom<T> {
-    mutable: true;
-}
-
-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) => `rejection` | undefined;
-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;
-    shouldCapture?: (update: TimelineUpdate, timeline: Timeline) => boolean;
-    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 createTimeline(options: TimelineOptions, store: Store, data?: Timeline): TimelineToken;
-
-declare const addAtomToTimeline: (atomToken: AtomToken<any>, tl: Timeline, store: Store) => void;
-
-declare const timeTravel: (direction: `backward` | `forward`, token: TimelineToken, store: Store) => void;
-
-declare class Store implements Lineage {
-    parent: Store | null;
-    child: Store | null;
-    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<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<ƒn>>;
-        timelineCreation: Subject<TimelineToken>;
-        transactionApplying: StatefulSubject<TransactionMeta<ƒn> | null>;
-        operationStatus: Subject<OperationProgress>;
-    };
-    operation: OperationProgress;
-    transactionMeta: TransactionMeta<ƒn> | null;
-    config: {
-        name: string;
-    };
-    loggers: AtomIOLogger[];
-    logger: 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 withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
-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: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined;
-declare function withdraw<T>(token: TimelineToken, store: Store): Timeline | undefined;
-
-declare function withdrawNewFamilyMember<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-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;
-
-type Atom<T> = {
-    key: string;
-    type: `atom`;
-    mutable?: boolean;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: 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.
- * @internal
- * @private
- * @typeParam T The type of the value that the promise will resolve to.
- *
- * @remarks
- * Can be constructed like a Promise, or from an existing Promise.
- */
-declare class Future<T> extends Promise<T> {
-    isCanceled: boolean;
-    constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
-    cancel(): void;
-}
-
-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 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 class LazyMap<K, V> extends Map<K, V> {
-    protected readonly source: Map<K, V>;
-    deleted: Set<K>;
-    constructor(source: Map<K, V>);
-    get(key: K): V | undefined;
-    set(key: K, value: V): this;
-    hasOwn(key: K): boolean;
-    has(key: K): boolean;
-    delete(key: K): boolean;
-}
-
-declare class NotFoundError extends Error {
-    constructor(token: ReadonlySelectorToken<any> | StateToken<any>, store: Store);
-}
-
-declare const readOrComputeValue: <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 setAtomOrSelector: <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;
-
-declare function subscribeToState<T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, key: string, store: Store$1): () => 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);
-
-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 };

package/introspection/dist/index.d.cts

@@ -1,24 +0,0 @@
-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 AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>;
-
-type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
-
-declare const attachIntrospectionStates: (store?: Internal.Store) => {
-    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<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = {
-    key: string;
-    familyMembers: Record<string, Token>;
-};
-type StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
-
-export { type FamilyNode, type StateTokenIndex, attachIntrospectionStates };

package/json/dist/index.d.cts

@@ -1,51 +0,0 @@
-import * as AtomIO from 'atom.io';
-import { Store } from 'atom.io/internal';
-
-type JsonInterface<T, J extends Serializable = Serializable> = {
-    toJson: (t: T) => J;
-    fromJson: (json: J) => T;
-};
-declare const stringSetJsonInterface: JsonInterface<Set<string>, Array<string>>;
-
-type primitive = boolean | number | string | null;
-declare const isString: (input: unknown) => input is string;
-declare const isNumber: (input: unknown) => input is number;
-declare const isBoolean: (input: unknown) => input is boolean;
-declare const isNull: (input: unknown) => input is null;
-declare const isPrimitive: (input: unknown) => input is primitive;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-
-type json_Array<Element extends Serializable = Serializable> = Array<Element>;
-type json_Serializable = Serializable;
-declare namespace json {
-  export type { json_Array as Array, Object$1 as Object, json_Serializable as Serializable };
-}
-
-declare const parseJson: <S extends Stringified<Serializable>>(str: string | S) => S extends Stringified<infer J extends Serializable> ? J : Serializable;
-type Stringified<J extends Serializable> = string & {
-    __json: J;
-};
-declare const stringifyJson: <J extends Serializable>(json: J) => Stringified<J>;
-type Empty = Record<string, never>;
-declare const JSON_TYPE_NAMES: readonly ["array", "boolean", "null", "number", "object", "string"];
-type JsonTypeName = (typeof JSON_TYPE_NAMES)[number];
-interface JsonTypes extends Record<JsonTypeName, Serializable> {
-    array: Array;
-    boolean: boolean;
-    null: null;
-    number: number;
-    object: Object$1;
-    string: string;
-}
-declare const JSON_DEFAULTS: JsonTypes;
-
-declare const selectJson: <T, J extends Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.SelectorToken<J>;
-
-declare const selectJsonFamily: <T, J extends Serializable, K extends Serializable>(atomFamily: AtomIO.AtomFamily<T, K>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.SelectorFamily<J, K>;
-
-export { type Empty, JSON_DEFAULTS, JSON_TYPE_NAMES, json as Json, type JsonInterface, type JsonTypeName, type JsonTypes, type Stringified, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, type primitive, selectJson, selectJsonFamily, stringSetJsonInterface, stringifyJson };

package/react/dist/index.d.cts

@@ -1,23 +0,0 @@
-import { Store } from 'atom.io/internal';
-import * as React from 'react';
-import { StateToken, ReadonlySelectorToken, MutableAtomToken, TimelineToken } from 'atom.io';
-import { Json } from 'atom.io/json';
-
-declare const StoreContext: React.Context<Store>;
-declare const StoreProvider: React.FC<{
-    children: React.ReactNode;
-    store?: Store;
-}>;
-
-declare function useI<T>(token: StateToken<T>): <New extends T>(next: New | ((old: T) => New)) => void;
-declare function useO<T>(token: ReadonlySelectorToken<T> | StateToken<T>): T;
-declare function useJSON<Serializable extends Json.Serializable>(token: MutableAtomToken<any, Serializable>): Serializable;
-type TimelineMeta = {
-    at: number;
-    length: number;
-    undo: () => void;
-    redo: () => void;
-};
-declare function useTL(token: TimelineToken): TimelineMeta;
-
-export { StoreContext, StoreProvider, type TimelineMeta, useI, useJSON, useO, useTL };