atom.io 0.2.0 → 0.3.1

package/react/dist/index.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  composeStoreHooks: () => composeStoreHooks
+});
+module.exports = __toCommonJS(react_exports);
+var import_atom = require("atom.io");
+var composeStoreHooks = ({
+  useState,
+  useEffect,
+  store = import_atom.__INTERNAL__.IMPLICIT.STORE
+}) => {
+  function useI(token) {
+    const updateState = (next) => (0, import_atom.setState)(token, next, store);
+    return updateState;
+  }
+  function useO(token) {
+    const state = import_atom.__INTERNAL__.withdraw(token, store);
+    const initialValue = import_atom.__INTERNAL__.getState__INTERNAL(state, store);
+    const [current, dispatch] = useState(initialValue);
+    useEffect(() => {
+      const unsubscribe = (0, import_atom.subscribe)(
+        token,
+        ({ newValue, oldValue }) => {
+          if (oldValue !== newValue) {
+            dispatch(newValue);
+          }
+        },
+        store
+      );
+      return unsubscribe;
+    }, []);
+    return current;
+  }
+  function useIO(token) {
+    return [useO(token), useI(token)];
+  }
+  function useStore(token) {
+    if (token.type === `readonly_selector`) {
+      return useO(token);
+    }
+    return useIO(token);
+  }
+  return { useI, useO, useIO, useStore };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  composeStoreHooks
+});
+//# sourceMappingURL=index.js.map

package/react/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/index.ts"],"sourcesContent":["import type Preact from \"preact/hooks\"\n\nimport type React from \"react\"\n\nimport { subscribe, setState, __INTERNAL__ } from \"atom.io\"\nimport type { ReadonlyValueToken, StateToken } from \"atom.io\"\n\nimport type { Modifier } from \"~/packages/anvl/src/function\"\n\nexport type AtomStoreReactConfig = {\n  useState: typeof Preact.useState | typeof React.useState\n  useEffect: typeof Preact.useEffect | typeof React.useEffect\n  store?: __INTERNAL__.Store\n}\n\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\nexport const composeStoreHooks = ({\n  useState,\n  useEffect,\n  store = __INTERNAL__.IMPLICIT.STORE,\n}: AtomStoreReactConfig) => {\n  function useI<T>(token: StateToken<T>): (next: Modifier<T> | T) => void {\n    const updateState = (next: Modifier<T> | T) => setState(token, next, store)\n    return updateState\n  }\n\n  function useO<T>(token: ReadonlyValueToken<T> | StateToken<T>): T {\n    const state = __INTERNAL__.withdraw(token, store)\n    const initialValue = __INTERNAL__.getState__INTERNAL(state, store)\n    const [current, dispatch] = useState(initialValue)\n    useEffect(() => {\n      const unsubscribe = subscribe(\n        token,\n        ({ newValue, oldValue }) => {\n          if (oldValue !== newValue) {\n            dispatch(newValue)\n          }\n        },\n        store\n      )\n      return unsubscribe\n    }, [])\n\n    return current\n  }\n\n  function useIO<T>(token: StateToken<T>): [T, (next: Modifier<T> | T) => void] {\n    return [useO(token), useI(token)]\n  }\n\n  function useStore<T>(\n    token: StateToken<T>\n  ): [T, (next: Modifier<T> | T) => void]\n  function useStore<T>(token: ReadonlyValueToken<T>): T\n  function useStore<T>(\n    token: ReadonlyValueToken<T> | StateToken<T>\n  ): T | [T, (next: Modifier<T> | T) => void] {\n    if (token.type === `readonly_selector`) {\n      return useO(token)\n    }\n    return useIO(token)\n  }\n  return { useI, useO, useIO, useStore }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,kBAAkD;AAY3C,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA;AAAA,EACA,QAAQ,yBAAa,SAAS;AAChC,MAA4B;AAC1B,WAAS,KAAQ,OAAuD;AACtE,UAAM,cAAc,CAAC,aAA0B,sBAAS,OAAO,MAAM,KAAK;AAC1E,WAAO;AAAA,EACT;AAEA,WAAS,KAAQ,OAAiD;AAChE,UAAM,QAAQ,yBAAa,SAAS,OAAO,KAAK;AAChD,UAAM,eAAe,yBAAa,mBAAmB,OAAO,KAAK;AACjE,UAAM,CAAC,SAAS,QAAQ,IAAI,SAAS,YAAY;AACjD,cAAU,MAAM;AACd,YAAM,kBAAc;AAAA,QAClB;AAAA,QACA,CAAC,EAAE,UAAU,SAAS,MAAM;AAC1B,cAAI,aAAa,UAAU;AACzB,qBAAS,QAAQ;AAAA,UACnB;AAAA,QACF;AAAA,QACA;AAAA,MACF;AACA,aAAO;AAAA,IACT,GAAG,CAAC,CAAC;AAEL,WAAO;AAAA,EACT;AAEA,WAAS,MAAS,OAA4D;AAC5E,WAAO,CAAC,KAAK,KAAK,GAAG,KAAK,KAAK,CAAC;AAAA,EAClC;AAMA,WAAS,SACP,OAC0C;AAC1C,QAAI,MAAM,SAAS,qBAAqB;AACtC,aAAO,KAAK,KAAK;AAAA,IACnB;AACA,WAAO,MAAM,KAAK;AAAA,EACpB;AACA,SAAO,EAAE,MAAM,MAAM,OAAO,SAAS;AACvC;","names":[]}

package/react/dist/index.mjs

@@ -0,0 +1,44 @@
+// ../src/react/index.ts
+import { subscribe, setState, __INTERNAL__ } from "atom.io";
+var composeStoreHooks = ({
+  useState,
+  useEffect,
+  store = __INTERNAL__.IMPLICIT.STORE
+}) => {
+  function useI(token) {
+    const updateState = (next) => setState(token, next, store);
+    return updateState;
+  }
+  function useO(token) {
+    const state = __INTERNAL__.withdraw(token, store);
+    const initialValue = __INTERNAL__.getState__INTERNAL(state, store);
+    const [current, dispatch] = useState(initialValue);
+    useEffect(() => {
+      const unsubscribe = subscribe(
+        token,
+        ({ newValue, oldValue }) => {
+          if (oldValue !== newValue) {
+            dispatch(newValue);
+          }
+        },
+        store
+      );
+      return unsubscribe;
+    }, []);
+    return current;
+  }
+  function useIO(token) {
+    return [useO(token), useI(token)];
+  }
+  function useStore(token) {
+    if (token.type === `readonly_selector`) {
+      return useO(token);
+    }
+    return useIO(token);
+  }
+  return { useI, useO, useIO, useStore };
+};
+export {
+  composeStoreHooks
+};
+//# sourceMappingURL=index.mjs.map

package/react/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/index.ts"],"sourcesContent":["import type Preact from \"preact/hooks\"\n\nimport type React from \"react\"\n\nimport { subscribe, setState, __INTERNAL__ } from \"atom.io\"\nimport type { ReadonlyValueToken, StateToken } from \"atom.io\"\n\nimport type { Modifier } from \"~/packages/anvl/src/function\"\n\nexport type AtomStoreReactConfig = {\n  useState: typeof Preact.useState | typeof React.useState\n  useEffect: typeof Preact.useEffect | typeof React.useEffect\n  store?: __INTERNAL__.Store\n}\n\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\nexport const composeStoreHooks = ({\n  useState,\n  useEffect,\n  store = __INTERNAL__.IMPLICIT.STORE,\n}: AtomStoreReactConfig) => {\n  function useI<T>(token: StateToken<T>): (next: Modifier<T> | T) => void {\n    const updateState = (next: Modifier<T> | T) => setState(token, next, store)\n    return updateState\n  }\n\n  function useO<T>(token: ReadonlyValueToken<T> | StateToken<T>): T {\n    const state = __INTERNAL__.withdraw(token, store)\n    const initialValue = __INTERNAL__.getState__INTERNAL(state, store)\n    const [current, dispatch] = useState(initialValue)\n    useEffect(() => {\n      const unsubscribe = subscribe(\n        token,\n        ({ newValue, oldValue }) => {\n          if (oldValue !== newValue) {\n            dispatch(newValue)\n          }\n        },\n        store\n      )\n      return unsubscribe\n    }, [])\n\n    return current\n  }\n\n  function useIO<T>(token: StateToken<T>): [T, (next: Modifier<T> | T) => void] {\n    return [useO(token), useI(token)]\n  }\n\n  function useStore<T>(\n    token: StateToken<T>\n  ): [T, (next: Modifier<T> | T) => void]\n  function useStore<T>(token: ReadonlyValueToken<T>): T\n  function useStore<T>(\n    token: ReadonlyValueToken<T> | StateToken<T>\n  ): T | [T, (next: Modifier<T> | T) => void] {\n    if (token.type === `readonly_selector`) {\n      return useO(token)\n    }\n    return useIO(token)\n  }\n  return { useI, useO, useIO, useStore }\n}\n"],"mappings":";AAIA,SAAS,WAAW,UAAU,oBAAoB;AAY3C,IAAM,oBAAoB,CAAC;AAAA,EAChC;AAAA,EACA;AAAA,EACA,QAAQ,aAAa,SAAS;AAChC,MAA4B;AAC1B,WAAS,KAAQ,OAAuD;AACtE,UAAM,cAAc,CAAC,SAA0B,SAAS,OAAO,MAAM,KAAK;AAC1E,WAAO;AAAA,EACT;AAEA,WAAS,KAAQ,OAAiD;AAChE,UAAM,QAAQ,aAAa,SAAS,OAAO,KAAK;AAChD,UAAM,eAAe,aAAa,mBAAmB,OAAO,KAAK;AACjE,UAAM,CAAC,SAAS,QAAQ,IAAI,SAAS,YAAY;AACjD,cAAU,MAAM;AACd,YAAM,cAAc;AAAA,QAClB;AAAA,QACA,CAAC,EAAE,UAAU,SAAS,MAAM;AAC1B,cAAI,aAAa,UAAU;AACzB,qBAAS,QAAQ;AAAA,UACnB;AAAA,QACF;AAAA,QACA;AAAA,MACF;AACA,aAAO;AAAA,IACT,GAAG,CAAC,CAAC;AAEL,WAAO;AAAA,EACT;AAEA,WAAS,MAAS,OAA4D;AAC5E,WAAO,CAAC,KAAK,KAAK,GAAG,KAAK,KAAK,CAAC;AAAA,EAClC;AAMA,WAAS,SACP,OAC0C;AAC1C,QAAI,MAAM,SAAS,qBAAqB;AACtC,aAAO,KAAK,KAAK;AAAA,IACnB;AACA,WAAO,MAAM,KAAK;AAAA,EACpB;AACA,SAAO,EAAE,MAAM,MAAM,OAAO,SAAS;AACvC;","names":[]}

package/react/package.json

@@ -1,6 +1,15 @@
 {
   "name": "atom.io-react",
-  "main": "../dist/react/index.js",
-  "types": "../dist/react/index.d.ts",
-  "module": "../dist/react/index.mjs"
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": "./dist/index.mjs",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  }
 }

package/src/atom.ts

@@ -1,14 +1,9 @@
-import HAMT from "hamt_plus"
-import * as Rx from "rxjs"
+import type * as Rx from "rxjs"
 
 import type { Serializable } from "~/packages/anvl/src/json"
-import { stringifyJson } from "~/packages/anvl/src/json"
 
-import type { AtomToken, ObserveState } from "."
-import { subscribe, setState } from "."
-import { deposit } from "./internal"
-import type { Store } from "./internal/store"
-import { IMPLICIT } from "./internal/store"
+import type { AtomToken } from "."
+import { atomFamily__INTERNAL, atom__INTERNAL } from "./internal"
 
 export type Effectors<T> = {
   setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
@@ -23,28 +18,8 @@ export type AtomOptions<T> = {
   effects?: AtomEffect<T>[]
 }
 
-export const atom = <T>(
-  options: AtomOptions<T>,
-  store: Store = IMPLICIT.STORE
-): AtomToken<T> => {
-  if (HAMT.has(options.key, store.atoms)) {
-    store.config.logger?.error?.(
-      `Key "${options.key}" already exists in the store.`
-    )
-    return deposit(store.atoms.get(options.key))
-  }
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
-  const newAtom = { ...options, subject }
-  const initialValue =
-    options.default instanceof Function ? options.default() : options.default
-  store.atoms = HAMT.set(options.key, newAtom, store.atoms)
-  store.atomsAreDefault = HAMT.set(options.key, true, store.atomsAreDefault)
-  store.valueMap = HAMT.set(options.key, initialValue, store.valueMap)
-  const token = deposit(newAtom)
-  const setSelf = (next) => setState(token, next, store)
-  const onSet = (observe: ObserveState<T>) => subscribe(token, observe, store)
-  options.effects?.forEach((effect) => effect({ setSelf, onSet }))
-  return token
+export function atom<T>(options: AtomOptions<T>): AtomToken<T> {
+  return atom__INTERNAL<T>(options)
 }
 
 export type AtomFamilyOptions<T, K extends Serializable> = {
@@ -53,26 +28,16 @@ export type AtomFamilyOptions<T, K extends Serializable> = {
   effects?: (key: K) => AtomEffect<T>[]
 }
 
-export const atomFamily =
-  <T, K extends Serializable>(
-    options: AtomFamilyOptions<T, K>,
-    store: Store = IMPLICIT.STORE
-  ) =>
-  (key: K): AtomToken<T> => {
-    const fullKey = `${options.key}__${stringifyJson(key)}`
-    const existing = store.atoms.get(fullKey)
-    if (existing) {
-      return deposit(existing)
-    }
-    return atom<T>(
-      {
-        key: fullKey,
-        default:
-          options.default instanceof Function
-            ? options.default(key)
-            : options.default,
-        effects: options.effects?.(key),
-      },
-      store
-    )
-  }
+export type AtomFamily<T, K extends Serializable = Serializable> = ((
+  key: K
+) => AtomToken<T>) & {
+  key: string
+  type: `atom_family`
+  subject: Rx.Subject<AtomToken<T>>
+}
+
+export function atomFamily<T, K extends Serializable>(
+  options: AtomFamilyOptions<T, K>
+): AtomFamily<T, K> {
+  return atomFamily__INTERNAL<T, K>(options)
+}

package/src/index.ts

@@ -1,36 +1,51 @@
 import {
   IMPLICIT,
-  configure,
-  finishAction,
+  closeOperation,
+  openOperation,
   getState__INTERNAL,
   setState__INTERNAL,
   isAtomDefault,
   isSelectorDefault,
-  startAction,
-  subscribeToRootAtoms,
   withdraw,
 } from "./internal"
 import * as __INTERNAL__ from "./internal"
 import type { Store } from "./internal/store"
 
 export * from "./atom"
+export * from "./logger"
 export * from "./selector"
+export * from "./subscribe"
+export * from "./timeline"
 export * from "./transaction"
-export { __INTERNAL__, configure }
+export { __INTERNAL__ }
+export type { Serializable } from "~/packages/anvl/src/json"
 
 export type AtomToken<_> = {
   key: string
   type: `atom`
+  family?: FamilyMetadata
 }
 export type SelectorToken<_> = {
   key: string
   type: `selector`
+  family?: FamilyMetadata
 }
 export type StateToken<T> = AtomToken<T> | SelectorToken<T>
 
 export type ReadonlyValueToken<_> = {
   key: string
   type: `readonly_selector`
+  family?: FamilyMetadata
+}
+
+export type FamilyMetadata = {
+  key: string
+  subKey: string
+}
+
+export type TransactionToken<_> = {
+  key: string
+  type: `transaction`
 }
 
 export const getState = <T>(
@@ -46,10 +61,17 @@ export const setState = <T, New extends T>(
   value: New | ((oldValue: T) => New),
   store: Store = IMPLICIT.STORE
 ): void => {
-  startAction(store)
+  try {
+    openOperation(token, store)
+  } catch (thrown) {
+    if (!(typeof thrown === `symbol`)) {
+      throw thrown
+    }
+    return
+  }
   const state = withdraw(token, store)
   setState__INTERNAL(state, value, store)
-  finishAction(store)
+  closeOperation(store)
 }
 
 export const isDefault = (
@@ -59,33 +81,3 @@ export const isDefault = (
   token.type === `atom`
     ? isAtomDefault(token.key, store)
     : isSelectorDefault(token.key, store)
-
-export type ObserveState<T> = (change: { newValue: T; oldValue: T }) => void
-
-export const subscribe = <T>(
-  token: ReadonlyValueToken<T> | StateToken<T>,
-  observe: ObserveState<T>,
-  store: Store = IMPLICIT.STORE
-): (() => void) => {
-  const state = withdraw<T>(token, store)
-  const subscription = state.subject.subscribe(observe)
-  store.config.logger?.info(`👀 subscribe to "${state.key}"`)
-  const dependencySubscriptions = subscribeToRootAtoms(state, store)
-  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
-}

package/src/internal/atom-internal.ts

@@ -0,0 +1,50 @@
+import * as Rx from "rxjs"
+
+import { deposit } from "./get"
+import { markAtomAsDefault } from "./is-default"
+import { cacheValue, hasKeyBeenUsed, storeAtom } from "./operation"
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+import { target } from "./transaction-internal"
+import type { AtomToken, FamilyMetadata, UpdateHandler } from ".."
+import { setState, subscribe } from ".."
+import type { AtomOptions } from "../atom"
+
+export type Atom<T> = {
+  key: string
+  type: `atom`
+  family?: FamilyMetadata
+  subject: Rx.Subject<{ newValue: T; oldValue: T }>
+  default: T
+}
+
+export function atom__INTERNAL<T>(
+  options: AtomOptions<T>,
+  family?: FamilyMetadata,
+  store: Store = IMPLICIT.STORE
+): AtomToken<T> {
+  const core = target(store)
+  if (hasKeyBeenUsed(options.key, store)) {
+    store.config.logger?.error?.(
+      `Key "${options.key}" already exists in the store.`
+    )
+    return deposit(core.atoms.get(options.key))
+  }
+  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
+  const newAtom = {
+    ...options,
+    subject,
+    type: `atom`,
+    ...(family && { family }),
+  } as const
+  const initialValue =
+    options.default instanceof Function ? options.default() : options.default
+  storeAtom(newAtom, store)
+  markAtomAsDefault(options.key, store)
+  cacheValue(options.key, initialValue, store)
+  const token = deposit(newAtom)
+  const setSelf = (next) => setState(token, next, store)
+  const onSet = (handle: UpdateHandler<T>) => subscribe(token, handle, store)
+  options.effects?.forEach((effect) => effect({ setSelf, onSet }))
+  return token
+}

package/src/internal/families-internal.ts

@@ -0,0 +1,142 @@
+import * as Rx from "rxjs"
+
+import type { Serializable } from "~/packages/anvl/src/json"
+import { stringifyJson } from "~/packages/anvl/src/json"
+
+import type { Store } from "."
+import {
+  atom__INTERNAL,
+  withdraw,
+  selector__INTERNAL,
+  target,
+  deposit,
+  IMPLICIT,
+} from "."
+import type {
+  AtomFamily,
+  AtomFamilyOptions,
+  AtomToken,
+  FamilyMetadata,
+  ReadonlySelectorFamily,
+  ReadonlySelectorFamilyOptions,
+  ReadonlyValueToken,
+  SelectorFamily,
+  SelectorFamilyOptions,
+  SelectorToken,
+} from ".."
+
+export function atomFamily__INTERNAL<T, K extends Serializable>(
+  options: AtomFamilyOptions<T, K>,
+  store: Store = IMPLICIT.STORE
+): AtomFamily<T, K> {
+  const subject = new Rx.Subject<AtomToken<T>>()
+  return Object.assign(
+    (key: K): AtomToken<T> => {
+      const subKey = stringifyJson(key)
+      const family: FamilyMetadata = { key: options.key, subKey }
+      const fullKey = `${options.key}(${subKey})`
+      const existing = withdraw({ key: fullKey, type: `atom` }, store)
+      const token = existing
+        ? deposit(existing)
+        : atom__INTERNAL<T>(
+            {
+              key: fullKey,
+              default:
+                options.default instanceof Function
+                  ? options.default(key)
+                  : options.default,
+              effects: options.effects?.(key),
+            },
+            family,
+            store
+          )
+      subject.next(token)
+      return token
+    },
+    {
+      key: options.key,
+      type: `atom_family`,
+      subject,
+    } as const
+  )
+}
+
+export function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(
+  options: SelectorFamilyOptions<T, K>,
+  store?: Store
+): ReadonlySelectorFamily<T, K> {
+  const core = target(store)
+  const subject = new Rx.Subject<ReadonlyValueToken<T>>()
+  return Object.assign(
+    (key: K): ReadonlyValueToken<T> => {
+      const subKey = stringifyJson(key)
+      const family: FamilyMetadata = { key: options.key, subKey }
+      const fullKey = `${options.key}(${subKey})`
+      const existing = core.readonlySelectors.get(fullKey)
+      if (existing) {
+        return deposit(existing)
+      }
+      return selector__INTERNAL<T>(
+        {
+          key: fullKey,
+          get: options.get(key),
+        },
+        family,
+        store
+      ) as ReadonlyValueToken<T>
+    },
+    {
+      key: options.key,
+      type: `readonly_selector_family`,
+      subject,
+    } as const
+  ) as ReadonlySelectorFamily<T, K>
+}
+
+export function selectorFamily__INTERNAL<T, K extends Serializable>(
+  options: SelectorFamilyOptions<T, K>,
+  store?: Store
+): SelectorFamily<T, K>
+export function selectorFamily__INTERNAL<T, K extends Serializable>(
+  options: ReadonlySelectorFamilyOptions<T, K>,
+  store?: Store
+): ReadonlySelectorFamily<T, K>
+export function selectorFamily__INTERNAL<T, K extends Serializable>(
+  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
+  store: Store = IMPLICIT.STORE
+): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
+  const isReadonly = !(`set` in options)
+
+  if (isReadonly) {
+    return readonlySelectorFamily__INTERNAL(options as any, store)
+  }
+  const core = target(store)
+  const subject = new Rx.Subject<SelectorToken<T>>()
+
+  return Object.assign(
+    (key: K): SelectorToken<T> => {
+      const subKey = stringifyJson(key)
+      const family: FamilyMetadata = { key: options.key, subKey }
+      const fullKey = `${options.key}(${subKey})`
+      const existing = core.selectors.get(fullKey)
+      if (existing) {
+        return deposit(existing)
+      }
+      const token = selector__INTERNAL<T>(
+        {
+          key: fullKey,
+          get: options.get(key),
+          set: options.set(key),
+        },
+        family,
+        store
+      )
+      subject.next(token)
+      return token
+    },
+    {
+      key: options.key,
+      type: `selector_family`,
+    } as const
+  ) as SelectorFamily<T, K>
+}

package/src/internal/get.ts

@@ -1,36 +1,18 @@
-import { pipe } from "fp-ts/function"
 import HAMT from "hamt_plus"
 
-import type { Atom, ReadonlySelector, Selector } from "."
-import type { Store } from "./store"
-import { IMPLICIT } from "./store"
+import type { Atom, ReadonlySelector, Selector, Store } from "."
+import { target, isValueCached, readCachedValue, IMPLICIT } from "."
 import type {
   AtomToken,
   ReadonlyValueToken,
   SelectorToken,
   StateToken,
+  Transaction,
+  TransactionToken,
+  ƒn,
 } from ".."
 
-export const getCachedState = <T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
-  store: Store = IMPLICIT.STORE
-): T => {
-  const path = []
-  if (`default` in state) {
-    const atomKey = state.key
-    store.selectorAtoms = pipe(store.selectorAtoms, (oldValue) => {
-      let newValue = oldValue
-      for (const selectorKey of path) {
-        newValue = newValue.set(selectorKey, atomKey)
-      }
-      return newValue
-    })
-  }
-  const value = HAMT.get(state.key, store.valueMap)
-  return value
-}
-
-export const getSelectorState = <T>(
+export const computeSelectorState = <T>(
   selector: ReadonlySelector<T> | Selector<T>
 ): T => selector.get()
 
@@ -38,9 +20,10 @@ export function lookup(
   key: string,
   store: Store
 ): AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown> {
-  const type = HAMT.has(key, store.atoms)
+  const core = target(store)
+  const type = HAMT.has(key, core.atoms)
     ? `atom`
-    : HAMT.has(key, store.selectors)
+    : HAMT.has(key, core.selectors)
     ? `selector`
     : `readonly_selector`
   return { key, type }
@@ -56,18 +39,28 @@ export function withdraw<T>(
   token: ReadonlyValueToken<T>,
   store: Store
 ): ReadonlySelector<T>
+export function withdraw<T>(
+  token: TransactionToken<T>,
+  store: Store
+): Transaction<T extends ƒn ? T : never>
 export function withdraw<T>(
   token: ReadonlyValueToken<T> | StateToken<T>,
   store: Store
 ): Atom<T> | ReadonlySelector<T> | Selector<T>
 export function withdraw<T>(
-  token: ReadonlyValueToken<T> | StateToken<T>,
+  token: ReadonlyValueToken<T> | StateToken<T> | TransactionToken<T>,
   store: Store
-): Atom<T> | ReadonlySelector<T> | Selector<T> {
+):
+  | Atom<T>
+  | ReadonlySelector<T>
+  | Selector<T>
+  | Transaction<T extends ƒn ? T : never> {
+  const core = target(store)
   return (
-    HAMT.get(token.key, store.atoms) ??
-    HAMT.get(token.key, store.selectors) ??
-    HAMT.get(token.key, store.readonlySelectors)
+    HAMT.get(token.key, core.atoms) ??
+    HAMT.get(token.key, core.selectors) ??
+    HAMT.get(token.key, core.readonlySelectors) ??
+    HAMT.get(token.key, core.transactions)
   )
 }
 
@@ -75,32 +68,37 @@ export function deposit<T>(state: Atom<T>): AtomToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: Atom<T> | Selector<T>): StateToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlyValueToken<T>
+export function deposit<T>(
+  state: Transaction<T extends ƒn ? T : never>
+): TransactionToken<T>
 export function deposit<T>(
   state: Atom<T> | ReadonlySelector<T> | Selector<T>
 ): ReadonlyValueToken<T> | StateToken<T>
 export function deposit<T>(
-  state: Atom<T> | ReadonlySelector<T> | Selector<T>
-): ReadonlyValueToken<T> | StateToken<T> {
-  if (`get` in state) {
-    if (`set` in state) {
-      return { key: state.key, type: `selector` }
-    }
-    return { key: state.key, type: `readonly_selector` }
+  state:
+    | Atom<T>
+    | ReadonlySelector<T>
+    | Selector<T>
+    | Transaction<T extends ƒn ? T : never>
+): ReadonlyValueToken<T> | StateToken<T> | TransactionToken<T> {
+  return {
+    key: state.key,
+    type: state.type,
+    ...(`family` in state && { family: state.family }),
   }
-  return { key: state.key, type: `atom` }
 }
 
 export const getState__INTERNAL = <T>(
   state: Atom<T> | ReadonlySelector<T> | Selector<T>,
   store: Store = IMPLICIT.STORE
 ): T => {
-  if (HAMT.has(state.key, store.valueMap)) {
+  if (isValueCached(state.key, store)) {
     store.config.logger?.info(`>> read "${state.key}"`)
-    return getCachedState(state, store)
+    return readCachedValue(state.key, store)
   }
-  if (`get` in state) {
+  if (state.type !== `atom`) {
     store.config.logger?.info(`-> calc "${state.key}"`)
-    return getSelectorState(state)
+    return computeSelectorState(state)
   }
   store.config.logger?.error(
     `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`