atom.io 0.1.0 → 0.3.0

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

@@ -0,0 +1,15 @@
+{
+  "name": "atom.io-react",
+  "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

@@ -0,0 +1,43 @@
+import type * as Rx from "rxjs"
+
+import type { Serializable } from "~/packages/anvl/src/json"
+
+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
+  onSet: (callback: (options: { newValue: T; oldValue: T }) => void) => void
+}
+
+export type AtomEffect<T> = (tools: Effectors<T>) => void
+
+export type AtomOptions<T> = {
+  key: string
+  default: T | (() => T)
+  effects?: AtomEffect<T>[]
+}
+
+export function atom<T>(options: AtomOptions<T>): AtomToken<T> {
+  return atom__INTERNAL<T>(options)
+}
+
+export type AtomFamilyOptions<T, K extends Serializable> = {
+  key: string
+  default: T | ((key: K) => T)
+  effects?: (key: K) => AtomEffect<T>[]
+}
+
+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

@@ -0,0 +1,77 @@
+import {
+  IMPLICIT,
+  closeOperation,
+  openOperation,
+  getState__INTERNAL,
+  setState__INTERNAL,
+  isAtomDefault,
+  isSelectorDefault,
+  withdraw,
+  setLogLevel,
+  useLogger,
+} from "./internal"
+import * as __INTERNAL__ from "./internal"
+import type { Store } from "./internal/store"
+
+export * from "./atom"
+export * from "./selector"
+export * from "./timeline"
+export * from "./transaction"
+export * from "./subscribe"
+export { __INTERNAL__, setLogLevel, useLogger }
+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>(
+  token: ReadonlyValueToken<T> | StateToken<T>,
+  store: Store = IMPLICIT.STORE
+): T => {
+  const state = withdraw<T>(token, store)
+  return getState__INTERNAL(state, store)
+}
+
+export const setState = <T, New extends T>(
+  token: StateToken<T>,
+  value: New | ((oldValue: T) => New),
+  store: Store = IMPLICIT.STORE
+): void => {
+  openOperation(store)
+  const state = withdraw(token, store)
+  setState__INTERNAL(state, value, store)
+  closeOperation(store)
+}
+
+export const isDefault = (
+  token: ReadonlyValueToken<unknown> | StateToken<unknown>,
+  store: Store = IMPLICIT.STORE
+): boolean =>
+  token.type === `atom`
+    ? isAtomDefault(token.key, store)
+    : isSelectorDefault(token.key, store)

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

@@ -0,0 +1,107 @@
+import HAMT from "hamt_plus"
+
+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 computeSelectorState = <T>(
+  selector: ReadonlySelector<T> | Selector<T>
+): T => selector.get()
+
+export function lookup(
+  key: string,
+  store: Store
+): AtomToken<unknown> | ReadonlyValueToken<unknown> | SelectorToken<unknown> {
+  const core = target(store)
+  const type = HAMT.has(key, core.atoms)
+    ? `atom`
+    : HAMT.has(key, core.selectors)
+    ? `selector`
+    : `readonly_selector`
+  return { key, type }
+}
+
+export function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>
+export function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>
+export function withdraw<T>(
+  token: StateToken<T>,
+  store: Store
+): Atom<T> | Selector<T>
+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> | TransactionToken<T>,
+  store: Store
+):
+  | Atom<T>
+  | ReadonlySelector<T>
+  | Selector<T>
+  | Transaction<T extends ƒn ? T : never> {
+  const core = target(store)
+  return (
+    HAMT.get(token.key, core.atoms) ??
+    HAMT.get(token.key, core.selectors) ??
+    HAMT.get(token.key, core.readonlySelectors) ??
+    HAMT.get(token.key, core.transactions)
+  )
+}
+
+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>
+    | 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 }),
+  }
+}
+
+export const getState__INTERNAL = <T>(
+  state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+  store: Store = IMPLICIT.STORE
+): T => {
+  if (isValueCached(state.key, store)) {
+    store.config.logger?.info(`>> read "${state.key}"`)
+    return readCachedValue(state.key, store)
+  }
+  if (`get` in state) {
+    store.config.logger?.info(`-> calc "${state.key}"`)
+    return computeSelectorState(state)
+  }
+  store.config.logger?.error(
+    `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
+  )
+  return state.default
+}

package/src/internal/index.ts

@@ -0,0 +1,12 @@
+export * from "./atom-internal"
+export * from "./families-internal"
+export * from "./get"
+export * from "./is-default"
+export * from "./logger"
+export * from "./operation"
+export * from "./selector-internal"
+export * from "./set"
+export * from "./store"
+export * from "./subscribe-internal"
+export * from "./timeline-internal"
+export * from "./transaction-internal"

package/src/internal/is-default.ts

@@ -0,0 +1,35 @@
+import type { Store } from "."
+import { target, IMPLICIT, traceAllSelectorAtoms } from "."
+
+export const isAtomDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): boolean => {
+  const core = target(store)
+  return core.atomsThatAreDefault.has(key)
+}
+
+export const markAtomAsDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key)
+}
+
+export const markAtomAsNotDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const core = target(store)
+  core.atomsThatAreDefault = new Set(target(store).atomsThatAreDefault)
+  core.atomsThatAreDefault.delete(key)
+}
+
+export const isSelectorDefault = (
+  key: string,
+  store: Store = IMPLICIT.STORE
+): boolean => {
+  const roots = traceAllSelectorAtoms(key, store)
+  return roots.every((root) => isAtomDefault(root.key, store))
+}

package/src/internal/logger.ts

@@ -0,0 +1,46 @@
+import { doNothing } from "~/packages/anvl/src/function"
+
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+
+export type Logger = Pick<Console, `error` | `info` | `warn`>
+export const LOG_LEVELS: ReadonlyArray<keyof Logger> = [
+  `info`,
+  `warn`,
+  `error`,
+] as const
+
+export const setLogLevel = (
+  preferredLevel: `error` | `info` | `warn` | null,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const { logger__INTERNAL } = store.config
+  if (preferredLevel === null) {
+    store.config.logger = null
+  } else {
+    store.config.logger = { ...console }
+    LOG_LEVELS.forEach((logLevel) => {
+      if (LOG_LEVELS.indexOf(logLevel) < LOG_LEVELS.indexOf(preferredLevel)) {
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+        store.config.logger![logLevel] = doNothing
+      } else {
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+        store.config.logger![logLevel] = logger__INTERNAL[logLevel]
+      }
+    })
+  }
+}
+
+export const useLogger = (
+  logger: Logger,
+  store: Store = IMPLICIT.STORE
+): void => {
+  const currentLogLevel =
+    store.config.logger === null
+      ? null
+      : LOG_LEVELS.find(
+          (logLevel) => store.config.logger?.[logLevel] !== doNothing
+        ) ?? null
+  store.config.logger__INTERNAL = { ...logger }
+  setLogLevel(currentLogLevel, store)
+}