atom.io 0.2.0 → 0.3.1

package/src/selector.ts

@@ -1,132 +1,62 @@
-import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
+import type * as Rx from "rxjs"
 
-import { become } from "~/packages/anvl/src/function"
 import type { Serializable } from "~/packages/anvl/src/json"
-import { stringifyJson } from "~/packages/anvl/src/json"
 
 import type { ReadonlyValueToken, SelectorToken } from "."
-import type { Selector, Store } from "./internal"
-import { IMPLICIT, markDone, deposit, registerSelector } from "./internal"
-import type { ReadonlyTransactors, Transactors } from "./transaction"
+import { selectorFamily__INTERNAL, selector__INTERNAL } from "./internal"
+import type { Read, Write } from "./transaction"
 
 export type SelectorOptions<T> = {
   key: string
-  get: (readonlyTransactors: ReadonlyTransactors) => T
-  set: (transactors: Transactors, newValue: T) => void
+  get: Read<() => T>
+  set: Write<(newValue: T) => void>
 }
 export type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>
 
+export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
 export function selector<T>(
-  options: SelectorOptions<T>,
-  store?: Store
-): SelectorToken<T>
-export function selector<T>(
-  options: ReadonlySelectorOptions<T>,
-  store?: Store
+  options: ReadonlySelectorOptions<T>
 ): ReadonlyValueToken<T>
 export function selector<T>(
-  options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
-  store: Store = IMPLICIT.STORE
+  options: ReadonlySelectorOptions<T> | SelectorOptions<T>
 ): ReadonlyValueToken<T> | SelectorToken<T> {
-  if (HAMT.has(options.key, store.selectors)) {
-    throw new Error(`Key "${options.key}" already exists in the store.`)
-  }
-
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
-
-  const { get, set } = registerSelector(options.key, store)
-  const getSelf = () => {
-    const value = options.get({ get })
-    store.valueMap = HAMT.set(options.key, value, store.valueMap)
-    return value
-  }
-
-  if (!(`set` in options)) {
-    const readonlySelector = {
-      ...options,
-      subject,
-      get: getSelf,
-    }
-    store.readonlySelectors = HAMT.set(
-      options.key,
-      readonlySelector,
-      store.readonlySelectors
-    )
-    const initialValue = getSelf()
-    store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-    return { ...readonlySelector, type: `readonly_selector` }
-  }
-
-  const setSelf = (next: T | ((oldValue: T) => T)): void => {
-    store.config.logger?.info(`   <- "${options.key}" became`, next)
-    const oldValue = getSelf()
-    const newValue = become(next)(oldValue)
-    store.valueMap = HAMT.set(options.key, newValue, store.valueMap)
-    markDone(options.key, store)
-    subject.next({ newValue, oldValue })
-    options.set({ get, set }, newValue)
-  }
-
-  const mySelector: Selector<T> = {
-    ...options,
-    subject,
-    get: getSelf,
-    set: setSelf,
-  }
-  store.selectors = HAMT.set(options.key, mySelector, store.selectors)
-  const initialValue = getSelf()
-  store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
-  return { ...mySelector, type: `selector` }
+  return selector__INTERNAL(options)
 }
 
 export 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>
 }
 export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<
   SelectorFamilyOptions<T, K>,
   `set`
 >
 
+export type SelectorFamily<T, K extends Serializable = Serializable> = ((
+  key: K
+) => SelectorToken<T>) & {
+  key: string
+  type: `selector_family`
+  subject: Rx.Subject<SelectorToken<T>>
+}
+
+export type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((
+  key: K
+) => ReadonlyValueToken<T>) & {
+  key: string
+  type: `readonly_selector_family`
+  subject: Rx.Subject<ReadonlyValueToken<T>>
+}
+
 export function selectorFamily<T, K extends Serializable>(
-  options: SelectorFamilyOptions<T, K>,
-  store?: Store
-): (key: K) => SelectorToken<T>
+  options: SelectorFamilyOptions<T, K>
+): SelectorFamily<T, K>
 export function selectorFamily<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K>,
-  store?: Store
-): (key: K) => ReadonlyValueToken<T>
+  options: ReadonlySelectorFamilyOptions<T, K>
+): ReadonlySelectorFamily<T, K>
 export function selectorFamily<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
-  store: Store = IMPLICIT.STORE
-): (key: K) => ReadonlyValueToken<T> | SelectorToken<T> {
-  return (key: K): ReadonlyValueToken<T> | SelectorToken<T> => {
-    const fullKey = `${options.key}__${stringifyJson(key)}`
-    const existing =
-      store.selectors.get(fullKey) ?? store.readonlySelectors.get(fullKey)
-    if (existing) {
-      return deposit(existing)
-    }
-    const readonlySelectorOptions: ReadonlySelectorOptions<T> = {
-      key: fullKey,
-      get: options.get(key),
-    }
-    if (!(`set` in options)) {
-      return selector<T>(
-        {
-          ...readonlySelectorOptions,
-        },
-        store
-      )
-    }
-    return selector<T>(
-      {
-        ...readonlySelectorOptions,
-        set: options.set(key),
-      },
-      store
-    )
-  }
+  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>
+): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
+  return selectorFamily__INTERNAL(options)
 }

package/src/subscribe.ts

@@ -0,0 +1,55 @@
+import type { ReadonlyValueToken, StateToken, TransactionToken, ƒn } from "."
+import type { Store, TransactionUpdate } from "./internal"
+import { IMPLICIT, subscribeToRootAtoms, withdraw } from "./internal"
+
+export type StateUpdate<T> = { newValue: T; oldValue: T }
+export type UpdateHandler<T> = (update: StateUpdate<T>) => void
+
+export const subscribe = <T>(
+  token: ReadonlyValueToken<T> | StateToken<T>,
+  handleUpdate: UpdateHandler<T>,
+  store: Store = IMPLICIT.STORE
+): (() => void) => {
+  const state = withdraw<T>(token, store)
+  const subscription = state.subject.subscribe(handleUpdate)
+  store.config.logger?.info(`👀 subscribe to "${state.key}"`)
+  const dependencySubscriptions =
+    state.type !== `atom` ? subscribeToRootAtoms(state, store) : null
+
+  const unsubscribe =
+    dependencySubscriptions === null
+      ? () => {
+          store.config.logger?.info(`🙈 unsubscribe from "${state.key}"`)
+          subscription.unsubscribe()
+        }
+      : () => {
+          store.config.logger?.info(
+            `🙈 unsubscribe from "${state.key}" and its dependencies`
+          )
+          subscription.unsubscribe()
+          for (const dependencySubscription of dependencySubscriptions) {
+            dependencySubscription.unsubscribe()
+          }
+        }
+
+  return unsubscribe
+}
+
+export type TransactionUpdateHandler<ƒ extends ƒn> = (
+  data: TransactionUpdate<ƒ>
+) => void
+
+export const subscribeToTransaction = <ƒ extends ƒn>(
+  token: TransactionToken<ƒ>,
+  handleUpdate: TransactionUpdateHandler<ƒ>,
+  store = IMPLICIT.STORE
+): (() => void) => {
+  const tx = withdraw(token, store)
+  store.config.logger?.info(`👀 subscribe to transaction "${token.key}"`)
+  const subscription = tx.subject.subscribe(handleUpdate)
+  const unsubscribe = () => {
+    store.config.logger?.info(`🙈 unsubscribe from transaction "${token.key}"`)
+    subscription.unsubscribe()
+  }
+  return unsubscribe
+}

package/src/timeline.ts

@@ -0,0 +1,29 @@
+import type { AtomFamily, AtomToken } from "."
+import { IMPLICIT } from "./internal"
+import {
+  redo__INTERNAL,
+  timeline__INTERNAL,
+  undo__INTERNAL,
+} from "./internal/timeline-internal"
+
+export type TimelineToken = {
+  key: string
+  type: `timeline`
+}
+
+export type TimelineOptions = {
+  key: string
+  atoms: (AtomFamily<any> | AtomToken<any>)[]
+}
+
+export const timeline = (options: TimelineOptions): TimelineToken => {
+  return timeline__INTERNAL(options)
+}
+
+export const redo = (token: TimelineToken): void => {
+  return redo__INTERNAL(token, IMPLICIT.STORE)
+}
+
+export const undo = (token: TimelineToken): void => {
+  return undo__INTERNAL(token, IMPLICIT.STORE)
+}

package/src/transaction.ts

@@ -1,12 +1,8 @@
-import type { ReadonlyValueToken, StateToken } from "."
-import { getState, setState } from "."
-import type { Store } from "./internal"
-import { IMPLICIT } from "./internal"
-import {
-  abortTransaction,
-  finishTransaction,
-  startTransaction,
-} from "./internal/transaction-internal"
+import type * as Rx from "rxjs"
+
+import type { ReadonlyValueToken, StateToken, TransactionToken } from "."
+import type { Store, TransactionUpdate } from "./internal"
+import { IMPLICIT, transaction__INTERNAL, withdraw } from "./internal"
 
 export type ƒn = (...parameters: any[]) => any
 
@@ -16,38 +12,35 @@ export type Transactors = {
 }
 export type ReadonlyTransactors = Pick<Transactors, `get`>
 
-export type Action<ƒ extends ƒn> = (
+export type Read<ƒ extends ƒn> = (
+  transactors: ReadonlyTransactors,
+  ...parameters: Parameters<ƒ>
+) => ReturnType<ƒ>
+
+export type Write<ƒ extends ƒn> = (
   transactors: Transactors,
   ...parameters: Parameters<ƒ>
 ) => ReturnType<ƒ>
 
 export type TransactionOptions<ƒ extends ƒn> = {
   key: string
-  do: Action<ƒ>
+  do: Write<ƒ>
+}
+
+export type Transaction<ƒ extends ƒn> = {
+  key: string
+  type: `transaction`
+  run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
+  subject: Rx.Subject<TransactionUpdate<ƒ>>
+}
+
+export function transaction<ƒ extends ƒn>(
+  options: TransactionOptions<ƒ>
+): TransactionToken<ƒ> {
+  return transaction__INTERNAL(options)
 }
 
-export const transaction = <ƒ extends ƒn>(
-  options: TransactionOptions<ƒ>,
-  store: Store = IMPLICIT.STORE
-): ((...parameters: Parameters<ƒ>) => ReturnType<ƒ>) & { key: string } =>
-  Object.assign(
-    (...parameters: Parameters<ƒ>) => {
-      startTransaction(store)
-      try {
-        const result = options.do(
-          {
-            get: (token) => getState(token, store),
-            set: (token, value) => setState(token, value, store),
-          },
-          ...parameters
-        )
-        finishTransaction(store)
-        return result
-      } catch (thrown) {
-        abortTransaction(store)
-        store.config.logger?.error(`Transaction ${options.key} failed`, thrown)
-        throw thrown
-      }
-    },
-    { key: options.key }
-  )
+export const runTransaction =
+  <ƒ extends ƒn>(token: TransactionToken<ƒ>, store: Store = IMPLICIT.STORE) =>
+  (...parameters: Parameters<ƒ>): ReturnType<ƒ> =>
+    withdraw(token, store).run(...parameters)

package/dist/index-9d9f5a05.d.ts

@@ -1,293 +0,0 @@
-import * as Rx from 'rxjs';
-import { Hamt } from 'hamt_plus';
-import { Refinement } from 'fp-ts/Refinement';
-
-type Primitive = boolean | number | string | null;
-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 Identified = {
-    id: string;
-};
-
-declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
-type RelationType = (typeof RELATION_TYPES)[number];
-type RelationData<CONTENT extends JsonObj | null = null> = {
-    contents: JsonObj<string, CONTENT>;
-    relations: JsonObj<string, string[]>;
-    relationType: RelationType;
-};
-
-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> {
-    readonly relationType: `1:1` | `1:n` | `n:n`;
-    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>;
-    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(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>;
-}
-
-interface Store {
-    valueMap: Hamt<any, string>;
-    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>;
-    operation: {
-        open: false;
-    } | {
-        open: true;
-        done: Set<string>;
-        prev: Hamt<any, string>;
-    };
-    transaction: {
-        open: false;
-    } | {
-        open: true;
-        prev: Pick<Store, `atoms` | `readonlySelectors` | `selectorGraph` | `selectors` | `valueMap`>;
-    };
-    config: {
-        name: string;
-        logger: Pick<Console, `error` | `info` | `warn`> | null;
-    };
-}
-declare const createStore: (name: string) => Store;
-declare const IMPLICIT: {
-    STORE_INTERNAL: Store | undefined;
-    readonly STORE: Store;
-};
-declare const configure: (config: Partial<Store[`config`]>, store?: Store) => void;
-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>;
-declare function withdraw<T>(token: ReadonlyValueToken<T>, store: Store): ReadonlySelector<T>;
-declare function withdraw<T>(token: ReadonlyValueToken<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: 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 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>(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 recallState: <T>(state: Atom<T> | Selector<T> | ReadonlySelector<T>, store?: Store) => T;
-
-declare const finishTransaction: (store: Store) => void;
-declare const startTransaction: (store: Store) => void;
-declare const abortTransaction: (store: Store) => void;
-
-type Atom<T> = {
-    key: string;
-    subject: Rx.Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    default: T;
-};
-type Selector<T> = {
-    key: string;
-    subject: Rx.Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-    set: (newValue: T | ((oldValue: T) => T)) => void;
-};
-type ReadonlySelector<T> = Omit<Selector<T>, `set`>;
-
-type index_Atom<T> = Atom<T>;
-declare const index_IMPLICIT: typeof IMPLICIT;
-type index_ReadonlySelector<T> = ReadonlySelector<T>;
-type index_Selector<T> = Selector<T>;
-type index_Store = Store;
-declare const index_abortTransaction: typeof abortTransaction;
-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_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 {
-    index_Atom as Atom,
-    index_IMPLICIT as IMPLICIT,
-    index_ReadonlySelector as ReadonlySelector,
-    index_Selector as Selector,
-    index_Store as Store,
-    index_abortTransaction as abortTransaction,
-    index_clearStore as clearStore,
-    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_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,
-  };
-}
-
-type Effectors<T> = {
-    setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
-    onSet: (callback: (options: {
-        newValue: T;
-        oldValue: T;
-    }) => void) => void;
-};
-type AtomEffect<T> = (tools: Effectors<T>) => void;
-type AtomOptions<T> = {
-    key: string;
-    default: T | (() => T);
-    effects?: AtomEffect<T>[];
-};
-declare const atom: <T>(options: AtomOptions<T>, store?: Store) => AtomToken<T>;
-type AtomFamilyOptions<T, K extends Serializable> = {
-    key: string;
-    default: T | ((key: K) => T);
-    effects?: (key: K) => AtomEffect<T>[];
-};
-declare const atomFamily: <T, K extends Serializable>(options: AtomFamilyOptions<T, K>, store?: Store) => (key: K) => AtomToken<T>;
-
-type SelectorOptions<T> = {
-    key: string;
-    get: (readonlyTransactors: ReadonlyTransactors) => T;
-    set: (transactors: Transactors, newValue: T) => void;
-};
-type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>;
-declare function selector<T>(options: SelectorOptions<T>, store?: Store): SelectorToken<T>;
-declare function selector<T>(options: ReadonlySelectorOptions<T>, store?: Store): ReadonlyValueToken<T>;
-type SelectorFamilyOptions<T, K extends Serializable> = {
-    key: string;
-    get: (key: K) => (readonlyTransactors: ReadonlyTransactors) => T;
-    set: (key: K) => (transactors: Transactors, newValue: T) => void;
-};
-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>;
-
-type AtomToken<_> = {
-    key: string;
-    type: `atom`;
-};
-type SelectorToken<_> = {
-    key: string;
-    type: `selector`;
-};
-type StateToken<T> = AtomToken<T> | SelectorToken<T>;
-type ReadonlyValueToken<_> = {
-    key: string;
-    type: `readonly_selector`;
-};
-declare const getState: <T>(token: ReadonlyValueToken<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;
-type ObserveState<T> = (change: {
-    newValue: T;
-    oldValue: T;
-}) => void;
-declare const subscribe: <T>(token: ReadonlyValueToken<T> | StateToken<T>, observe: ObserveState<T>, store?: Store) => (() => void);
-
-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 ƒ };