atom.io 0.6.6 → 0.6.8

package/introspection/dist/index.d.mts

@@ -0,0 +1,272 @@
+import { AtomToken as AtomToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, SelectorToken as SelectorToken$1, __INTERNAL__, TransactionToken as TransactionToken$1, ReadonlySelectorFamily, TransactionUpdate as TransactionUpdate$1, TimelineToken as TimelineToken$1 } from 'atom.io';
+import { Refinement } from 'fp-ts/Refinement';
+
+type ƒn = (...parameters: any[]) => any;
+
+type AtomTokenIndex = StateTokenIndex<AtomToken$1<unknown>>;
+
+type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>>;
+
+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 Identified = {
+    id: string;
+};
+
+declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
+type RelationType = typeof RELATION_TYPES[number];
+type RelationData<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
+    contents: Object$1<string, CONTENT>;
+    relations: Object$1<string, string[]>;
+    relationType: RelationType;
+    a: A;
+    b: B;
+};
+type IsRelationDataOptions<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
+    from?: A;
+    to?: B;
+    isContent?: (json: Serializable) => json is CONTENT;
+};
+
+type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
+type NullSafeRest<MaybeArg, IfArg = MaybeArg> = MaybeArg extends null ? [] | [undefined] : [IfArg];
+
+declare class Join<CONTENT extends Object$1 | 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 Object$1 | null, A extends string, B extends string>(json: Serializable, 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>;
+}
+
+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 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;
+    };
+}
+
+type Atom<T> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    default: T;
+};
+
+type OperationProgress = {
+    open: false;
+} | {
+    open: true;
+    done: Set<string>;
+    prev: Map<string, any>;
+    time: number;
+    token: StateToken<any>;
+};
+
+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;
+};
+
+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;
+};
+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 = {
+    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`>;
+};
+
+type Transaction<ƒ extends ƒn> = {
+    key: string;
+    type: `transaction`;
+    install: (store: Store) => void;
+    subject: Subject<TransactionUpdate<ƒ>>;
+    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+};
+
+type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
+    phase: `applying` | `building`;
+    time: number;
+    core: StoreCore;
+};
+type TransactionIdle = {
+    phase: `idle`;
+};
+type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
+
+declare const attachIntrospectionStates: (store?: __INTERNAL__.Store) => {
+    atomIndex: ReadonlySelectorToken$1<AtomTokenIndex>;
+    selectorIndex: ReadonlySelectorToken$1<SelectorTokenIndex>;
+    transactionIndex: ReadonlySelectorToken$1<TransactionToken$1<ƒn>[]>;
+    findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate$1<ƒn>[]>;
+    timelineIndex: ReadonlySelectorToken$1<TimelineToken$1[]>;
+    findTimelineState: ReadonlySelectorFamily<Timeline>;
+};
+
+type FamilyNode<Token extends AtomToken$1<unknown> | ReadonlySelectorToken$1<unknown> | SelectorToken$1<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>;
+
+export { FamilyNode, StateTokenIndex, attachIntrospectionStates };

package/introspection/dist/index.d.ts

@@ -0,0 +1,272 @@
+import { AtomToken as AtomToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, SelectorToken as SelectorToken$1, __INTERNAL__, TransactionToken as TransactionToken$1, ReadonlySelectorFamily, TransactionUpdate as TransactionUpdate$1, TimelineToken as TimelineToken$1 } from 'atom.io';
+import { Refinement } from 'fp-ts/Refinement';
+
+type ƒn = (...parameters: any[]) => any;
+
+type AtomTokenIndex = StateTokenIndex<AtomToken$1<unknown>>;
+
+type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken$1<unknown> | SelectorToken$1<unknown>>;
+
+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 Identified = {
+    id: string;
+};
+
+declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
+type RelationType = typeof RELATION_TYPES[number];
+type RelationData<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
+    contents: Object$1<string, CONTENT>;
+    relations: Object$1<string, string[]>;
+    relationType: RelationType;
+    a: A;
+    b: B;
+};
+type IsRelationDataOptions<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
+    from?: A;
+    to?: B;
+    isContent?: (json: Serializable) => json is CONTENT;
+};
+
+type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
+type NullSafeRest<MaybeArg, IfArg = MaybeArg> = MaybeArg extends null ? [] | [undefined] : [IfArg];
+
+declare class Join<CONTENT extends Object$1 | 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 Object$1 | null, A extends string, B extends string>(json: Serializable, 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>;
+}
+
+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 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;
+    };
+}
+
+type Atom<T> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    default: T;
+};
+
+type OperationProgress = {
+    open: false;
+} | {
+    open: true;
+    done: Set<string>;
+    prev: Map<string, any>;
+    time: number;
+    token: StateToken<any>;
+};
+
+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;
+};
+
+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;
+};
+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 = {
+    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`>;
+};
+
+type Transaction<ƒ extends ƒn> = {
+    key: string;
+    type: `transaction`;
+    install: (store: Store) => void;
+    subject: Subject<TransactionUpdate<ƒ>>;
+    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+};
+
+type TransactionUpdateInProgress<ƒ extends ƒn> = TransactionUpdate<ƒ> & {
+    phase: `applying` | `building`;
+    time: number;
+    core: StoreCore;
+};
+type TransactionIdle = {
+    phase: `idle`;
+};
+type TransactionStatus<ƒ extends ƒn> = TransactionIdle | TransactionUpdateInProgress<ƒ>;
+
+declare const attachIntrospectionStates: (store?: __INTERNAL__.Store) => {
+    atomIndex: ReadonlySelectorToken$1<AtomTokenIndex>;
+    selectorIndex: ReadonlySelectorToken$1<SelectorTokenIndex>;
+    transactionIndex: ReadonlySelectorToken$1<TransactionToken$1<ƒn>[]>;
+    findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate$1<ƒn>[]>;
+    timelineIndex: ReadonlySelectorToken$1<TimelineToken$1[]>;
+    findTimelineState: ReadonlySelectorFamily<Timeline>;
+};
+
+type FamilyNode<Token extends AtomToken$1<unknown> | ReadonlySelectorToken$1<unknown> | SelectorToken$1<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>;
+
+export { FamilyNode, StateTokenIndex, attachIntrospectionStates };

package/introspection/dist/index.js

@@ -165,15 +165,53 @@ var attachSelectorIndex = (store = import_atom2.__INTERNAL__.IMPLICIT.STORE) =>
 
 // ../src/introspection/attach-timeline-family.ts
 var import_atom3 = require("atom.io");
+
+// ../../anvl/reactivity/subject.ts
+var Subject = class {
+  constructor() {
+    this.subscribers = [];
+  }
+  subscribe(subscriber) {
+    this.subscribers.push(subscriber);
+    const unsubscribe = () => this.unsubscribe(subscriber);
+    return { unsubscribe };
+  }
+  unsubscribe(subscriber) {
+    const subscriberIndex = this.subscribers.indexOf(subscriber);
+    if (subscriberIndex !== -1) {
+      this.subscribers.splice(subscriberIndex, 1);
+    }
+  }
+  next(value) {
+    for (const subscriber of this.subscribers) {
+      subscriber(value);
+    }
+  }
+};
+
+// ../src/introspection/attach-timeline-family.ts
 var attachTimelineFamily = (store = import_atom3.__INTERNAL__.IMPLICIT.STORE) => {
   const findTimelineLogState__INTERNAL = import_atom3.__INTERNAL__.atomFamily__INTERNAL(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log (Internal)`,
-      default: (key) => store.timelines.get(key),
+      default: (key) => {
+        var _a;
+        return (_a = store.timelines.get(key)) != null ? _a : {
+          key: ``,
+          at: 0,
+          timeTraveling: null,
+          history: [],
+          selectorTime: null,
+          transactionKey: null,
+          install: () => {
+          },
+          subject: new Subject()
+        };
+      },
       effects: (key) => [
         ({ setSelf }) => {
           const tl = store.timelines.get(key);
-          tl.subject.subscribe((_) => {
+          tl == null ? void 0 : tl.subject.subscribe((_) => {
             if (store.operation.open === true) {
               const subscription = store.subject.operationStatus.subscribe(
                 (operationStatus) => {
@@ -274,7 +312,7 @@ var attachTransactionLogs = (store = import_atom6.__INTERNAL__.IMPLICIT.STORE) =
       effects: (key) => [
         ({ setSelf }) => {
           const tx = store.transactions.get(key);
-          tx.subject.subscribe((transactionUpdate) => {
+          tx == null ? void 0 : tx.subject.subscribe((transactionUpdate) => {
             if (transactionUpdate.key === key) {
               setSelf((state) => [...state, transactionUpdate]);
             }