atom.io 0.3.1 → 0.4.1

package/README.md

@@ -20,10 +20,15 @@
 
 # atom.io
 ## upcoming features
-- [ ] subscribe to creation of all tokens
+- [ ] store observation api
+- [x] subscribe to creation of atom tokens
+- [x] subscribe to creation of selector tokens
+- [x] subscribe to creation of readonly selector tokens
+- [ ] subscribe to creation of transaction tokens
+- [ ] subscribe to creation of timeline tokens
+- [ ] subscribe to changes in store configuration
 - [ ] resettable atoms
 - [ ] resettable selectors
-- [ ] store observation api
 
 ## documentation
 - [ ] document atom and selector families
@@ -32,8 +37,11 @@
 
 # /react
 ## features
-- [x] useSubject
 - [x] useStore
+- [x] useI, useO, useIO
+- [ ] useTimeline
+- [ ] useStoreIndex
+- [ ] useTransactionIO 
 
 # /effects
 ## features

package/dist/index.d.ts

@@ -16,22 +16,28 @@ type Identified = {
 
 declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
 type RelationType = (typeof RELATION_TYPES)[number];
-type RelationData<CONTENT extends JsonObj | null = null> = {
+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 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> implements RelationData<CONTENT> {
+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>>);
-    toJSON(): RelationData<CONTENT>;
-    static fromJSON<CONTENT extends JsonObj | null = null>(json: Json, isContent?: Refinement<unknown, CONTENT>): Join<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, isContent?: Refinement<unknown, CONTENT>, a?: A, b?: 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>;
     getRelatedId(id: string): string | undefined;
     getRelatedIds(id: string): string[];
     getContent(idA: string, idB: string): CONTENT | undefined;
@@ -39,9 +45,15 @@ declare class Join<CONTENT extends JsonObj | null = null> implements RelationDat
     getRelationRecord(id: string): Record<string, CONTENT>;
     getRelation(id: string): NullSafeUnion<Identified, CONTENT> | undefined;
     getRelations(id: string): NullSafeUnion<Identified, CONTENT>[];
-    setRelations(id: string, relations: NullSafeUnion<Identified, CONTENT>[]): Join<CONTENT>;
-    set(idA: string, idB: string, ...rest: NullSafeRest<CONTENT>): Join<CONTENT>;
-    remove(idA: string, idB?: string): Join<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 StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
@@ -49,16 +61,22 @@ interface Store {
     atoms: Hamt<Atom<any>, string>;
     atomsThatAreDefault: Set<string>;
     readonlySelectors: Hamt<ReadonlySelector<any>, string>;
-    selectorAtoms: Join;
+    selectorAtoms: Join<null, `selectorKey`, `atomKey`>;
     selectorGraph: Join<{
         source: string;
     }>;
     selectors: Hamt<Selector<any>, string>;
     timelines: Hamt<Timeline, string>;
-    timelineAtoms: Join;
+    timelineAtoms: Join<null, `timelineKey`, `atomKey`>;
     timelineStore: Hamt<TimelineData, string>;
     transactions: Hamt<Transaction<any>, string>;
     valueMap: Hamt<any, string>;
+    subject: {
+        atomCreation: Rx.Subject<AtomToken<unknown>>;
+        selectorCreation: Rx.Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
+        transactionCreation: Rx.Subject<TransactionToken<unknown>>;
+        timelineCreation: Rx.Subject<TimelineToken>;
+    };
     operation: OperationProgress;
     transactionStatus: TransactionStatus<ƒn>;
     config: {
@@ -118,19 +136,19 @@ declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: Se
 declare function selectorFamily__INTERNAL<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): ReadonlySelectorFamily<T, K>;
 
 declare const computeSelectorState: <T>(selector: ReadonlySelector<T> | Selector<T>) => T;
-declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown>;
+declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
 declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
 declare function withdraw<T>(token: StateToken<T>, store: Store): Atom<T> | Selector<T>;
-declare function withdraw<T>(token: ReadonlyValueToken<T>, store: Store): ReadonlySelector<T>;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
 declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends ƒn ? T : never>;
-declare function withdraw<T>(token: ReadonlyValueToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T>;
+declare function withdraw<T>(token: ReadonlySelectorToken<T> | StateToken<T>, store: Store): Atom<T> | ReadonlySelector<T> | Selector<T>;
 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>): ReadonlyValueToken<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>): ReadonlyValueToken<T> | StateToken<T>;
+declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlySelectorToken<T> | StateToken<T>;
 declare const getState__INTERNAL: <T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>, store?: Store) => T;
 
 declare const isAtomDefault: (key: string, store?: Store) => boolean;
@@ -138,6 +156,37 @@ declare const markAtomAsDefault: (key: string, store?: Store) => void;
 declare const markAtomAsNotDefault: (key: string, store?: Store) => void;
 declare const isSelectorDefault: (key: string, store?: Store) => boolean;
 
+type StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = Record<string, Token | {
+    key: string;
+    familyMembers: Record<string, Token>;
+}>;
+type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>;
+type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
+declare const attachMetaAtoms: (store?: Store) => ReadonlySelectorToken<AtomTokenIndex>;
+declare const attachMetaSelectors: (store?: Store) => ReadonlySelectorToken<SelectorTokenIndex>;
+
+declare const attachMetaState: (store?: Store) => {
+    atomTokenIndexState: ReadonlySelectorToken<AtomTokenIndex>;
+    selectorTokenIndexState: ReadonlySelectorToken<SelectorTokenIndex>;
+};
+
+type index$1_AtomTokenIndex = AtomTokenIndex;
+type index$1_SelectorTokenIndex = SelectorTokenIndex;
+type index$1_StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = StateTokenIndex<Token>;
+declare const index$1_attachMetaAtoms: typeof attachMetaAtoms;
+declare const index$1_attachMetaSelectors: typeof attachMetaSelectors;
+declare const index$1_attachMetaState: typeof attachMetaState;
+declare namespace index$1 {
+  export {
+    index$1_AtomTokenIndex as AtomTokenIndex,
+    index$1_SelectorTokenIndex as SelectorTokenIndex,
+    index$1_StateTokenIndex as StateTokenIndex,
+    index$1_attachMetaAtoms as attachMetaAtoms,
+    index$1_attachMetaSelectors as attachMetaSelectors,
+    index$1_attachMetaState as attachMetaState,
+  };
+}
+
 type OperationProgress = {
     open: false;
 } | {
@@ -163,7 +212,7 @@ declare const hasKeyBeenUsed: (key: string, store?: Store) => boolean;
 
 type ƒn = (...parameters: any[]) => any;
 type Transactors = {
-    get: <S>(state: ReadonlyValueToken<S> | StateToken<S>) => S;
+    get: <S>(state: ReadonlySelectorToken<S> | StateToken<S>) => S;
     set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
 };
 type ReadonlyTransactors = Pick<Transactors, `get`>;
@@ -179,6 +228,7 @@ type Transaction<ƒ extends ƒn> = {
     run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
     subject: Rx.Subject<TransactionUpdate<ƒ>>;
 };
+type TransactionIO<Token extends TransactionToken<any>> = Token extends TransactionToken<infer ƒ> ? ƒ : never;
 declare function transaction<ƒ extends ƒn>(options: TransactionOptions<ƒ>): TransactionToken<ƒ>;
 declare const runTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, store?: Store) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
 
@@ -203,13 +253,13 @@ type ReadonlySelector<T> = {
     }>;
     get: () => T;
 };
-declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown>)[];
-declare const traceSelectorAtoms: (selectorKey: string, dependency: ReadonlyValueToken<unknown> | StateToken<unknown>, store: Store) => AtomToken<unknown>[];
+declare const lookupSelectorSources: (key: string, store: Store) => (AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>)[];
+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: ReadonlyValueToken<unknown> | StateToken<unknown>, store: Store) => void;
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>, store: Store) => void;
 declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
 declare function selector__INTERNAL<T>(options: SelectorOptions<T>, family?: FamilyMetadata, store?: Store): SelectorToken<T>;
-declare function selector__INTERNAL<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata, store?: Store): ReadonlyValueToken<T>;
+declare function selector__INTERNAL<T>(options: ReadonlySelectorOptions<T>, family?: FamilyMetadata, store?: Store): ReadonlySelectorToken<T>;
 
 declare const evictDownStream: <T>(state: Atom<T>, store?: Store) => void;
 declare const setAtomState: <T>(atom: Atom<T>, next: T | ((oldValue: T) => T), store?: Store) => void;
@@ -223,6 +273,9 @@ declare const subscribeToRootAtoms: <T>(state: ReadonlySelector<T> | Selector<T>
     unsubscribe: () => void;
 }[] | null;
 
+declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
+
 type Timeline = {
     key: string;
     type: `timeline`;
@@ -244,10 +297,10 @@ type TimelineData = {
     at: number;
     timeTraveling: boolean;
     history: (TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate)[];
+    selectorTime: number | null;
+    transactionKey: string | null;
 };
 declare function timeline__INTERNAL(options: TimelineOptions, store?: Store): TimelineToken;
-declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
-declare const undo__INTERNAL: (token: TimelineToken, store?: Store) => void;
 
 declare const TRANSACTION_PHASES: readonly ["idle", "building", "applying"];
 type TransactionPhase = (typeof TRANSACTION_PHASES)[number];
@@ -352,6 +405,7 @@ declare namespace index {
     index_Atom as Atom,
     index_IMPLICIT as IMPLICIT,
     index_KeyedStateUpdate as KeyedStateUpdate,
+    index$1 as META,
     index_OperationProgress as OperationProgress,
     index_ReadonlySelector as ReadonlySelector,
     index_Selector as Selector,
@@ -434,8 +488,8 @@ type SelectorOptions<T> = {
     set: Write<(newValue: T) => void>;
 };
 type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>;
+declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 declare function selector<T>(options: SelectorOptions<T>): SelectorToken<T>;
-declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlyValueToken<T>;
 type SelectorFamilyOptions<T, K extends Serializable> = {
     key: string;
     get: (key: K) => Read<() => T>;
@@ -447,10 +501,10 @@ type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => Sel
     type: `selector_family`;
     subject: Rx.Subject<SelectorToken<T>>;
 };
-type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlyValueToken<T>) & {
+type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
-    subject: Rx.Subject<ReadonlyValueToken<T>>;
+    subject: Rx.Subject<ReadonlySelectorToken<T>>;
 };
 declare function selectorFamily<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>): SelectorFamily<T, K>;
 declare function selectorFamily<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamily<T, K>;
@@ -460,7 +514,7 @@ type StateUpdate<T> = {
     oldValue: T;
 };
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
-declare const subscribe: <T>(token: ReadonlyValueToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, store?: Store) => (() => void);
+declare const subscribe: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, handleUpdate: UpdateHandler<T>, store?: Store) => (() => void);
 type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
 declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, store?: Store) => (() => void);
 
@@ -487,7 +541,7 @@ type SelectorToken<_> = {
     family?: FamilyMetadata;
 };
 type StateToken<T> = AtomToken<T> | SelectorToken<T>;
-type ReadonlyValueToken<_> = {
+type ReadonlySelectorToken<_> = {
     key: string;
     type: `readonly_selector`;
     family?: FamilyMetadata;
@@ -500,8 +554,8 @@ type TransactionToken<_> = {
     key: string;
     type: `transaction`;
 };
-declare const getState: <T>(token: ReadonlyValueToken<T> | StateToken<T>, store?: Store) => T;
+declare const getState: <T>(token: ReadonlySelectorToken<T> | StateToken<T>, store?: Store) => T;
 declare const setState: <T, New extends T>(token: StateToken<T>, value: New | ((oldValue: T) => New), store?: Store) => void;
-declare const isDefault: (token: ReadonlyValueToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
+declare const isDefault: (token: ReadonlySelectorToken<unknown> | StateToken<unknown>, store?: Store) => boolean;
 
-export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlyTransactors, ReadonlyValueToken, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };
+export { AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, LOG_LEVELS, Logger, Read, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlySelectorToken, ReadonlyTransactors, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionIO, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, Write, index as __INTERNAL__, atom, atomFamily, getState, isDefault, redo, runTransaction, selector, selectorFamily, setLogLevel, setState, subscribe, subscribeToTransaction, timeline, transaction, undo, useLogger, ƒn };