atomirx 0.0.8 → 0.1.1

package/dist/devtools/index.js

@@ -0,0 +1,429 @@
+var k = Object.defineProperty;
+var b = (r, t, n) => t in r ? k(r, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : r[t] = n;
+var a = (r, t, n) => b(r, typeof t != "symbol" ? t + "" : t, n);
+import { o as y, a as g } from "../onErrorHook-BGGy3tqK.js";
+import { o as p } from "../onDispatchHook-SKbiIUaJ.js";
+const N = "atomirx-devtools-preferences", m = 50, L = "atomirx", z = 1, T = 999999, O = 200, V = 800, M = 300, U = 48, v = 200;
+let S = 0;
+function f(r) {
+  return `${L}-${r}-${++S}`;
+}
+class w {
+  constructor(t = m) {
+    a(this, "_entities", /* @__PURE__ */ new Map());
+    a(this, "_logs", []);
+    a(this, "_listeners", /* @__PURE__ */ 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 n = {
+      ...t,
+      id: `log-${++this._logIdCounter}`
+    };
+    this._logs = [n, ...this._logs].slice(0, this._maxLogSize), this._notifyListeners();
+  }
+  clearLogs() {
+    this._logs = [], this._notifyListeners();
+  }
+  /**
+   * Register a mutable atom.
+   */
+  registerMutable(t, n) {
+    const i = f("mutable"), e = Date.now(), s = {
+      id: i,
+      type: "mutable",
+      key: n,
+      createdAt: e,
+      lastUpdatedAt: e,
+      changeCount: 0,
+      instanceRef: new WeakRef(t),
+      subscriberCount: 0,
+      history: []
+    };
+    return this._entities.set(i, s), this._notifyListeners(), this._trackMutableChanges(i, t), i;
+  }
+  /**
+   * Register a derived atom.
+   */
+  registerDerived(t, n, i = []) {
+    const e = f("derived"), s = Date.now(), o = {
+      id: e,
+      type: "derived",
+      key: n,
+      createdAt: s,
+      lastUpdatedAt: s,
+      changeCount: 0,
+      instanceRef: new WeakRef(t),
+      dependencyIds: i,
+      subscriberCount: 0,
+      history: []
+    };
+    return this._entities.set(e, o), this._notifyListeners(), this._trackDerivedChanges(e, t), e;
+  }
+  /**
+   * Register an effect.
+   */
+  registerEffect(t, n, i = []) {
+    const e = f("effect"), s = Date.now(), o = {
+      id: e,
+      type: "effect",
+      key: n,
+      createdAt: s,
+      lastUpdatedAt: s,
+      changeCount: 0,
+      instanceRef: new WeakRef(t),
+      dependencyIds: i,
+      runCount: 0,
+      isActive: !0
+    };
+    return this._entities.set(e, o), this._notifyListeners(), e;
+  }
+  /**
+   * Register a pool.
+   */
+  registerPool(t, n, i) {
+    const e = f("pool"), s = Date.now(), o = {
+      id: e,
+      type: "pool",
+      key: n,
+      createdAt: s,
+      lastUpdatedAt: s,
+      changeCount: 0,
+      instanceRef: new WeakRef(t),
+      entryCount: 0,
+      gcTime: i
+    };
+    return this._entities.set(e, o), this._notifyListeners(), this._trackPoolChanges(e, t), e;
+  }
+  /**
+   * Register a module.
+   */
+  registerModule(t, n) {
+    const i = f("module"), e = Date.now(), s = {
+      id: i,
+      type: "module",
+      key: n,
+      createdAt: e,
+      lastUpdatedAt: e,
+      changeCount: 0,
+      instanceRef: new WeakRef(t)
+    };
+    return this._entities.set(i, s), this._notifyListeners(), i;
+  }
+  /**
+   * Track changes to a mutable atom.
+   */
+  _trackMutableChanges(t, n) {
+    let i = this._serializeValue(n.get());
+    n.on(() => {
+      var _;
+      const e = this._entities.get(t);
+      if (!e) return;
+      const s = this._serializeValue(n.get()), o = Date.now(), h = {
+        timestamp: o,
+        previousValue: i,
+        newValue: s
+      };
+      e.history = [h, ...e.history].slice(
+        0,
+        this._maxHistorySize
+      ), e.changeCount++, e.lastUpdatedAt = o, i = s, this._notifyListeners();
+      const u = (_ = n.meta) == null ? void 0 : _.key;
+      u && this.addLog({
+        type: "mutable.change",
+        timestamp: o,
+        atomKey: u
+      });
+    });
+  }
+  /**
+   * Track changes to a derived atom.
+   */
+  _trackDerivedChanges(t, n) {
+    let i = this._serializeValue(n.staleValue);
+    n.on(() => {
+      var _;
+      const e = this._entities.get(t);
+      if (!e) return;
+      const s = this._serializeValue(n.staleValue), o = Date.now(), h = {
+        timestamp: o,
+        previousValue: i,
+        newValue: s
+      };
+      e.history = [h, ...e.history].slice(
+        0,
+        this._maxHistorySize
+      ), e.changeCount++, e.lastUpdatedAt = o, i = s, this._notifyListeners();
+      const u = (_ = n.meta) == null ? void 0 : _.key;
+      u && this.addLog({
+        type: "derived.change",
+        timestamp: o,
+        atomKey: u
+      });
+    });
+  }
+  /**
+   * Track changes to a pool and log events.
+   */
+  _trackPoolChanges(t, n) {
+    n.on((i) => {
+      var o;
+      const e = this._entities.get(t);
+      if (!e) return;
+      (i.type === "create" || i.type === "change") && (e.changeCount++, e.lastUpdatedAt = Date.now()), this._updatePoolEntryCount(t, n), this._notifyListeners();
+      const s = (o = n.meta) == null ? void 0 : o.key;
+      if (s) {
+        const h = {
+          create: "pool.create",
+          change: "pool.set",
+          // "change" maps to "set" for logging
+          remove: "pool.remove"
+        }, u = this._serializeParams(i.params);
+        this.addLog({
+          type: h[i.type],
+          timestamp: Date.now(),
+          poolKey: s,
+          params: u.slice(0, 50)
+          // Truncate long params
+        });
+      }
+    });
+  }
+  /**
+   * Serialize params for logging.
+   */
+  _serializeParams(t) {
+    try {
+      return JSON.stringify(t);
+    } catch {
+      return String(t);
+    }
+  }
+  /**
+   * Update pool entry count.
+   */
+  _updatePoolEntryCount(t, n) {
+    const i = this._entities.get(t);
+    i && (i.entryCount = n.size());
+  }
+  /**
+   * Serialize a value for history storage.
+   */
+  _serializeValue(t) {
+    if (t === void 0) return "undefined";
+    if (t === null) return "null";
+    try {
+      const n = /* @__PURE__ */ new WeakSet();
+      return JSON.stringify(
+        t,
+        (i, e) => {
+          if (typeof e == "object" && e !== null) {
+            if (n.has(e)) return "[Circular]";
+            n.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 n = [];
+    for (const i of this._entities.values())
+      i.type === t && n.push(i);
+    return n;
+  }
+  get(t) {
+    return this._entities.get(t);
+  }
+  subscribe(t) {
+    return this._listeners.add(t), () => {
+      this._listeners.delete(t);
+    };
+  }
+  getStats() {
+    let t = 0, n = 0, i = 0, e = 0, s = 0;
+    for (const o of this._entities.values())
+      switch (o.type) {
+        case "mutable":
+          t++;
+          break;
+        case "derived":
+          n++;
+          break;
+        case "effect":
+          i++;
+          break;
+        case "pool":
+          e++;
+          break;
+        case "module":
+          s++;
+          break;
+      }
+    return {
+      mutableCount: t,
+      derivedCount: n,
+      effectCount: i,
+      poolCount: e,
+      moduleCount: s,
+      totalCount: t + n + i + e + s
+    };
+  }
+  clear() {
+    this._entities.clear(), this._notifyListeners();
+  }
+  /**
+   * Schedule listener notifications.
+   * Uses queueMicrotask to defer notifications and avoid updating React state during render.
+   * Multiple calls within the same microtask are batched into a single notification.
+   */
+  _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 E(r) {
+  return l || (l = new w(r)), l;
+}
+function x() {
+  l == null || l.clear(), l = null;
+}
+function C() {
+  l = null;
+}
+const D = { BASE_URL: "/", DEV: !1, MODE: "production", PROD: !0, SSR: !1 };
+function A() {
+  try {
+    if (typeof process < "u" && process.env)
+      return process.env.NODE_ENV === "production";
+  } catch {
+  }
+  try {
+    if (typeof import.meta < "u" && D)
+      return !0;
+  } catch {
+  }
+  return !1;
+}
+let d = !1, c = null;
+function F(r = {}) {
+  const {
+    maxHistorySize: t = m,
+    enableInProduction: n = !1
+  } = r;
+  if (A() && !n)
+    return console.warn(
+      "[atomirx-devtools] Devtools disabled in production. Use { enableInProduction: true } to enable."
+    ), () => {
+    };
+  if (d && c)
+    return c;
+  const i = E(t);
+  return y.override((e) => (s) => {
+    switch (e == null || e(s), s.type) {
+      case "mutable":
+        i.registerMutable(s.instance, s.key);
+        break;
+      case "derived":
+        i.registerDerived(s.instance, s.key);
+        break;
+      case "effect":
+        i.registerEffect(s.instance, s.key);
+        break;
+      case "pool":
+        i.registerPool(s.instance, s.key, 0);
+        break;
+      case "module":
+        typeof s.instance == "object" && s.instance !== null && i.registerModule(s.instance, s.key);
+        break;
+    }
+  }), p.override((e) => (s) => {
+    var o;
+    e == null || e(s), (o = s.meta) != null && o.key && i.addLog({
+      type: "action.dispatch",
+      timestamp: Date.now(),
+      actionKey: s.meta.key,
+      deps: JSON.stringify(s.deps).slice(0, 100)
+    });
+  }), g.override((e) => (s) => {
+    e == null || e(s), i.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.reset(), p.reset(), g.reset(), i.clear(), i.clearLogs(), d = !1, c = null;
+  }, c;
+}
+function H() {
+  return d ? E() : null;
+}
+function K() {
+  return d;
+}
+function W() {
+  c && c(), C(), d = !1, c = null;
+}
+const Z = {
+  isOpen: !1,
+  position: "bottom",
+  activeTab: "atoms",
+  panelSize: 300,
+  searchText: {
+    atoms: "",
+    effects: "",
+    pools: "",
+    modules: "",
+    logs: ""
+  },
+  atomFilter: "all",
+  selectedEntityId: null,
+  showAtomValues: !1
+};
+export {
+  v as ANIMATION_DURATION,
+  m as DEFAULT_MAX_HISTORY_SIZE,
+  M as DEFAULT_PANEL_SIZE,
+  Z as DEFAULT_PREFERENCES,
+  T as DEVTOOLS_Z_INDEX,
+  L as ENTITY_ID_PREFIX,
+  U as FLOATING_BUTTON_SIZE,
+  V as MAX_PANEL_SIZE,
+  O as MIN_PANEL_SIZE,
+  N as STORAGE_KEY_PREFERENCES,
+  z as STORAGE_VERSION,
+  W as _resetDevtools,
+  H as getDevtoolsRegistry,
+  E as getRegistry,
+  K as isDevtoolsEnabled,
+  x as resetRegistry,
+  F as setupDevtools
+};

package/dist/devtools/registry.d.ts

@@ -0,0 +1,98 @@
+import { EntityInfo, EntityType, DevtoolsRegistry, DevtoolsStats, LogEntry, NewLogEntry } from './types';
+import { MutableAtom, DerivedAtom, Pool } from '../core/types';
+import { Effect } from '../core/effect';
+/**
+ * Generate a unique entity ID.
+ */
+export declare function generateEntityId(type: EntityType): string;
+/**
+ * Internal registry implementation.
+ */
+declare class DevtoolsRegistryImpl implements DevtoolsRegistry {
+    private _entities;
+    private _logs;
+    private _listeners;
+    private _maxHistorySize;
+    private _maxLogSize;
+    private _logIdCounter;
+    constructor(maxHistorySize?: number);
+    private _version;
+    private _cachedEntities;
+    private _cachedLogs;
+    private _notifyScheduled;
+    get entities(): ReadonlyMap<string, EntityInfo>;
+    get logs(): readonly LogEntry[];
+    get version(): number;
+    addLog(entry: NewLogEntry): void;
+    clearLogs(): void;
+    /**
+     * Register a mutable atom.
+     */
+    registerMutable(instance: MutableAtom<unknown>, key: string | undefined): string;
+    /**
+     * Register a derived atom.
+     */
+    registerDerived(instance: DerivedAtom<unknown, boolean>, key: string | undefined, dependencyIds?: string[]): string;
+    /**
+     * Register an effect.
+     */
+    registerEffect(instance: Effect, key: string | undefined, dependencyIds?: string[]): string;
+    /**
+     * Register a pool.
+     */
+    registerPool(instance: Pool<unknown, unknown>, key: string | undefined, gcTime: number): string;
+    /**
+     * Register a module.
+     */
+    registerModule(instance: object, key: string | undefined): string;
+    /**
+     * Track changes to a mutable atom.
+     */
+    private _trackMutableChanges;
+    /**
+     * Track changes to a derived atom.
+     */
+    private _trackDerivedChanges;
+    /**
+     * Track changes to a pool and log events.
+     */
+    private _trackPoolChanges;
+    /**
+     * Serialize params for logging.
+     */
+    private _serializeParams;
+    /**
+     * Update pool entry count.
+     */
+    private _updatePoolEntryCount;
+    /**
+     * Serialize a value for history storage.
+     */
+    private _serializeValue;
+    getByType<T extends EntityType>(type: T): EntityInfo[];
+    get(id: string): EntityInfo | undefined;
+    subscribe(listener: () => void): () => void;
+    getStats(): DevtoolsStats;
+    clear(): void;
+    /**
+     * Schedule listener notifications.
+     * Uses queueMicrotask to defer notifications and avoid updating React state during render.
+     * Multiple calls within the same microtask are batched into a single notification.
+     */
+    private _notifyListeners;
+}
+/**
+ * Get or create the global devtools registry.
+ */
+export declare function getRegistry(maxHistorySize?: number): DevtoolsRegistryImpl;
+/**
+ * Reset the global registry (for testing).
+ * Note: This also resets the isEnabled state in setup.ts
+ */
+export declare function resetRegistry(): void;
+/**
+ * Force set the global registry to null (for testing).
+ * @internal
+ */
+export declare function _forceResetRegistry(): void;
+export {};

package/dist/devtools/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/devtools/setup.d.ts

@@ -0,0 +1,61 @@
+import { DevtoolsOptions, DevtoolsRegistry } from './types';
+/**
+ * Set up devtools to track all atomirx entities.
+ *
+ * This function hooks into the entity creation system and registers
+ * all atoms, derived atoms, effects, pools, and modules with the
+ * devtools registry for inspection.
+ *
+ * @param options - Configuration options
+ * @returns Cleanup function to disable devtools
+ *
+ * @example Basic setup
+ * ```ts
+ * import { setupDevtools } from 'atomirx/devtools';
+ *
+ * // Enable devtools (disabled in production by default)
+ * const cleanup = setupDevtools();
+ *
+ * // Later: disable devtools
+ * cleanup();
+ * ```
+ *
+ * @example Enable in production
+ * ```ts
+ * setupDevtools({ enableInProduction: true });
+ * ```
+ *
+ * @example Custom history size
+ * ```ts
+ * setupDevtools({ maxHistorySize: 100 });
+ * ```
+ */
+export declare function setupDevtools(options?: DevtoolsOptions): () => void;
+/**
+ * Get the devtools registry.
+ *
+ * Returns the registry instance if devtools is enabled,
+ * otherwise returns null.
+ *
+ * @returns The registry or null if devtools not enabled
+ *
+ * @example
+ * ```ts
+ * import { getDevtoolsRegistry } from 'atomirx/devtools';
+ *
+ * const registry = getDevtoolsRegistry();
+ * if (registry) {
+ *   console.log('Stats:', registry.getStats());
+ * }
+ * ```
+ */
+export declare function getDevtoolsRegistry(): DevtoolsRegistry | null;
+/**
+ * Check if devtools is currently enabled.
+ */
+export declare function isDevtoolsEnabled(): boolean;
+/**
+ * Reset devtools state (for testing).
+ * @internal
+ */
+export declare function _resetDevtools(): void;