atom.io 0.1.0 → 0.2.0

package/README.md

@@ -1,4 +1,4 @@
-## MVP
+## features
 - [x] atoms and selectors
 - [x] implicit store
 - [x] readonly selectors
@@ -12,25 +12,25 @@
 - [x] atom effects
 - [x] transactions
 
+
 # atom.io
-## features
-- [ ] atom default as function
-- [ ] async effects
+## upcoming features
+- [x] "lazy mode": only propagate updates downstream to selectors with an active subscription
+- [x] async effects
+- [x] atom default as function
+- [x] check whether an atom is "default" (never set)
+- [ ] timelines
 - [ ] resettable atoms
 - [ ] resettable selectors
 - [ ] subscribe to transactions
 - [ ] subscribe to token creation
 - [ ] logging levels (debug, info, warn, error)
 - [ ] store observation api
-- [ ] "lazy mode": only propagate updates downstream to selectors with an active subscription
-- [ ] optional default value for atoms
-- [ ] optional state keys
+
 ## fixes & improvements
-- [ ] refactor selector dependencies to be asymmetrical
-      just include the id of the leader in the relation between the leader and the follower
-      this will permit us to rebuild the dependency graph on every update
+- [x] refactor selector dependencies to be asymmetrical
+- [ ] tokens explicitly contain the key of their family
 - [ ] apply and emit transactions all at once
-- [ ] trampoline for recursive propagation
 
 ## documentation
 - [ ] document atom and selector families

package/dist/{index-3b5d305c.d.ts → index-9d9f5a05.d.ts}

@@ -46,10 +46,14 @@ declare class Join<CONTENT extends JsonObj | null = null> implements RelationDat
 
 interface Store {
     valueMap: Hamt<any, string>;
-    selectorGraph: Join;
+    selectorGraph: Join<{
+        source: string;
+    }>;
+    selectorAtoms: Join;
+    atoms: Hamt<Atom<any>, string>;
+    atomsAreDefault: Hamt<boolean, string>;
     selectors: Hamt<Selector<any>, string>;
     readonlySelectors: Hamt<ReadonlySelector<any>, string>;
-    atoms: Hamt<Atom<any>, string>;
     operation: {
         open: false;
     } | {
@@ -78,6 +82,7 @@ declare const clearStore: (store?: Store) => void;
 
 declare const getCachedState: <T>(state: Atom<T> | Selector<T> | ReadonlySelector<T>, store?: Store) => T;
 declare const getSelectorState: <T>(selector: Selector<T> | ReadonlySelector<T>) => T;
+declare function lookup(key: string, store: Store): AtomToken<unknown> | ReadonlyValueToken<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>;
@@ -90,16 +95,44 @@ declare function deposit<T>(state: ReadonlySelector<T>): ReadonlyValueToken<T>;
 declare function deposit<T>(state: Atom<T> | ReadonlySelector<T> | Selector<T>): ReadonlyValueToken<T> | StateToken<T>;
 declare const getState__INTERNAL: <T>(state: Atom<T> | Selector<T> | ReadonlySelector<T>, store?: Store) => T;
 
-declare const propagateDown: <T>(state: Atom<T> | Selector<T>, store?: Store) => void;
+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;
 declare const setSelectorState: <T>(selector: Selector<T>, next: T | ((oldValue: T) => T), store?: Store) => void;
-declare const setState__INTERNAL: <T>(token: StateToken<T>, value: T | ((oldValue: T) => T), store?: Store) => void;
+declare const setState__INTERNAL: <T>(state: Atom<T> | Selector<T>, value: T | ((oldValue: T) => T), store?: Store) => void;
+
+declare const isAtomDefault: (key: string, store?: Store) => boolean;
+declare const isSelectorDefault: (key: string, store?: Store) => boolean;
+
+type ƒn = (...parameters: any[]) => any;
+type Transactors = {
+    get: <S>(state: ReadonlyValueToken<S> | StateToken<S>) => S;
+    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 TransactionOptions<ƒ extends ƒn> = {
+    key: string;
+    do: Action<ƒ>;
+};
+declare const transaction: <ƒ extends ƒn>(options: TransactionOptions<ƒ>, store?: Store) => ((...parameters: Parameters<ƒ>) => ReturnType<ƒ>) & {
+    key: string;
+};
+
+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 traceAllSelectorAtoms: (selectorKey: string, store: Store) => AtomToken<unknown>[];
+declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlyValueToken<unknown> | StateToken<unknown>, store: Store) => void;
+declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
+
+declare const subscribeToRootAtoms: <T>(state: Atom<T> | Selector<T> | ReadonlySelector<T>, store?: Store) => {
+    unsubscribe: () => void;
+}[] | null;
 
 declare const startAction: (store: Store) => void;
 declare const finishAction: (store: Store) => void;
 declare const isDone: (key: string, store?: Store) => boolean;
 declare const markDone: (key: string, store?: Store) => void;
-declare const recall: <T>(state: Atom<T> | Selector<T> | ReadonlySelector<T>, store?: Store) => T;
+declare const recallState: <T>(state: Atom<T> | Selector<T> | ReadonlySelector<T>, store?: Store) => T;
 
 declare const finishTransaction: (store: Store) => void;
 declare const startTransaction: (store: Store) => void;
@@ -134,20 +167,29 @@ declare const index_clearStore: typeof clearStore;
 declare const index_configure: typeof configure;
 declare const index_createStore: typeof createStore;
 declare const index_deposit: typeof deposit;
+declare const index_evictDownStream: typeof evictDownStream;
 declare const index_finishAction: typeof finishAction;
 declare const index_finishTransaction: typeof finishTransaction;
 declare const index_getCachedState: typeof getCachedState;
 declare const index_getSelectorState: typeof getSelectorState;
 declare const index_getState__INTERNAL: typeof getState__INTERNAL;
+declare const index_isAtomDefault: typeof isAtomDefault;
 declare const index_isDone: typeof isDone;
+declare const index_isSelectorDefault: typeof isSelectorDefault;
+declare const index_lookup: typeof lookup;
+declare const index_lookupSelectorSources: typeof lookupSelectorSources;
 declare const index_markDone: typeof markDone;
-declare const index_propagateDown: typeof propagateDown;
-declare const index_recall: typeof recall;
+declare const index_recallState: typeof recallState;
+declare const index_registerSelector: typeof registerSelector;
 declare const index_setAtomState: typeof setAtomState;
 declare const index_setSelectorState: typeof setSelectorState;
 declare const index_setState__INTERNAL: typeof setState__INTERNAL;
 declare const index_startAction: typeof startAction;
 declare const index_startTransaction: typeof startTransaction;
+declare const index_subscribeToRootAtoms: typeof subscribeToRootAtoms;
+declare const index_traceAllSelectorAtoms: typeof traceAllSelectorAtoms;
+declare const index_traceSelectorAtoms: typeof traceSelectorAtoms;
+declare const index_updateSelectorAtoms: typeof updateSelectorAtoms;
 declare const index_withdraw: typeof withdraw;
 declare namespace index {
   export {
@@ -161,20 +203,29 @@ declare namespace index {
     index_configure as configure,
     index_createStore as createStore,
     index_deposit as deposit,
+    index_evictDownStream as evictDownStream,
     index_finishAction as finishAction,
     index_finishTransaction as finishTransaction,
     index_getCachedState as getCachedState,
     index_getSelectorState as getSelectorState,
     index_getState__INTERNAL as getState__INTERNAL,
+    index_isAtomDefault as isAtomDefault,
     index_isDone as isDone,
+    index_isSelectorDefault as isSelectorDefault,
+    index_lookup as lookup,
+    index_lookupSelectorSources as lookupSelectorSources,
     index_markDone as markDone,
-    index_propagateDown as propagateDown,
-    index_recall as recall,
+    index_recallState as recallState,
+    index_registerSelector as registerSelector,
     index_setAtomState as setAtomState,
     index_setSelectorState as setSelectorState,
     index_setState__INTERNAL as setState__INTERNAL,
     index_startAction as startAction,
     index_startTransaction as startTransaction,
+    index_subscribeToRootAtoms as subscribeToRootAtoms,
+    index_traceAllSelectorAtoms as traceAllSelectorAtoms,
+    index_traceSelectorAtoms as traceSelectorAtoms,
+    index_updateSelectorAtoms as updateSelectorAtoms,
     index_withdraw as withdraw,
   };
 }
@@ -189,7 +240,7 @@ type Effectors<T> = {
 type AtomEffect<T> = (tools: Effectors<T>) => void;
 type AtomOptions<T> = {
     key: string;
-    default: T;
+    default: T | (() => T);
     effects?: AtomEffect<T>[];
 };
 declare const atom: <T>(options: AtomOptions<T>, store?: Store) => AtomToken<T>;
@@ -200,21 +251,6 @@ type AtomFamilyOptions<T, K extends Serializable> = {
 };
 declare const atomFamily: <T, K extends Serializable>(options: AtomFamilyOptions<T, K>, store?: Store) => (key: K) => AtomToken<T>;
 
-type ƒn = (...parameters: any[]) => any;
-type Transactors = {
-    get: <S>(state: ReadonlyValueToken<S> | StateToken<S>) => S;
-    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 TransactionOptions<ƒ extends ƒn> = {
-    key: string;
-    do: Action<ƒ>;
-};
-declare const transaction: <ƒ extends ƒn>(options: TransactionOptions<ƒ>, store?: Store) => ((...parameters: Parameters<ƒ>) => ReturnType<ƒ>) & {
-    key: string;
-};
-
 type SelectorOptions<T> = {
     key: string;
     get: (readonlyTransactors: ReadonlyTransactors) => T;
@@ -231,7 +267,6 @@ type SelectorFamilyOptions<T, K extends Serializable> = {
 type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<SelectorFamilyOptions<T, K>, `set`>;
 declare function selectorFamily<T, K extends Serializable>(options: SelectorFamilyOptions<T, K>, store?: Store): (key: K) => SelectorToken<T>;
 declare function selectorFamily<T, K extends Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store?: Store): (key: K) => ReadonlyValueToken<T>;
-declare const registerSelector: (selectorKey: string, store?: Store) => Transactors;
 
 type AtomToken<_> = {
     key: string;
@@ -247,11 +282,12 @@ type ReadonlyValueToken<_> = {
     type: `readonly_selector`;
 };
 declare const getState: <T>(token: ReadonlyValueToken<T> | StateToken<T>, store?: Store) => T;
-declare const setState: <T, New extends T>(state: StateToken<T>, value: New | ((oldValue: T) => New), store?: Store) => void;
-type Observe<T> = (change: {
+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;
+type ObserveState<T> = (change: {
     newValue: T;
     oldValue: T;
 }) => void;
-declare const subscribe: <T>(token: ReadonlyValueToken<T> | StateToken<T>, observe: Observe<T>, store?: Store) => (() => void);
+declare const subscribe: <T>(token: ReadonlyValueToken<T> | StateToken<T>, observe: ObserveState<T>, store?: Store) => (() => void);
 
-export { AtomToken as A, Effectors as E, Observe as O, ReadonlyValueToken as R, Store as S, Transactors as T, StateToken as a, SelectorToken as b, configure as c, subscribe as d, AtomEffect as e, AtomOptions as f, getState as g, atom as h, index as i, AtomFamilyOptions as j, atomFamily as k, SelectorOptions as l, ReadonlySelectorOptions as m, selector as n, SelectorFamilyOptions as o, ReadonlySelectorFamilyOptions as p, selectorFamily as q, registerSelector as r, setState as s, ReadonlyTransactors as t, Action as u, TransactionOptions as v, transaction as w, ƒn as ƒ };
+export { AtomToken as A, Effectors as E, ObserveState as O, ReadonlyValueToken as R, Store as S, Transactors as T, StateToken as a, SelectorToken as b, configure as c, isDefault as d, subscribe as e, AtomEffect as f, getState as g, AtomOptions as h, index as i, atom as j, AtomFamilyOptions as k, atomFamily as l, SelectorOptions as m, ReadonlySelectorOptions as n, selector as o, SelectorFamilyOptions as p, ReadonlySelectorFamilyOptions as q, selectorFamily as r, setState as s, ReadonlyTransactors as t, Action as u, TransactionOptions as v, transaction as w, ƒn as ƒ };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { u as Action, e as AtomEffect, j as AtomFamilyOptions, f as AtomOptions, A as AtomToken, E as Effectors, O as Observe, p as ReadonlySelectorFamilyOptions, m as ReadonlySelectorOptions, t as ReadonlyTransactors, R as ReadonlyValueToken, o as SelectorFamilyOptions, l as SelectorOptions, b as SelectorToken, a as StateToken, v as TransactionOptions, T as Transactors, i as __INTERNAL__, h as atom, k as atomFamily, c as configure, g as getState, r as registerSelector, n as selector, q as selectorFamily, s as setState, d as subscribe, w as transaction, ƒ as ƒn } from './index-3b5d305c.js';
+export { u as Action, f as AtomEffect, k as AtomFamilyOptions, h as AtomOptions, A as AtomToken, E as Effectors, O as ObserveState, q as ReadonlySelectorFamilyOptions, n as ReadonlySelectorOptions, t as ReadonlyTransactors, R as ReadonlyValueToken, p as SelectorFamilyOptions, m as SelectorOptions, b as SelectorToken, a as StateToken, v as TransactionOptions, T as Transactors, i as __INTERNAL__, j as atom, l as atomFamily, c as configure, g as getState, d as isDefault, o as selector, r as selectorFamily, s as setState, e as subscribe, w as transaction, ƒ as ƒn } from './index-9d9f5a05.js';
 import 'rxjs';
 import 'hamt_plus';
 import 'fp-ts/Refinement';