atomirx 0.0.8 → 0.1.0

package/dist/core/types.d.ts

@@ -12,6 +12,14 @@ export declare const SYMBOL_ATOM: unique symbol;
  * Symbol to identify derived atoms.
  */
 export declare const SYMBOL_DERIVED: unique symbol;
+/**
+ * Symbol to identify scoped atoms (temporary wrappers for pool atoms).
+ */
+export declare const SYMBOL_SCOPED: unique symbol;
+/**
+ * Symbol to identify pool instances.
+ */
+export declare const SYMBOL_POOL: unique symbol;
 /**
  * Interface for objects that support the `.use()` plugin pattern.
  *
@@ -33,6 +41,7 @@ export interface Pipeable {
     use<TNew = void>(plugin: (source: this) => TNew): void extends TNew ? this : TNew extends object ? TNew extends {
         use: any;
     } ? TNew : Pipeable & TNew : TNew;
+    use<TPlugin extends object>(plugin: TPlugin): TPlugin extends any[] ? this : this & TPlugin;
 }
 /**
  * Optional metadata for atoms.
@@ -113,6 +122,11 @@ export interface MutableAtom<T> extends Atom<T>, Pipeable {
      * ```
      */
     dirty(): boolean;
+    /**
+     * Dispose the atom, aborting any pending operations and running cleanup functions.
+     * @internal - Used by pool when removing entries.
+     */
+    _dispose(): void;
 }
 /**
  * A derived (computed) atom that always returns Promise<T> for its value.
@@ -154,6 +168,11 @@ export interface DerivedAtom<T, F extends boolean = false> extends Atom<Promise<
      * - With fallback: T (guaranteed)
      */
     readonly staleValue: F extends true ? T : T | undefined;
+    /**
+     * Dispose the derived atom, cleaning up all subscriptions.
+     * @internal - Reserved for future use.
+     */
+    _dispose(): void;
 }
 /**
  * Union type for any atom (mutable or derived).
@@ -319,9 +338,9 @@ export interface EffectOptions {
     onError?: (error: unknown) => void;
 }
 export interface AtomirxMeta {
+    key?: string;
 }
 export interface EffectMeta extends AtomirxMeta {
-    key?: string;
 }
 /**
  * A function that returns a value when called.
@@ -362,3 +381,216 @@ export interface ModuleMeta {
 }
 export type Listener<T> = (value: T) => void;
 export type SingleOrMultipleListeners<T> = Listener<T> | Listener<T>[];
+/**
+ * Event emitted by pool's `on()` method.
+ *
+ * @template P - The type of params used to index entries
+ * @template T - The type of value stored in each entry
+ */
+export type PoolEvent<P, T> = {
+    type: "create";
+    params: P;
+    value: T;
+} | {
+    type: "change";
+    params: P;
+    value: T;
+} | {
+    type: "remove";
+    params: P;
+    value: T;
+};
+/**
+ * A scoped atom is a temporary wrapper around a real atom from a pool.
+ * It is only valid during a select() context and throws if accessed outside.
+ *
+ * ScopedAtoms prevent memory leaks by ensuring pool atom references
+ * cannot be stored and used after the computation completes.
+ *
+ * @template T - The type of value stored in the underlying atom
+ */
+export interface ScopedAtom<T> extends Atom<T> {
+    /** Symbol marker to identify scoped atom instances */
+    readonly [SYMBOL_SCOPED]: true;
+    /**
+     * Get the underlying real atom.
+     * @internal
+     * @throws Error if called outside select() context
+     */
+    _getAtom(): Atom<T>;
+    /**
+     * Mark this scoped atom as disposed.
+     * After disposal, any method call will throw.
+     * @internal
+     */
+    _dispose(): void;
+}
+/**
+ * Configuration options for creating a pool.
+ *
+ * @template P - The type of params used to index pool entries (must be object)
+ */
+export interface PoolOptions<P> {
+    /**
+     * Time in milliseconds before an unused entry is garbage collected.
+     * The GC timer resets on:
+     * - Entry creation
+     * - Value change
+     * - Access (get/set)
+     *
+     * GC is paused while the entry's value is a pending Promise.
+     */
+    gcTime: number;
+    /**
+     * Equality strategy for params comparison (default: "shallow").
+     * Used to determine if two params objects refer to the same cache entry.
+     *
+     * With default "shallow" equality:
+     * - `{ a: 1, b: 2 }` and `{ b: 2, a: 1 }` are considered equal (same entry)
+     * - Property order doesn't matter
+     *
+     * @example
+     * ```ts
+     * // Default shallow equality
+     * const userPool = pool((params: { id: string }) => fetchUser(params.id), {
+     *   gcTime: 60_000,
+     * });
+     * userPool.get({ id: "1" });
+     * userPool.get({ id: "1" }); // Same entry (shallow equal)
+     *
+     * // Custom equality
+     * const pool = pool((params: { a: number; b: number }) => params.a + params.b, {
+     *   gcTime: 60_000,
+     *   equals: (a, b) => a.a === b.a && a.b === b.b,
+     * });
+     * ```
+     */
+    equals?: Equality<P>;
+    /**
+     * Optional metadata for the pool.
+     */
+    meta?: PoolMeta;
+}
+/**
+ * Metadata for pool instances.
+ */
+export interface PoolMeta extends AtomirxMeta {
+    key?: string;
+}
+/**
+ * A pool is a collection of atoms indexed by params.
+ * Similar to atomFamily in Jotai/Recoil, but with automatic GC
+ * and ScopedAtom pattern to prevent memory leaks.
+ *
+ * @template P - The type of params used to index entries
+ * @template T - The type of value stored in each entry
+ *
+ * @example
+ * ```ts
+ * // Create a pool
+ * const userPool = pool(
+ *   (id: string) => fetchUser(id),
+ *   { gcTime: 60_000 }
+ * );
+ *
+ * // Public API (value-based)
+ * userPool.get("user-1");  // T | undefined
+ * userPool.set("user-1", newUser);
+ * userPool.remove("user-1");
+ *
+ * // In reactive context
+ * derived(({ read, from }) => {
+ *   const user$ = from(userPool, "user-1");
+ *   return read(user$);
+ * });
+ * ```
+ */
+export interface Pool<P, T> {
+    /** Symbol marker to identify pool instances */
+    readonly [SYMBOL_POOL]: true;
+    /** Optional metadata for the pool */
+    readonly meta?: PoolMeta;
+    /**
+     * Get the current value for params.
+     * Creates entry if it doesn't exist.
+     * Extends GC timer on access.
+     *
+     * @param params - The params to look up
+     * @returns The current value
+     */
+    get(params: P): T;
+    /**
+     * Set the value for params.
+     * Creates entry if it doesn't exist.
+     * Extends GC timer on access.
+     *
+     * @param params - The params to set
+     * @param value - The new value or reducer function
+     */
+    set(params: P, value: T | ((prev: T) => T)): void;
+    /**
+     * Check if an entry exists for params.
+     *
+     * @param params - The params to check
+     * @returns true if entry exists
+     */
+    has(params: P): boolean;
+    /**
+     * Remove an entry from the pool.
+     * Triggers onRemove listeners.
+     *
+     * @param params - The params to remove
+     */
+    remove(params: P): void;
+    /**
+     * Remove all entries from the pool.
+     * Triggers onRemove listeners for each entry.
+     */
+    clear(): void;
+    size(): number;
+    /**
+     * Iterate over all entries in the pool.
+     *
+     * @param callback - Called for each entry with (value, params)
+     */
+    forEach(callback: (value: T, params: P) => void): void;
+    /**
+     * Subscribe to pool events.
+     *
+     * Event types:
+     * - `create` - New entry created
+     * - `change` - Existing entry value changed
+     * - `remove` - Entry removed (manual or GC)
+     *
+     * @param listener - Called with event object containing type, params, and value
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```ts
+     * const unsub = userPool.on((event) => {
+     *   switch (event.type) {
+     *     case "create":
+     *       console.log("Created:", event.params, event.value);
+     *       break;
+     *     case "change":
+     *       console.log("Changed:", event.params, event.value);
+     *       break;
+     *     case "remove":
+     *       console.log("Removed:", event.params, event.value);
+     *       break;
+     *   }
+     * });
+     * ```
+     */
+    on(listener: (event: PoolEvent<P, T>) => void): VoidFunction;
+    /**
+     * Get the underlying atom for params.
+     * @internal - Use `from(pool, params)` in SelectContext instead.
+     */
+    _getAtom(params: P): MutableAtom<T>;
+    /**
+     * Subscribe to removal of a specific entry.
+     * @internal - Used by SelectContext for automatic recomputation.
+     */
+    _onRemove(params: P, listener: VoidFunction): VoidFunction;
+}

package/dist/core/withAbort.d.ts

@@ -0,0 +1,95 @@
+import { SelectContext } from './select';
+/**
+ * Extended context providing abort capabilities.
+ *
+ * Added to the select context when using `withAbort()` extension.
+ */
+export interface WithAbortContext {
+    /**
+     * AbortSignal that is automatically aborted when the effect/derived
+     * re-runs or is disposed. Use this to cancel async operations.
+     *
+     * @example
+     * ```ts
+     * effect(({ read, onCleanup }) => {
+     *   const ctx = context.use(withAbort(onCleanup));
+     *   fetch('/api/data', { signal: ctx.signal });
+     * });
+     * ```
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Manually trigger abort. Safe to call multiple times - subsequent
+     * calls after the first abort are no-ops.
+     *
+     * @example
+     * ```ts
+     * effect(({ read, onCleanup }) => {
+     *   const ctx = context.use(withAbort(onCleanup));
+     *   if (shouldCancel) ctx.abort();
+     * });
+     * ```
+     */
+    abort(): void;
+}
+/**
+ * Context extension that provides an AbortSignal for cancellation.
+ *
+ * Use this to cancel async operations (fetch, timers, etc.) when an
+ * effect or derived atom re-runs or is disposed. The signal is
+ * automatically aborted when the cleanup function runs.
+ *
+ * ## Usage Pattern
+ *
+ * The `withAbort` function takes an `onCleanup` registration function
+ * and returns a context extender that can be used with `.use()`:
+ *
+ * ```ts
+ * effect(({ read, onCleanup }) => {
+ *   const ctx = context.use(withAbort(onCleanup));
+ *
+ *   // Signal is aborted when effect re-runs or disposes
+ *   fetch('/api/data', { signal: ctx.signal })
+ *     .then(r => r.json())
+ *     .then(data => results$.set(data));
+ * });
+ * ```
+ *
+ * ## Key Features
+ *
+ * - **Automatic cleanup**: Signal aborts when `onCleanup` fires
+ * - **Manual abort**: Call `ctx.abort()` to cancel immediately
+ * - **Safe re-abort**: Multiple `abort()` calls are no-ops
+ *
+ * @param onCleanup - Cleanup registration function (from effect context)
+ * @returns Context extender function for use with `.use()`
+ *
+ * @example Basic fetch cancellation
+ * ```ts
+ * effect(({ read, onCleanup }) => {
+ *   const userId = read(userId$);
+ *   const ctx = context.use(withAbort(onCleanup));
+ *
+ *   fetch(`/api/users/${userId}`, { signal: ctx.signal })
+ *     .then(r => r.json())
+ *     .then(user => user$.set(user))
+ *     .catch(err => {
+ *       if (err.name !== 'AbortError') throw err;
+ *     });
+ * });
+ * ```
+ *
+ * @example With timeout
+ * ```ts
+ * effect(({ read, onCleanup }) => {
+ *   const ctx = context.use(withAbort(onCleanup));
+ *
+ *   // Abort after 5 seconds
+ *   const timeout = setTimeout(() => ctx.abort(), 5000);
+ *   onCleanup(() => clearTimeout(timeout));
+ *
+ *   fetch('/api/slow', { signal: ctx.signal });
+ * });
+ * ```
+ */
+export declare function withAbort(onCleanup: (cleanup: VoidFunction) => void): <TContext extends SelectContext>(context: TContext) => TContext & WithAbortContext;

package/dist/core/withReady.d.ts

@@ -4,7 +4,7 @@ import { Atom } from './types';
  * Extension interface that adds `ready()` method to SelectContext.
  * Used in derived atoms and effects to wait for non-null values.
  */
-export interface WithReadySelectContext {
+export interface WithReadyContext {
     /**
      * Wait for an atom to have a non-null/non-undefined value.
      *
@@ -109,7 +109,7 @@ export interface WithReadySelectContext {
  * @example
  * ```ts
  * // Used internally by derived() - you don't need to call this directly
- * const result = select((context) => fn(context.use(withReady())));
+ * const { result } = select((context) => fn(context.use(withReady())));
  * ```
  */
-export declare function withReady(): <TContext extends SelectContext>(context: TContext) => TContext & WithReadySelectContext;
+export declare function withReady(): <TContext extends SelectContext>(context: TContext) => TContext & WithReadyContext;

package/dist/devtools/constants.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LocalStorage key for devtools preferences.
+ * Global across all domains.
+ */
+export declare const STORAGE_KEY_PREFERENCES = "atomirx-devtools-preferences";
+/**
+ * Maximum history entries per entity.
+ */
+export declare const DEFAULT_MAX_HISTORY_SIZE = 50;
+/**
+ * Prefix for generating entity IDs.
+ */
+export declare const ENTITY_ID_PREFIX = "atomirx";
+/**
+ * Version for storage schema (for future migrations).
+ */
+export declare const STORAGE_VERSION = 1;
+/**
+ * Z-index for devtools panel.
+ */
+export declare const DEVTOOLS_Z_INDEX = 999999;
+/**
+ * Minimum panel size in pixels.
+ */
+export declare const MIN_PANEL_SIZE = 200;
+/**
+ * Maximum panel size in pixels.
+ */
+export declare const MAX_PANEL_SIZE = 800;
+/**
+ * Default panel size in pixels.
+ */
+export declare const DEFAULT_PANEL_SIZE = 300;
+/**
+ * Floating button size in pixels.
+ */
+export declare const FLOATING_BUTTON_SIZE = 48;
+/**
+ * Animation duration in milliseconds.
+ */
+export declare const ANIMATION_DURATION = 200;

package/dist/devtools/index.cjs

@@ -0,0 +1 @@
+"use strict";var D=Object.defineProperty;var L=(r,t,o)=>t in r?D(r,t,{enumerable:!0,configurable:!0,writable:!0,value:o}):r[t]=o;var a=(r,t,o)=>L(r,typeof t!="symbol"?t+"":t,o);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const y=require("../onErrorHook-DHBASmYw.cjs"),m=require("../onDispatchHook-C8yLzr-o.cjs");var g=typeof document<"u"?document.currentScript:null;const R="atomirx-devtools-preferences",E=50,S="atomirx",A=1,k=999999,I=200,b=800,C=300,w=48,T=200;let N=0;function f(r){return`${S}-${r}-${++N}`}class P{constructor(t=E){a(this,"_entities",new Map);a(this,"_logs",[]);a(this,"_listeners",new Set);a(this,"_maxHistorySize");a(this,"_maxLogSize",200);a(this,"_logIdCounter",0);a(this,"_version",0);a(this,"_cachedEntities",null);a(this,"_cachedLogs",null);a(this,"_notifyScheduled",!1);this._maxHistorySize=t}get entities(){return this._cachedEntities||(this._cachedEntities=new Map(this._entities)),this._cachedEntities}get logs(){return this._cachedLogs||(this._cachedLogs=[...this._logs]),this._cachedLogs}get version(){return this._version}addLog(t){const o={...t,id:`log-${++this._logIdCounter}`};this._logs=[o,...this._logs].slice(0,this._maxLogSize),this._notifyListeners()}clearLogs(){this._logs=[],this._notifyListeners()}registerMutable(t,o){const n=f("mutable"),e=Date.now(),s={id:n,type:"mutable",key:o,createdAt:e,lastUpdatedAt:e,changeCount:0,instanceRef:new WeakRef(t),subscriberCount:0,history:[]};return this._entities.set(n,s),this._notifyListeners(),this._trackMutableChanges(n,t),n}registerDerived(t,o,n=[]){const e=f("derived"),s=Date.now(),i={id:e,type:"derived",key:o,createdAt:s,lastUpdatedAt:s,changeCount:0,instanceRef:new WeakRef(t),dependencyIds:n,subscriberCount:0,history:[]};return this._entities.set(e,i),this._notifyListeners(),this._trackDerivedChanges(e,t),e}registerEffect(t,o,n=[]){const e=f("effect"),s=Date.now(),i={id:e,type:"effect",key:o,createdAt:s,lastUpdatedAt:s,changeCount:0,instanceRef:new WeakRef(t),dependencyIds:n,runCount:0,isActive:!0};return this._entities.set(e,i),this._notifyListeners(),e}registerPool(t,o,n){const e=f("pool"),s=Date.now(),i={id:e,type:"pool",key:o,createdAt:s,lastUpdatedAt:s,changeCount:0,instanceRef:new WeakRef(t),entryCount:0,gcTime:n};return this._entities.set(e,i),this._notifyListeners(),this._trackPoolChanges(e,t),e}registerModule(t,o){const n=f("module"),e=Date.now(),s={id:n,type:"module",key:o,createdAt:e,lastUpdatedAt:e,changeCount:0,instanceRef:new WeakRef(t)};return this._entities.set(n,s),this._notifyListeners(),n}_trackMutableChanges(t,o){let n=this._serializeValue(o.get());o.on(()=>{var h;const e=this._entities.get(t);if(!e)return;const s=this._serializeValue(o.get()),i=Date.now(),_={timestamp:i,previousValue:n,newValue:s};e.history=[_,...e.history].slice(0,this._maxHistorySize),e.changeCount++,e.lastUpdatedAt=i,n=s,this._notifyListeners();const u=(h=o.meta)==null?void 0:h.key;u&&this.addLog({type:"mutable.change",timestamp:i,atomKey:u})})}_trackDerivedChanges(t,o){let n=this._serializeValue(o.staleValue);o.on(()=>{var h;const e=this._entities.get(t);if(!e)return;const s=this._serializeValue(o.staleValue),i=Date.now(),_={timestamp:i,previousValue:n,newValue:s};e.history=[_,...e.history].slice(0,this._maxHistorySize),e.changeCount++,e.lastUpdatedAt=i,n=s,this._notifyListeners();const u=(h=o.meta)==null?void 0:h.key;u&&this.addLog({type:"derived.change",timestamp:i,atomKey:u})})}_trackPoolChanges(t,o){o.on(n=>{var i;const e=this._entities.get(t);if(!e)return;(n.type==="create"||n.type==="change")&&(e.changeCount++,e.lastUpdatedAt=Date.now()),this._updatePoolEntryCount(t,o),this._notifyListeners();const s=(i=o.meta)==null?void 0:i.key;if(s){const _={create:"pool.create",change:"pool.set",remove:"pool.remove"},u=this._serializeParams(n.params);this.addLog({type:_[n.type],timestamp:Date.now(),poolKey:s,params:u.slice(0,50)})}})}_serializeParams(t){try{return JSON.stringify(t)}catch{return String(t)}}_updatePoolEntryCount(t,o){const n=this._entities.get(t);n&&(n.entryCount=o.size())}_serializeValue(t){if(t===void 0)return"undefined";if(t===null)return"null";try{const o=new WeakSet;return JSON.stringify(t,(n,e)=>{if(typeof e=="object"&&e!==null){if(o.has(e))return"[Circular]";o.add(e)}return typeof e=="function"?"[Function]":typeof e=="symbol"?e.toString():e instanceof Error?`[Error: ${e.message}]`:e instanceof Promise?"[Promise]":e},2)}catch{return"[unserializable]"}}getByType(t){const o=[];for(const n of this._entities.values())n.type===t&&o.push(n);return o}get(t){return this._entities.get(t)}subscribe(t){return this._listeners.add(t),()=>{this._listeners.delete(t)}}getStats(){let t=0,o=0,n=0,e=0,s=0;for(const i of this._entities.values())switch(i.type){case"mutable":t++;break;case"derived":o++;break;case"effect":n++;break;case"pool":e++;break;case"module":s++;break}return{mutableCount:t,derivedCount:o,effectCount:n,poolCount:e,moduleCount:s,totalCount:t+o+n+e+s}}clear(){this._entities.clear(),this._notifyListeners()}_notifyListeners(){this._version++,this._cachedEntities=null,this._cachedLogs=null,!this._notifyScheduled&&(this._notifyScheduled=!0,queueMicrotask(()=>{this._notifyScheduled=!1;for(const t of this._listeners)try{t()}catch{}}))}}let l=null;function p(r){return l||(l=new P(r)),l}function O(){l==null||l.clear(),l=null}function U(){l=null}const v={BASE_URL:"/",DEV:!1,MODE:"production",PROD:!0,SSR:!1};function M(){try{if(typeof process<"u"&&process.env)return process.env.NODE_ENV==="production"}catch{}try{if(typeof{url:typeof document>"u"?require("url").pathToFileURL(__filename).href:g&&g.tagName.toUpperCase()==="SCRIPT"&&g.src||new URL("devtools/index.cjs",document.baseURI).href}<"u"&&v)return!0}catch{}return!1}let d=!1,c=null;function z(r={}){const{maxHistorySize:t=E,enableInProduction:o=!1}=r;if(M()&&!o)return console.warn("[atomirx-devtools] Devtools disabled in production. Use { enableInProduction: true } to enable."),()=>{};if(d&&c)return c;const n=p(t);return y.onCreateHook.override(e=>s=>{switch(e==null||e(s),s.type){case"mutable":n.registerMutable(s.instance,s.key);break;case"derived":n.registerDerived(s.instance,s.key);break;case"effect":n.registerEffect(s.instance,s.key);break;case"pool":n.registerPool(s.instance,s.key,0);break;case"module":typeof s.instance=="object"&&s.instance!==null&&n.registerModule(s.instance,s.key);break}}),m.onDispatchHook.override(e=>s=>{var i;e==null||e(s),(i=s.meta)!=null&&i.key&&n.addLog({type:"action.dispatch",timestamp:Date.now(),actionKey:s.meta.key,deps:JSON.stringify(s.deps).slice(0,100)})}),y.onErrorHook.override(e=>s=>{e==null||e(s),n.addLog({type:"error",timestamp:Date.now(),sourceType:s.source.type,sourceKey:s.source.key,error:String(s.error).slice(0,200)})}),d=!0,c=()=>{y.onCreateHook.reset(),m.onDispatchHook.reset(),y.onErrorHook.reset(),n.clear(),n.clearLogs(),d=!1,c=null},c}function F(){return d?p():null}function V(){return d}function H(){c&&c(),U(),d=!1,c=null}const x={isOpen:!1,position:"bottom",activeTab:"atoms",panelSize:300,searchText:{atoms:"",effects:"",pools:"",modules:"",logs:""},atomFilter:"all",selectedEntityId:null,showAtomValues:!1};exports.ANIMATION_DURATION=T;exports.DEFAULT_MAX_HISTORY_SIZE=E;exports.DEFAULT_PANEL_SIZE=C;exports.DEFAULT_PREFERENCES=x;exports.DEVTOOLS_Z_INDEX=k;exports.ENTITY_ID_PREFIX=S;exports.FLOATING_BUTTON_SIZE=w;exports.MAX_PANEL_SIZE=b;exports.MIN_PANEL_SIZE=I;exports.STORAGE_KEY_PREFERENCES=R;exports.STORAGE_VERSION=A;exports._resetDevtools=H;exports.getDevtoolsRegistry=F;exports.getRegistry=p;exports.isDevtoolsEnabled=V;exports.resetRegistry=O;exports.setupDevtools=z;

package/dist/devtools/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Atomirx Devtools - Core API
+ *
+ * This module provides the core devtools functionality for tracking
+ * and inspecting atomirx entities (atoms, derived, effects, pools, modules).
+ *
+ * @packageDocumentation
+ *
+ * @example Basic usage
+ * ```ts
+ * import { setupDevtools, getDevtoolsRegistry } from 'atomirx/devtools';
+ *
+ * // Enable devtools (call once at app startup)
+ * setupDevtools();
+ *
+ * // Access registry for custom integrations
+ * const registry = getDevtoolsRegistry();
+ * if (registry) {
+ *   registry.subscribe(() => {
+ *     console.log('Entities changed:', registry.getStats());
+ *   });
+ * }
+ * ```
+ */
+export { setupDevtools, getDevtoolsRegistry, isDevtoolsEnabled, _resetDevtools, } from './setup';
+export { getRegistry, resetRegistry } from './registry';
+export type { EntityType, EntityInfo, BaseEntityInfo, MutableEntityInfo, DerivedEntityInfo, EffectEntityInfo, PoolEntityInfo, ModuleEntityInfo, DevtoolsRegistry, DevtoolsStats, DevtoolsOptions, ChangeHistoryEntry, LogEntry, LogEntryType, ActionDispatchLogEntry, ErrorLogEntry, PoolCreateLogEntry, NewLogEntry, PanelPosition, DevtoolsTab, AtomFilter, DevtoolsPreferences, DevtoolsAtomState, } from './types';
+export { DEFAULT_PREFERENCES } from './types';
+export { STORAGE_KEY_PREFERENCES, DEFAULT_MAX_HISTORY_SIZE, ENTITY_ID_PREFIX, STORAGE_VERSION, DEVTOOLS_Z_INDEX, MIN_PANEL_SIZE, MAX_PANEL_SIZE, DEFAULT_PANEL_SIZE, FLOATING_BUTTON_SIZE, ANIMATION_DURATION, } from './constants';