atom.io 0.6.7 → 0.6.9

package/react-devtools/dist/index.d.mts

@@ -1,180 +1,73 @@
-import { Refinement } from 'fp-ts/Refinement';
-import { AtomToken as AtomToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, SelectorToken as SelectorToken$1 } from 'atom.io';
+import * as atom_io from 'atom.io';
+import { StateToken, FamilyMetadata, TimelineUpdate, StateUpdate, TransactionUpdate, ƒn, AtomToken, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, Logger } from 'atom.io';
+import { Refinement as Refinement$1 } from 'fp-ts/Refinement';
 
 type PlainObject = Record<keyof any, unknown>;
 
-type ƒn = (...parameters: any[]) => any;
+type primitive = boolean | number | string | null;
 
-type JsonInterface<T, J extends Json = Json> = {
-    toJson: (t: T) => J;
-    fromJson: (json: J) => T;
-};
-
-type Primitive = boolean | number | string | null;
-type Serializable = Primitive | Readonly<{
+type Serializable = primitive | Readonly<{
     [key: string]: Serializable;
 }> | ReadonlyArray<Serializable>;
-type JsonObj<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-type JsonArr<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-type Json = JsonArr | JsonObj | Primitive;
+type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
 
-type Identified = {
-    id: string;
-};
+type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
+type Cardinality = `1:1` | `1:n` | `n:n`;
 
-declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
-type RelationType = typeof RELATION_TYPES[number];
-type RelationData<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
-    contents: JsonObj<string, CONTENT>;
-    relations: JsonObj<string, string[]>;
-    relationType: RelationType;
-    a: A;
-    b: B;
-};
-type IsRelationDataOptions<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
-    from?: A;
-    to?: B;
-    isContent?: (json: Json) => json is CONTENT;
-};
-
-type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
-type NullSafeRest<MaybeArg> = MaybeArg extends null ? [] | [undefined] : [MaybeArg];
-
-declare class Join<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> implements RelationData<CONTENT, A, B> {
-    readonly relationType: `1:1` | `1:n` | `n:n`;
-    readonly a: A;
-    readonly b: B;
-    readonly relations: Record<string, string[]>;
-    readonly contents: Record<string, CONTENT>;
-    constructor(json?: Partial<RelationData<CONTENT, A, B>>);
-    toJSON(): RelationData<CONTENT, A, B>;
-    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, options?: IsRelationDataOptions<CONTENT, A, B>): Join<CONTENT, A, B>;
-    from<AA extends string>(newA: AA): Join<CONTENT, AA, B>;
-    to<BB extends string>(newB: BB): Join<CONTENT, A, BB>;
-    makeJsonInterface: (...params: CONTENT extends null ? [
-    ] : [Refinement<unknown, CONTENT>]) => JsonInterface<Join<CONTENT, A, B>, RelationData<CONTENT, A, B>>;
-    getRelatedId(id: string): string | undefined;
-    getRelatedIds(id: string): string[];
-    getContent(idA: string, idB: string): CONTENT | undefined;
-    getRelationEntries(id: string): [string, CONTENT][];
-    getRelationRecord(id: string): Record<string, CONTENT>;
-    getRelation(id: string): NullSafeUnion<Identified, CONTENT> | undefined;
-    getRelations(id: string): NullSafeUnion<Identified, CONTENT>[];
-    setRelations(subject: {
-        [from in A]: string;
-    } | {
-        [to in B]: string;
-    }, relations: NullSafeUnion<Identified, CONTENT>[]): Join<CONTENT, A, B>;
-    set(relation: {
-        [key in A | B]: string;
-    }, ...rest: NullSafeRest<CONTENT>): Join<CONTENT, A, B>;
-    remove(relation: Partial<Record<A | B, string>>): Join<CONTENT, A, B>;
+interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
+    readonly relations: [string, string[]][];
+    readonly contents: [string, Content][];
 }
-
-type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
-    key: string;
-    type: `atom_family`;
-    subject: Subject<AtomToken<T>>;
-};
-
-type Logger = Pick<Console, `error` | `info` | `warn`>;
-
-type TransactionToken<_> = {
-    key: string;
-    type: `transaction`;
-    __brand?: _;
-};
-type TransactionUpdate<ƒ extends ƒn> = {
-    key: string;
-    atomUpdates: KeyedStateUpdate<unknown>[];
-    params: Parameters<ƒ>;
-    output: ReturnType<ƒ>;
-};
-
-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;
-};
-
-type TimelineToken = {
-    key: string;
-    type: `timeline`;
-};
-type TimelineUpdate = TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate;
-
-type AtomToken<_> = {
-    key: string;
-    type: `atom`;
-    family?: FamilyMetadata;
-    __brand?: _;
-};
-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;
-};
-
-type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
-interface Store {
-    atoms: Map<string, Atom<any>>;
-    atomsThatAreDefault: Set<string>;
-    readonlySelectors: Map<string, ReadonlySelector<any>>;
-    selectorAtoms: Join<null, `selectorKey`, `atomKey`>;
-    selectorGraph: Join<{
-        source: string;
-    }>;
-    selectors: Map<string, Selector<any>>;
-    timelineAtoms: Join<null, `timelineKey`, `atomKey`>;
-    timelines: Map<string, Timeline>;
-    transactions: Map<string, Transaction<any>>;
-    valueMap: Map<string, any>;
-    subject: {
-        atomCreation: Subject<AtomToken<unknown>>;
-        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<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;
-    };
+interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
+    readonly between: [a: ASide, b: BSide];
+    readonly cardinality: Cardinality;
 }
-
-type Atom<T> = {
-    key: string;
-    type: `atom`;
-    family?: FamilyMetadata;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    default: T;
+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: (g: any) => 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;
+}
 
 type OperationProgress = {
     open: false;
@@ -186,6 +79,14 @@ type OperationProgress = {
     token: StateToken<any>;
 };
 
+type Subscriber<T> = (value: T) => void;
+declare class Subject<T> {
+    subscribers: Map<string, Subscriber<T>>;
+    subscribe(key: string, subscriber: Subscriber<T>): () => void;
+    private unsubscribe;
+    next(value: T): void;
+}
+
 type Selector<T> = {
     key: string;
     type: `selector`;
@@ -210,20 +111,11 @@ type ReadonlySelector<T> = {
     get: () => T;
 };
 
-type Subscriber<T> = (value: T) => void;
-declare class Subject<T> {
-    subscribers: Subscriber<T>[];
-    subscribe(subscriber: Subscriber<T>): {
-        unsubscribe: () => void;
-    };
-    private unsubscribe;
-    next(value: T): void;
-}
-
 type TimelineAtomUpdate = StateUpdate<unknown> & {
     key: string;
     type: `atom_update`;
     timestamp: number;
+    family?: FamilyMetadata;
 };
 type TimelineSelectorUpdate = {
     key: string;
@@ -237,9 +129,10 @@ type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
     timestamp: number;
 };
 type Timeline = {
+    type: `timeline`;
     key: string;
     at: number;
-    timeTraveling: boolean;
+    timeTraveling: `into_future` | `into_past` | null;
     history: TimelineUpdate[];
     selectorTime: number | null;
     transactionKey: string | null;
@@ -265,20 +158,62 @@ type TransactionIdle = {
 };
 type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
 
-type AtomTokenIndex = StateTokenIndex<AtomToken$1<unknown>>;
+type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
+declare class Store {
+    valueMap: Map<string, any>;
+    atoms: Map<string, Atom<any>>;
+    selectors: Map<string, Selector<any>>;
+    readonlySelectors: Map<string, ReadonlySelector<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>;
+        operationStatus: Subject<OperationProgress>;
+    };
+    operation: OperationProgress;
+    transactionStatus: TransactionStatus<ƒn>;
+    config: {
+        name: string;
+        logger: Logger | null;
+        logger__INTERNAL: Logger;
+    };
+    constructor(name: string, store?: Store | null);
+}
+
+type Atom<T> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    default: T;
+};
+
+type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>;
 
-type FamilyNode<Token extends AtomToken$1<unknown> | ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>> = {
+type FamilyNode<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = {
     key: string;
     familyMembers: Record<string, Token>;
 };
-type StateTokenIndex<Token extends AtomToken$1<unknown> | ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>> = Record<string, FamilyNode<Token> | Token>;
+type StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
 
-type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>>;
+type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
 
 type ClassSignature = abstract new (...args: any) => any;
 
-type RefinementStrategy = ClassSignature | Refinement<unknown, any>;
-type Supported<Refine extends RefinementStrategy> = Refine extends Refinement<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
+type RefinementStrategy = ClassSignature | Refinement$1<unknown, any>;
+type Supported<Refine extends RefinementStrategy> = Refine extends Refinement$1<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
 type RefinementSupport = Record<string, RefinementStrategy>;
 declare class Refinery<SupportedTypes extends RefinementSupport> {
     supported: SupportedTypes;
@@ -318,17 +253,17 @@ declare class Differ<Leaf extends Record<string, any>, Tree extends Record<strin
 
 declare const AtomIODevtools: () => JSX.Element;
 
-declare const atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
-declare const selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
-declare const transactionIndex: ReadonlySelectorToken<TransactionToken<ƒn>[]>;
-declare const findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate<ƒn>[]>;
-declare const timelineIndex: ReadonlySelectorToken<TimelineToken[]>;
-declare const findTimelineState: ReadonlySelectorFamily<Timeline>;
-declare const devtoolsAreOpenState: AtomToken<boolean>;
+declare const atomIndex: atom_io.ReadonlySelectorToken<AtomTokenIndex>;
+declare const selectorIndex: atom_io.ReadonlySelectorToken<SelectorTokenIndex>;
+declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<atom_io.ƒn>[]>;
+declare const findTransactionLogState: atom_io.ReadonlySelectorFamily<atom_io.TransactionUpdate<atom_io.ƒn>[]>;
+declare const timelineIndex: atom_io.ReadonlySelectorToken<atom_io.TimelineToken[]>;
+declare const findTimelineState: atom_io.ReadonlySelectorFamily<Timeline>;
+declare const devtoolsAreOpenState: atom_io.AtomToken<boolean>;
 type DevtoolsView = `atoms` | `selectors` | `timelines` | `transactions`;
-declare const devtoolsViewSelectionState: AtomToken<DevtoolsView>;
-declare const devtoolsViewOptionsState: AtomToken<DevtoolsView[]>;
-declare const findViewIsOpenState: AtomFamily<boolean, string>;
+declare const devtoolsViewSelectionState: atom_io.AtomToken<DevtoolsView>;
+declare const devtoolsViewOptionsState: atom_io.AtomToken<DevtoolsView[]>;
+declare const findViewIsOpenState: atom_io.AtomFamily<boolean, string>;
 declare const primitiveRefinery: Refinery<{
     number: (input: unknown) => input is number;
     string: (input: unknown) => input is string;