atom.io 0.3.0 → 0.3.1

package/README.md

@@ -14,19 +14,17 @@
 - [x] atom default as function
 - [x] check whether an atom is "default" (never set)
 - [x] customizable logging
+- [x] subscribe to transactions
+- [x] timelines
+- [x] subscribe to families
 
 # atom.io
 ## upcoming features
-- [ ] subscribe to token creation
-- [ ] subscribe to transactions
-- [ ] timelines
+- [ ] subscribe to creation of all tokens
 - [ ] resettable atoms
 - [ ] resettable selectors
 - [ ] store observation api
 
-## fixes & improvements
-- [ ] apply and emit transactions all at once
-
 ## documentation
 - [ ] document atom and selector families
 - [ ] document atom and selector

package/dist/index.d.ts

@@ -138,19 +138,16 @@ 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 Logger = Pick<Console, `error` | `info` | `warn`>;
-declare const LOG_LEVELS: ReadonlyArray<keyof Logger>;
-declare const setLogLevel: (preferredLevel: `error` | `info` | `warn` | null, store?: Store) => void;
-declare const useLogger: (logger: Logger, store?: Store) => void;
-
 type OperationProgress = {
     open: false;
 } | {
     open: true;
     done: Set<string>;
     prev: Hamt<any, string>;
+    time: number;
+    token: StateToken<any>;
 };
-declare const openOperation: (store: Store) => void;
+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;
@@ -170,10 +167,11 @@ type Transactors = {
     set: <S>(state: StateToken<S>, newValue: S | ((oldValue: S) => S)) => void;
 };
 type ReadonlyTransactors = Pick<Transactors, `get`>;
-type Action<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Read<ƒ extends ƒn> = (transactors: ReadonlyTransactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+type Write<ƒ extends ƒn> = (transactors: Transactors, ...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
 type TransactionOptions<ƒ extends ƒn> = {
     key: string;
-    do: Action<ƒ>;
+    do: Write<ƒ>;
 };
 type Transaction<ƒ extends ƒn> = {
     key: string;
@@ -231,8 +229,13 @@ type Timeline = {
     next: () => void;
     prev: () => void;
 };
-type TimelineStateUpdate = KeyedStateUpdate<unknown> & {
-    type: `state_update`;
+type TimelineAtomUpdate = KeyedStateUpdate<unknown> & {
+    type: `atom_update`;
+};
+type TimelineSelectorUpdate = {
+    key: string;
+    type: `selector_update`;
+    atomUpdates: TimelineAtomUpdate[];
 };
 type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
     type: `transaction_update`;
@@ -240,7 +243,7 @@ type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 type TimelineData = {
     at: number;
     timeTraveling: boolean;
-    history: (TimelineStateUpdate | TimelineTransactionUpdate)[];
+    history: (TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate)[];
 };
 declare function timeline__INTERNAL(options: TimelineOptions, store?: Store): TimelineToken;
 declare const redo__INTERNAL: (token: TimelineToken, store?: Store) => void;
@@ -276,8 +279,6 @@ declare const target: (store?: Store) => StoreCore;
 type index_Atom<T> = Atom<T>;
 declare const index_IMPLICIT: typeof IMPLICIT;
 type index_KeyedStateUpdate<T> = KeyedStateUpdate<T>;
-declare const index_LOG_LEVELS: typeof LOG_LEVELS;
-type index_Logger = Logger;
 type index_OperationProgress = OperationProgress;
 type index_ReadonlySelector<T> = ReadonlySelector<T>;
 type index_Selector<T> = Selector<T>;
@@ -285,8 +286,9 @@ type index_Store = Store;
 type index_StoreCore = StoreCore;
 declare const index_TRANSACTION_PHASES: typeof TRANSACTION_PHASES;
 type index_Timeline = Timeline;
+type index_TimelineAtomUpdate = TimelineAtomUpdate;
 type index_TimelineData = TimelineData;
-type index_TimelineStateUpdate = TimelineStateUpdate;
+type index_TimelineSelectorUpdate = TimelineSelectorUpdate;
 type index_TimelineTransactionUpdate = TimelineTransactionUpdate;
 type index_TransactionIdle = TransactionIdle;
 type index_TransactionPhase = TransactionPhase;
@@ -329,7 +331,6 @@ declare const index_registerSelector: typeof registerSelector;
 declare const index_selectorFamily__INTERNAL: typeof selectorFamily__INTERNAL;
 declare const index_selector__INTERNAL: typeof selector__INTERNAL;
 declare const index_setAtomState: typeof setAtomState;
-declare const index_setLogLevel: typeof setLogLevel;
 declare const index_setSelectorState: typeof setSelectorState;
 declare const index_setState__INTERNAL: typeof setState__INTERNAL;
 declare const index_storeAtom: typeof storeAtom;
@@ -345,15 +346,12 @@ declare const index_transaction__INTERNAL: typeof transaction__INTERNAL;
 declare const index_undoTransactionUpdate: typeof undoTransactionUpdate;
 declare const index_undo__INTERNAL: typeof undo__INTERNAL;
 declare const index_updateSelectorAtoms: typeof updateSelectorAtoms;
-declare const index_useLogger: typeof useLogger;
 declare const index_withdraw: typeof withdraw;
 declare namespace index {
   export {
     index_Atom as Atom,
     index_IMPLICIT as IMPLICIT,
     index_KeyedStateUpdate as KeyedStateUpdate,
-    index_LOG_LEVELS as LOG_LEVELS,
-    index_Logger as Logger,
     index_OperationProgress as OperationProgress,
     index_ReadonlySelector as ReadonlySelector,
     index_Selector as Selector,
@@ -361,8 +359,9 @@ declare namespace index {
     index_StoreCore as StoreCore,
     index_TRANSACTION_PHASES as TRANSACTION_PHASES,
     index_Timeline as Timeline,
+    index_TimelineAtomUpdate as TimelineAtomUpdate,
     index_TimelineData as TimelineData,
-    index_TimelineStateUpdate as TimelineStateUpdate,
+    index_TimelineSelectorUpdate as TimelineSelectorUpdate,
     index_TimelineTransactionUpdate as TimelineTransactionUpdate,
     index_TransactionIdle as TransactionIdle,
     index_TransactionPhase as TransactionPhase,
@@ -405,7 +404,6 @@ declare namespace index {
     index_selectorFamily__INTERNAL as selectorFamily__INTERNAL,
     index_selector__INTERNAL as selector__INTERNAL,
     index_setAtomState as setAtomState,
-    index_setLogLevel as setLogLevel,
     index_setSelectorState as setSelectorState,
     index_setState__INTERNAL as setState__INTERNAL,
     index_storeAtom as storeAtom,
@@ -421,23 +419,27 @@ declare namespace index {
     index_undoTransactionUpdate as undoTransactionUpdate,
     index_undo__INTERNAL as undo__INTERNAL,
     index_updateSelectorAtoms as updateSelectorAtoms,
-    index_useLogger as useLogger,
     index_withdraw as withdraw,
   };
 }
 
+type Logger = Pick<Console, `error` | `info` | `warn`>;
+declare const LOG_LEVELS: ReadonlyArray<keyof Logger>;
+declare const setLogLevel: (preferredLevel: `error` | `info` | `warn` | null, store?: Store) => void;
+declare const useLogger: (logger: Logger, store?: Store) => void;
+
 type SelectorOptions<T> = {
     key: string;
-    get: (readonlyTransactors: ReadonlyTransactors) => T;
-    set: (transactors: Transactors, newValue: T) => void;
+    get: Read<() => T>;
+    set: Write<(newValue: T) => void>;
 };
 type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>;
 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) => (readonlyTransactors: ReadonlyTransactors) => T;
-    set: (key: K) => (transactors: Transactors, newValue: T) => void;
+    get: (key: K) => Read<() => T>;
+    set: (key: K) => Write<(newValue: T) => void>;
 };
 type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<SelectorFamilyOptions<T, K>, `set`>;
 type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
@@ -453,6 +455,15 @@ type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K
 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>;
 
+type StateUpdate<T> = {
+    newValue: 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);
+type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
+declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, store?: Store) => (() => void);
+
 type TimelineToken = {
     key: string;
     type: `timeline`;
@@ -465,15 +476,6 @@ declare const timeline: (options: TimelineOptions) => TimelineToken;
 declare const redo: (token: TimelineToken) => void;
 declare const undo: (token: TimelineToken) => void;
 
-type StateUpdate<T> = {
-    newValue: 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);
-type TransactionUpdateHandler<ƒ extends ƒn> = (data: TransactionUpdate<ƒ>) => void;
-declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, store?: Store) => (() => void);
-
 type AtomToken<_> = {
     key: string;
     type: `atom`;
@@ -502,4 +504,4 @@ declare const getState: <T>(token: ReadonlyValueToken<T> | StateToken<T>, store?
 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;
 
-export { Action, AtomEffect, AtomFamily, AtomFamilyOptions, AtomOptions, AtomToken, Effectors, FamilyMetadata, ReadonlySelectorFamily, ReadonlySelectorFamilyOptions, ReadonlySelectorOptions, ReadonlyTransactors, ReadonlyValueToken, SelectorFamily, SelectorFamilyOptions, SelectorOptions, SelectorToken, Serializable, StateToken, StateUpdate, TimelineOptions, TimelineToken, Transaction, TransactionOptions, TransactionToken, TransactionUpdateHandler, Transactors, UpdateHandler, 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, 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 };