@buoy-gg/jotai 7.0.38 → 7.0.39

package/lib/module/jotai/utils/snapshotProvider.js

@@ -1 +1,214 @@
-"use strict";import{createRestoreScope,emptyRestoreResult,failedRestore,registerStateSnapshotProvider,unionKeys}from"@buoy-gg/shared-ui";import{boundedDeepEqual}from"@buoy-gg/shared-ui/dataViewer";import{jotaiStateStore}from"./jotaiStateStore";function status(){const e=jotaiStateStore.getAtoms();if(0===e.length)return{canCapture:!1,canRestore:!1,detail:"No Jotai atoms registered — pass your atoms to watchAtoms() / watchDefaultStoreAtoms()"};const t=e.filter(e=>e.setValue).length;return{canCapture:!0,canRestore:t>0,detail:t<e.length?e.length-t+" derived atom(s) recompute automatically and are not restored":void 0}}async function capture(){const e=[],t={};let o=0;for(const a of jotaiStateStore.getAtoms())try{const s=a.getValue();if("function"==typeof s){e.push(`atom "${a.label}": function value not capturable`);continue}a.setValue||(o+=1),t[a.label]={value:s,writable:Boolean(a.setValue)}}catch(t){e.push(`atom "${a.label}": capture failed (${String(t)})`)}return o>0&&e.push(`${o} derived atom(s) captured for inspection only (recompute on restore)`),{data:{atoms:t},warnings:e}}async function restore(e,t){const o=e,a=createRestoreScope(t),s=emptyRestoreResult();if(!o?.atoms)return failedRestore("empty jotai snapshot");let r=0;for(const[e,t]of Object.entries(o.atoms)){if(!a.allows(e))continue;if(!t.writable){r+=1;continue}const o=jotaiStateStore.getAtom(e);if(o)if(o.setValue)try{o.setValue(t.value),s.applied+=1}catch(t){s.skipped.push({id:e,reason:String(t)}),s.ok=!1}else s.skipped.push({id:e,reason:"atom is now read-only (derived)"});else s.skipped.push({id:e,reason:"atom not registered (renamed, or unwatched since snapshot?)"})}r>0&&s.warnings.push(`${r} derived atom(s) left to recompute`);const n=a.excludedWarning("atom(s)");return n&&s.warnings.push(n),s}async function previewItems(e,t){const o=e?.atoms??{},a=void 0===t,s={};if(a)for(const e of jotaiStateStore.getAtoms())try{s[e.label]={value:e.getValue(),writable:Boolean(e.setValue)}}catch{}else Object.assign(s,t?.atoms??{});const r=[],n=[];for(const e of unionKeys(s,o)){if(!(e in o)){a?n.push(`atom "${e}" not in snapshot — untouched`):r.push({key:e,label:e,verdict:"removed",oldValue:s[e]?.value});continue}const t=o[e],i=e in s&&boundedDeepEqual(s[e].value,t.value);if(t.writable){if(a){const t=jotaiStateStore.getAtom(e);if(!t){r.push({key:e,label:e,verdict:"wont-apply",reason:"atom not registered (renamed, or unwatched since snapshot?)"});continue}if(!t.setValue){r.push({key:e,label:e,verdict:"wont-apply",reason:"atom is now read-only (derived)"});continue}}e in s?i?r.push({key:e,label:e,verdict:"unchanged"}):r.push({key:e,label:e,verdict:"changed",oldValue:s[e].value,newValue:t.value}):r.push({key:e,label:e,verdict:"added",newValue:t.value})}else r.push({key:e,label:e,verdict:i?"unchanged":"recomputes",reason:i?void 0:"derived atom — recomputes from its sources",oldValue:s[e]?.value,newValue:t.value})}return{items:r,notes:n}}registerStateSnapshotProvider({id:"jotai",label:"Jotai",status:status,capture:capture,restore:restore,previewItems:previewItems});
+"use strict";
+
+/**
+ * Time Machine snapshot provider for Jotai.
+ *
+ * Registered into @buoy-gg/shared-ui's stateSnapshotRegistry at module init;
+ * consumed by @buoy-gg/time-machine.
+ *
+ * Coverage is opt-in by nature: only atoms the app passed to `watchAtoms` /
+ * `watchDefaultStoreAtoms` are visible. Derived (read-only) atoms are captured
+ * for inspection but never restored — they recompute from their sources.
+ * Caveat (documented): atoms with custom write functions (`atomWithReducer`)
+ * receive ACTIONS through `store.set`, so restoring a raw value can misbehave;
+ * nothing in the registry distinguishes them from plain atoms.
+ */
+import { createRestoreScope, emptyRestoreResult, failedRestore, registerStateSnapshotProvider, unionKeys } from "@buoy-gg/shared-ui";
+import { boundedDeepEqual } from "@buoy-gg/shared-ui/dataViewer";
+import { jotaiStateStore } from "./jotaiStateStore";
+function status() {
+  const atoms = jotaiStateStore.getAtoms();
+  if (atoms.length === 0) {
+    return {
+      canCapture: false,
+      canRestore: false,
+      detail: "No Jotai atoms registered — pass your atoms to watchAtoms() / watchDefaultStoreAtoms()"
+    };
+  }
+  const writable = atoms.filter(a => a.setValue).length;
+  return {
+    canCapture: true,
+    canRestore: writable > 0,
+    detail: writable < atoms.length ? `${atoms.length - writable} derived atom(s) recompute automatically and are not restored` : undefined
+  };
+}
+async function capture() {
+  const warnings = [];
+  const atoms = {};
+  let derived = 0;
+  for (const info of jotaiStateStore.getAtoms()) {
+    try {
+      const value = info.getValue();
+      if (typeof value === "function") {
+        warnings.push(`atom "${info.label}": function value not capturable`);
+        continue;
+      }
+      if (!info.setValue) derived += 1;
+      atoms[info.label] = {
+        value,
+        writable: Boolean(info.setValue)
+      };
+    } catch (e) {
+      warnings.push(`atom "${info.label}": capture failed (${String(e)})`);
+    }
+  }
+  if (derived > 0) {
+    warnings.push(`${derived} derived atom(s) captured for inspection only (recompute on restore)`);
+  }
+  return {
+    data: {
+      atoms
+    },
+    warnings
+  };
+}
+async function restore(data, options) {
+  const snapshot = data;
+  const scope = createRestoreScope(options);
+  const result = emptyRestoreResult();
+  if (!snapshot?.atoms) {
+    return failedRestore("empty jotai snapshot");
+  }
+  let derived = 0;
+  for (const [label, entry] of Object.entries(snapshot.atoms)) {
+    if (!scope.allows(label)) continue;
+    if (!entry.writable) {
+      derived += 1;
+      continue;
+    }
+    const info = jotaiStateStore.getAtom(label);
+    if (!info) {
+      result.skipped.push({
+        id: label,
+        reason: "atom not registered (renamed, or unwatched since snapshot?)"
+      });
+      continue;
+    }
+    if (!info.setValue) {
+      result.skipped.push({
+        id: label,
+        reason: "atom is now read-only (derived)"
+      });
+      continue;
+    }
+    try {
+      info.setValue(entry.value);
+      result.applied += 1;
+    } catch (e) {
+      result.skipped.push({
+        id: label,
+        reason: String(e)
+      });
+      result.ok = false;
+    }
+  }
+  if (derived > 0) {
+    result.warnings.push(`${derived} derived atom(s) left to recompute`);
+  }
+  const excludedWarning = scope.excludedWarning("atom(s)");
+  if (excludedWarning) result.warnings.push(excludedWarning);
+  return result;
+}
+
+/** Per-atom restore preview. `base` omitted = compare against live atoms. */
+async function previewItems(target, base) {
+  const targetAtoms = target?.atoms ?? {};
+  const liveMode = base === undefined;
+  const baseAtoms = {};
+  if (liveMode) {
+    for (const info of jotaiStateStore.getAtoms()) {
+      try {
+        baseAtoms[info.label] = {
+          value: info.getValue(),
+          writable: Boolean(info.setValue)
+        };
+      } catch {
+        // unreadable atom — treated as absent
+      }
+    }
+  } else {
+    Object.assign(baseAtoms, base?.atoms ?? {});
+  }
+  const items = [];
+  const notes = [];
+  for (const label of unionKeys(baseAtoms, targetAtoms)) {
+    const inTarget = label in targetAtoms;
+    if (!inTarget) {
+      if (liveMode) notes.push(`atom "${label}" not in snapshot — untouched`);else items.push({
+        key: label,
+        label,
+        verdict: "removed",
+        oldValue: baseAtoms[label]?.value
+      });
+      continue;
+    }
+    const entry = targetAtoms[label];
+    const equal = label in baseAtoms && boundedDeepEqual(baseAtoms[label].value, entry.value);
+    if (!entry.writable) {
+      items.push({
+        key: label,
+        label,
+        verdict: equal ? "unchanged" : "recomputes",
+        reason: equal ? undefined : "derived atom — recomputes from its sources",
+        oldValue: baseAtoms[label]?.value,
+        newValue: entry.value
+      });
+      continue;
+    }
+    if (liveMode) {
+      const info = jotaiStateStore.getAtom(label);
+      if (!info) {
+        items.push({
+          key: label,
+          label,
+          verdict: "wont-apply",
+          reason: "atom not registered (renamed, or unwatched since snapshot?)"
+        });
+        continue;
+      }
+      if (!info.setValue) {
+        items.push({
+          key: label,
+          label,
+          verdict: "wont-apply",
+          reason: "atom is now read-only (derived)"
+        });
+        continue;
+      }
+    }
+    if (!(label in baseAtoms)) {
+      items.push({
+        key: label,
+        label,
+        verdict: "added",
+        newValue: entry.value
+      });
+    } else if (equal) {
+      items.push({
+        key: label,
+        label,
+        verdict: "unchanged"
+      });
+    } else {
+      items.push({
+        key: label,
+        label,
+        verdict: "changed",
+        oldValue: baseAtoms[label].value,
+        newValue: entry.value
+      });
+    }
+  }
+  return {
+    items,
+    notes
+  };
+}
+registerStateSnapshotProvider({
+  id: "jotai",
+  label: "Jotai",
+  status,
+  capture,
+  restore,
+  previewItems
+});

package/lib/module/jotai/utils/testIDs.js

@@ -1 +1,82 @@
-"use strict";export const JOTAI_TEST_ID="buoy-jotai";export function slugForTestID(t){return String(t??"").toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")||"unknown"}export function changeRowTestID(t,o){return`buoy-jotai-row-${slugForTestID(t)}-${o}`}export function atomRowTestID(t){return`buoy-jotai-atom-${slugForTestID(t)}`}export function buildChangeRowTestIDs(t){const o=new Map,e=new Map;for(const n of t){const t=(o.get(n.atomLabel)??0)+1;o.set(n.atomLabel,t),e.set(n.id,changeRowTestID(n.atomLabel,t))}return e}
+"use strict";
+
+/**
+ * Jotai tool test handles.
+ *
+ * Every tappable and every value the e2e suite reads back is addressed
+ * `buoy-jotai-<thing>`. Two rules need explaining, and the second is the one
+ * this tool does not share with any other.
+ *
+ * **A change row's handle carries an ORDINAL, and it counts per ATOM.** Same
+ * reason as the Zustand tool: an atom a screen writes to fifty times produces
+ * fifty separate, equally real rows, and addressing them by label alone would
+ * give fifty views one handle — Detox fails a *matcher* that hits more than
+ * one element, so the suite would break on `toExist()` before any assertion,
+ * with an error that says nothing about duplicate changes. The handle is
+ * `buoy-jotai-row-<slug(atomLabel)>-<n>`, n counting back from the newest row
+ * for that atom (1 = newest). Deliberately relative: an atom change has no
+ * identity a host could know in advance, and what a test CAN know is "the
+ * write I just fired is the newest change to that atom". Read and tap in one
+ * beat — a row's ordinal moves the instant another change lands.
+ *
+ * **The ordinal is per ATOM, and one write can move several atoms.** This is
+ * where jotai differs from every store-shaped tool. Atoms form a dependency
+ * graph, and this tool watches NODES: a single `set` on a primitive atom
+ * notifies every mounted derived atom whose value actually moved, so one
+ * press can add a row under three different labels — and add nothing at all
+ * under a fourth whose recomputed value happened to be unchanged. Counting
+ * ordinals across the whole list would make a row's handle depend on how many
+ * *other* atoms the write happened to touch, which is exactly the thing a
+ * test of a graph must not assume.
+ *
+ * **An atom row's handle does NOT carry an ordinal.** An atom is registered
+ * once under a label that is unique by construction
+ * (`jotaiStateStore.registerAtom` returns early on a label it already holds,
+ * and `watchAtoms` marks the atom with a per-label symbol), so
+ * `buoy-jotai-atom-<slug(label)>` is as stable as the registration itself —
+ * and unlike a change, it is a thing the host knows the name of before the
+ * app has booted.
+ *
+ * The suite mirrors these rules in CommonJS (`example-dev-build/utils/
+ * jotaiBench.js`) and asserts the two agree — Detox runs in Node on the host
+ * and cannot import TypeScript.
+ */
+
+/** Prefix every handle in this tool shares. */
+export const JOTAI_TEST_ID = "buoy-jotai";
+
+/** `jbenchCount` → `jbenchcount`. Shared with every Buoy tool. */
+export function slugForTestID(value) {
+  return String(value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+
+/**
+ * Handle for one change row: `buoy-jotai-row-jbenchcount-1`.
+ *
+ * `ordinal` is 1-based and counts back from the newest row for this atom.
+ */
+export function changeRowTestID(atomLabel, ordinal) {
+  return `${JOTAI_TEST_ID}-row-${slugForTestID(atomLabel)}-${ordinal}`;
+}
+
+/** Handle for one atom row in the browser: `buoy-jotai-atom-jbenchcount`. */
+export function atomRowTestID(atomLabel) {
+  return `${JOTAI_TEST_ID}-atom-${slugForTestID(atomLabel)}`;
+}
+
+/**
+ * Row handle per change id for one rendered list, newest-first.
+ *
+ * Built once for the whole list rather than per row, because an ordinal is a
+ * fact about the list and a row cannot compute its own.
+ */
+export function buildChangeRowTestIDs(changes) {
+  const seen = new Map();
+  const handles = new Map();
+  for (const change of changes) {
+    const ordinal = (seen.get(change.atomLabel) ?? 0) + 1;
+    seen.set(change.atomLabel, ordinal);
+    handles.set(change.id, changeRowTestID(change.atomLabel, ordinal));
+  }
+  return handles;
+}

package/lib/module/jotai/utils/watchAtoms.js

@@ -1 +1,157 @@
-"use strict";import{jotaiStateStore}from"./jotaiStateStore";import{classifyAtomWrite}from"./writeSemantics";export function watchAtoms(t,e,o){const a=!1!==o?.enabled,r=[];for(const[o,i]of Object.entries(e)){const e=i,c=Symbol.for(`@@buoy-jotai/watched/${o}`);if(e[c])continue;let n;e[c]=!0;try{n=t.get(i)}catch{n=void 0}const s="function"==typeof i.write,u=t.set&&s?e=>{t.set(i,e)}:void 0;jotaiStateStore.registerAtom(o,()=>{try{return t.get(i)}catch{return}},u,s?classifyAtomWrite(i):void 0),a&&jotaiStateStore.addAtomChange({atomLabel:o,prevValue:void 0,nextValue:n,category:"initial"});const l=t.sub(i,()=>{try{const e=t.get(i);jotaiStateStore.addAtomChange({atomLabel:o,prevValue:n,nextValue:e,category:"write"}),n=e}catch{}});r.push(()=>{l(),delete e[c],jotaiStateStore.unregisterAtom(o)})}return()=>r.forEach(t=>t())}export function watchDefaultStoreAtoms(t,e){let o;try{const{getDefaultStore:t}=require("jotai/vanilla");o=t()}catch{try{const{getDefaultStore:t}=require("jotai");o=t()}catch{return console.warn("[@buoy-gg/jotai] Could not find getDefaultStore from jotai. Pass the store explicitly via watchAtoms(store, atoms) instead."),()=>{}}}return watchAtoms(o,t,e)}export function isAtomWatched(t){return void 0!==jotaiStateStore.getAtom(t)}
+"use strict";
+
+/**
+ * Buoy Jotai DevTools — Atom instrumentation
+ *
+ * watchAtoms() — RECOMMENDED. Pass a Jotai store and a named atom map.
+ * Uses store.sub() to observe each atom externally. Never touches atom internals.
+ *
+ * watchDefaultStoreAtoms() — Convenience wrapper that uses getDefaultStore().
+ */
+
+import { jotaiStateStore } from "./jotaiStateStore";
+import { classifyAtomWrite } from "./writeSemantics";
+
+/** Any Jotai atom — alias for Atom<unknown> for readability */
+
+/** Minimal store shape — what Jotai's createStore() / getDefaultStore() returns */
+
+/**
+ * Watch a set of Jotai atoms for value changes.
+ *
+ * Pass a Jotai store and an object mapping display names to atoms.
+ * Uses store.sub() to observe each atom — never modifies atom internals.
+ *
+ * @example
+ * ```tsx
+ * import { getDefaultStore } from 'jotai';
+ * import { watchAtoms } from '@buoy-gg/jotai';
+ * import { countAtom } from './atoms/count';
+ * import { authAtom } from './atoms/auth';
+ *
+ * watchAtoms(getDefaultStore(), {
+ *   countAtom,
+ *   authAtom,
+ * });
+ * ```
+ *
+ * @param store  - Jotai store (from createStore() or getDefaultStore())
+ * @param atoms  - Object mapping display labels to Jotai atoms
+ * @param options - Optional configuration
+ * @returns Cleanup function that removes all subscriptions
+ */
+export function watchAtoms(store, atoms, options) {
+  const enabled = options?.enabled !== false;
+  const cleanups = [];
+  for (const [label, atom] of Object.entries(atoms)) {
+    // Skip if already watched under this label
+    const atomAny = atom;
+    const watchedKey = Symbol.for(`@@buoy-jotai/watched/${label}`);
+    if (atomAny[watchedKey]) continue;
+    atomAny[watchedKey] = true;
+    let prevValue;
+    try {
+      prevValue = store.get(atom);
+    } catch {
+      prevValue = undefined;
+    }
+
+    // Register the atom for the browser view. A setter is captured only when
+    // the store supports `set` AND the atom itself is writable (has a `write`
+    // function — primitive atoms get a default one, read-only derived atoms
+    // have none). Deriveds used to get a setter that threw inside jotai at
+    // set time; now they're correctly reported as read-only up front.
+    const isWritable = typeof atom.write === "function";
+    const setter = store.set && isWritable ? value => {
+      store.set(atom, value);
+    } : undefined;
+    jotaiStateStore.registerAtom(label, () => {
+      try {
+        return store.get(atom);
+      } catch {
+        return undefined;
+      }
+    }, setter,
+    // "value" = jotai's shared defaultWrite (a primitive atom: store.set
+    // stores the value). "action" = a custom write receiving the value as
+    // its argument — still writable, but the editor says so.
+    isWritable ? classifyAtomWrite(atom) : undefined);
+
+    // Record initial value
+    if (enabled) {
+      jotaiStateStore.addAtomChange({
+        atomLabel: label,
+        prevValue: undefined,
+        nextValue: prevValue,
+        category: "initial"
+      });
+    }
+
+    // Subscribe to future changes
+    const unsubscribe = store.sub(atom, () => {
+      try {
+        const nextValue = store.get(atom);
+        jotaiStateStore.addAtomChange({
+          atomLabel: label,
+          prevValue,
+          nextValue,
+          category: "write"
+        });
+        prevValue = nextValue;
+      } catch {
+        // Silently catch — our bug must never propagate into the store
+      }
+    });
+    cleanups.push(() => {
+      unsubscribe();
+      delete atomAny[watchedKey];
+      jotaiStateStore.unregisterAtom(label);
+    });
+  }
+  return () => cleanups.forEach(fn => fn());
+}
+
+/**
+ * Watch atoms using Jotai's default store (no Provider setup required).
+ *
+ * Convenience wrapper around watchAtoms() — auto-imports getDefaultStore.
+ *
+ * @example
+ * ```tsx
+ * import { watchDefaultStoreAtoms } from '@buoy-gg/jotai';
+ * import { countAtom, authAtom } from './atoms';
+ *
+ * watchDefaultStoreAtoms({ countAtom, authAtom });
+ * ```
+ */
+export function watchDefaultStoreAtoms(atoms, options) {
+  // Dynamic import to avoid bundling jotai internals when not needed
+  let store;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const {
+      getDefaultStore
+    } = require("jotai/vanilla");
+    store = getDefaultStore();
+  } catch {
+    // Try the main jotai entry (React Native)
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const {
+        getDefaultStore
+      } = require("jotai");
+      store = getDefaultStore();
+    } catch {
+      console.warn("[@buoy-gg/jotai] Could not find getDefaultStore from jotai. " + "Pass the store explicitly via watchAtoms(store, atoms) instead.");
+      return () => {};
+    }
+  }
+  return watchAtoms(store, atoms, options);
+}
+
+/**
+ * Check if an atom label is currently being watched
+ */
+export function isAtomWatched(label) {
+  return jotaiStateStore.getAtom(label) !== undefined;
+}

package/lib/module/jotai/utils/writeSemantics.js

@@ -1 +1,43 @@
-"use strict";import{atom as probeAtom}from"jotai/vanilla";const probe=probeAtom(null),DEFAULT_WRITE=probe.write,DEFAULT_WRITE_SOURCE="function"==typeof DEFAULT_WRITE?String(DEFAULT_WRITE):null;export function classifyAtomWrite(t){const o=t,n=o?.write;return"function"!=typeof n?"action":n===DEFAULT_WRITE||null!==o&&"init"in o&&null!==DEFAULT_WRITE_SOURCE&&String(n)===DEFAULT_WRITE_SOURCE?"value":"action"}
+"use strict";
+
+/**
+ * What does `store.set(atom, x)` DO with x?
+ *
+ * jotai's `atom(initialValue)` gives every primitive atom the SAME shared
+ * `defaultWrite` function (see jotai/src/vanilla/atom.ts): it stores x as the
+ * atom's new value (or calls it with the previous value when x is a
+ * function). Any other `write` is app code — `atomWithReducer` receives
+ * ACTIONS, `atomWithStorage` persists as a side effect, a custom write can do
+ * anything — so a raw value handed to `store.set` may not mean "set to this".
+ *
+ * The tool's editor needs that distinction to be honest: a "value" atom edits
+ * like plain data; an "action" atom is still writable (the MCP `setAtom` and
+ * Time Machine restore already write to them) but the editor says what the
+ * write actually does.
+ *
+ * Detection: a probe primitive atom exposes this jotai instance's
+ * `defaultWrite`; identity match is exact. The `toString` fallback covers an
+ * app that somehow bundles a second jotai copy (its atoms carry a different —
+ * but textually identical — defaultWrite instance). An unrecognized write
+ * classifies as "action", which only makes the editor more cautious.
+ */
+
+import { atom as probeAtom } from "jotai/vanilla";
+const probe = probeAtom(null);
+const DEFAULT_WRITE = probe.write;
+const DEFAULT_WRITE_SOURCE = typeof DEFAULT_WRITE === "function" ? String(DEFAULT_WRITE) : null;
+
+/** Classify a writable atom's write. Call only when `atom.write` exists. */
+export function classifyAtomWrite(candidate) {
+  const atomLike = candidate;
+  const write = atomLike?.write;
+  if (typeof write !== "function") return "action";
+  if (write === DEFAULT_WRITE) return "value";
+  // Dual-copy fallback: a primitive atom from another jotai instance holds
+  // its own value (`init` present) and its write's source is the library's
+  // defaultWrite verbatim.
+  if (atomLike !== null && "init" in atomLike && DEFAULT_WRITE_SOURCE !== null && String(write) === DEFAULT_WRITE_SOURCE) {
+    return "value";
+  }
+  return "action";
+}

package/lib/module/preset.js

@@ -1 +1,87 @@
-"use strict";import{JotaiModal}from"./jotai/components/JotaiModal";import{JotaiIcon}from"./jotai/components/JotaiIcon";import{createToolFactory,defineToolPreset}from"@buoy-gg/shared-ui";import{jsx as _jsx}from"react/jsx-runtime";export const jotaiToolPreset=defineToolPreset({id:"jotai",name:"JOTAI",description:"Jotai atom & state inspector",slot:"both",icon:({size:o})=>_jsx(JotaiIcon,{size:o}),component:JotaiModal,props:{enableSharedModalDimensions:!1}});export const createJotaiTool=createToolFactory(jotaiToolPreset,o=>({enableSharedModalDimensions:o.enableSharedModalDimensions??!1}),o=>({icon:({size:e})=>_jsx(JotaiIcon,{size:e,color:o.iconColor})}));
+"use strict";
+
+/**
+ * Pre-configured Jotai DevTools preset for FloatingDevTools
+ *
+ * ZERO-CONFIG: This preset is auto-discovered by FloatingDevTools!
+ * Just install @buoy-gg/jotai and call watchAtoms() with your atoms.
+ *
+ * @example Automatic (recommended)
+ * ```tsx
+ * import { getDefaultStore } from 'jotai';
+ * import { watchAtoms } from '@buoy-gg/jotai';
+ * import { countAtom, authAtom } from './atoms';
+ *
+ * watchAtoms(getDefaultStore(), { countAtom, authAtom });
+ *
+ * // The Jotai tool appears automatically in FloatingDevTools!
+ * <FloatingDevTools />
+ * ```
+ *
+ * @example Manual (only for custom configuration)
+ * ```tsx
+ * import { createJotaiTool } from '@buoy-gg/jotai';
+ *
+ * const customJotaiTool = createJotaiTool({
+ *   name: "ATOMS",
+ *   iconColor: "#6C47FF",
+ * });
+ *
+ * <FloatingDevTools apps={[customJotaiTool]} />
+ * ```
+ */
+
+import { JotaiModal } from "./jotai/components/JotaiModal";
+import { JotaiIcon } from "./jotai/components/JotaiIcon";
+import { createToolFactory, defineToolPreset } from "@buoy-gg/shared-ui";
+
+/**
+ * Pre-configured Jotai DevTools preset for FloatingDevTools.
+ * Includes:
+ * - Live atom change monitoring
+ * - Atom value inspection (JSON viewer)
+ * - Value diff visualization (tree + split)
+ * - Filter by atom label
+ * - Changed keys tracking for object atoms
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export const jotaiToolPreset = defineToolPreset({
+  id: "jotai",
+  name: "JOTAI",
+  description: "Jotai atom & state inspector",
+  slot: "both",
+  icon: ({
+    size
+  }) => /*#__PURE__*/_jsx(JotaiIcon, {
+    size: size
+  }),
+  component: JotaiModal,
+  props: {
+    enableSharedModalDimensions: false
+  }
+});
+
+/**
+ * Create a custom Jotai DevTools configuration.
+ * Use this if you want to override default settings.
+ *
+ * @example
+ * ```tsx
+ * import { createJotaiTool } from '@buoy-gg/jotai';
+ *
+ * const myJotaiTool = createJotaiTool({
+ *   name: "ATOMS",
+ *   iconColor: "#6C47FF",
+ * });
+ * ```
+ */
+export const createJotaiTool = createToolFactory(jotaiToolPreset, options => ({
+  enableSharedModalDimensions: options.enableSharedModalDimensions ?? false
+}), options => ({
+  icon: ({
+    size
+  }) => /*#__PURE__*/_jsx(JotaiIcon, {
+    size: size,
+    color: options.iconColor
+  })
+}));

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,gCAAgC,CAAC;AAKxC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK5D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAKtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAK9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,YAAY,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAOnF,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,2BAA2B,EAAE,MAAM,gDAAgD,CAAC;AAC7F,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAK3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAKjE,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAKvB,gBAAgB;AAChB,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC"}

package/lib/typescript/jotai/components/JotaiAtomBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JotaiAtomBrowser.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomBrowser.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAI9C,UAAU,qBAAqB;IAC7B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAuDD,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,WAAW,EACX,UAAU,GACX,EAAE,qBAAqB,+BA4FvB"}

package/lib/typescript/jotai/components/JotaiAtomChangeItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JotaiAtomChangeItem.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomChangeItem.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAsB,MAAM,UAAU,CAAC;AAGpE,UAAU,wBAAwB;IAChC,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;IAC3C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAsDD,eAAO,MAAM,mBAAmB,gEAwB9B,CAAC"}

package/lib/typescript/jotai/components/JotaiAtomDetailContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JotaiAtomDetailContent.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomDetailContent.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAA+C,MAAM,OAAO,CAAC;AA6BpE,OAAO,KAAK,EACV,eAAe,EAEf,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAwOlB,UAAU,2BAA2B;IACnC,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,WAAW,CAAC,EAAE,mBAAmB,CAAC;CACnC;AAED,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,OAAO,EACP,aAAa,EACb,aAAa,EACb,qBAA6B,EAC7B,WAAsB,GACvB,EAAE,2BAA2B,qBAkL7B;AAED,wBAAgB,qBAAqB,CAAC,EACpC,MAAM,EACN,OAAO,EACP,aAAa,EACb,aAAa,GACd,EAAE;IACD,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC,4BAcA"}

package/lib/typescript/jotai/components/JotaiAtomValueDetailContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JotaiAtomValueDetailContent.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiAtomValueDetailContent.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AA2BH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAoE9C,UAAU,gCAAgC;IACxC,IAAI,EAAE,aAAa,CAAC;IACpB,kEAAkE;IAClE,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,EACJ,aAAa,GACd,EAAE,gCAAgC,+BA6OlC"}

package/lib/typescript/jotai/components/JotaiEventFilterView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JotaiEventFilterView.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiEventFilterView.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAG9C,UAAU,yBAAyB;IACjC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAQD,wBAAgB,oBAAoB,CAAC,EACnC,eAAe,EACf,eAAe,EACf,YAAY,EACZ,KAAK,GACN,EAAE,yBAAyB,+BAqB3B"}

package/lib/typescript/jotai/components/JotaiIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JotaiIcon.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiIcon.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/lib/typescript/jotai/components/JotaiModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JotaiModal.d.ts","sourceRoot":"","sources":["../../../../src/jotai/components/JotaiModal.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA8CH,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,UAAU,CAAC;AAsCjE,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,OAAO,EACP,MAAM,EACN,UAAU,EACV,2BAAmC,EACnC,MAAc,EACd,UAAU,EACV,uBAAuB,EACvB,iBAAiB,EACjB,cAAc,EACd,YAAY,GACb,EAAE,eAAe,sCAuqBjB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,GAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAM,+BAGpE"}

package/lib/typescript/jotai/hooks/useJotaiAtomChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useJotaiAtomChanges.d.ts","sourceRoot":"","sources":["../../../../src/jotai/hooks/useJotaiAtomChanges.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5E,MAAM,WAAW,yBAAyB;IACxC,gCAAgC;IAChC,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,+CAA+C;IAC/C,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,8BAA8B;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,6BAA6B;IAC7B,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC,CAAC;IAC7D,wCAAwC;IACxC,KAAK,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,yBAAyB,EAAE,MAAM,CAAC;QAClC,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,2BAA2B;IAC3B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,iCAAiC;IACjC,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,iCAAiC;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,4BAA4B;IAC5B,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,6BAA6B;IAC7B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,uBAAuB;IACvB,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,eAAe,GAAG,SAAS,CAAC;CAC5D;AA8BD,wBAAgB,mBAAmB,IAAI,yBAAyB,CAwC/D"}

package/lib/typescript/jotai/sync/jotaiSyncAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jotaiSyncAdapter.d.ts","sourceRoot":"","sources":["../../../../src/jotai/sync/jotaiSyncAdapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAqBhD;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;EAG3B,CAAC;AAmFF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;IAiBzB;;;;OAIG;;;;;IAQH;;;OAGG;4BACqB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsC/B;;;;;OAKG;yBACkB,OAAO;;;;;;;;;;;;;;;IAsC5B;;;;;;;;;;;;;;;OAeG;uBACgB,OAAO;;;;;;;;;;;;;;;EAiEF,CAAC"}

package/lib/typescript/jotai/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/jotai/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAC1B,OAAO,GACP,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IAGxB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3C,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAChC;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,6EAA6E;IAC7E,iBAAiB,CAAC,EAAE,mBAAmB,CAAC;IACxC;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;IACnD;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/lib/typescript/jotai/utils/jotaiStateStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jotaiStateStore.d.ts","sourceRoot":"","sources":["../../../../src/jotai/utils/jotaiStateStore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,SAAS,EAIV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EACnB,MAAM,UAAU,CAAC;AAuClB,cAAM,eAAgB,SAAQ,SAAS,CAAC,eAAe,CAAC;IACtD,OAAO,CAAC,KAAK,CAAyC;IACtD,OAAO,CAAC,aAAa,CAAoD;IAIzE,aAAa,CAAC,MAAM,EAAE;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,OAAO,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;QACnB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;KAC/B,GAAG,IAAI;IAsCR,cAAc,IAAI,eAAe,EAAE;IAInC,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI1D,gBAAgB,IAAI,IAAI;IAUxB;;;;OAIG;IACH,gBAAgB,IAAI,iBAAiB,EAAE;IAkBvC;;;;;OAKG;IACH,mBAAmB,CACjB,OAAO,EAAE,eAAe,EAAE,EAC1B,aAAa,EAAE,iBAAiB,EAAE,GACjC,IAAI;IAoEP;;;OAGG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IAIhE;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,IAAI;IAY5D,YAAY,CACV,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,OAAO,EACvB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EACnC,SAAS,CAAC,EAAE,OAAO,GAAG,QAAQ,GAC7B,IAAI;IAgBP;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAWjD,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKnC,QAAQ,IAAI,aAAa,EAAE;IAI3B,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIjD,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAMnC,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,eAAe,EAAE;IA4BzD,QAAQ;;;;;;IAYR,mBAAmB,IAAI,MAAM,EAAE;IAM/B,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMhC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,GAAG,MAAM,IAAI;IAKxE,OAAO,CAAC,mBAAmB;CAI5B;AAED,eAAO,MAAM,eAAe,iBAAwB,CAAC"}

package/lib/typescript/jotai/utils/snapshotProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotProvider.d.ts","sourceRoot":"","sources":["../../../../src/jotai/utils/snapshotProvider.ts"],"names":[],"mappings":""}

package/lib/typescript/jotai/utils/testIDs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testIDs.d.ts","sourceRoot":"","sources":["../../../../src/jotai/utils/testIDs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,+CAA+C;AAC/C,eAAO,MAAM,aAAa,eAAe,CAAC;AAE1C,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAOpD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EAAE,GACzB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CASrB"}

package/lib/typescript/jotai/utils/watchAtoms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchAtoms.d.ts","sourceRoot":"","sources":["../../../../src/jotai/utils/watchAtoms.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAGlC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,+DAA+D;AAC/D,KAAK,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;AAE7B,mFAAmF;AACnF,UAAU,aAAa;IACrB,GAAG,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC;IACzC,GAAG,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IACzD;;;;;;OAMG;IACH,GAAG,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,IAAI,CAiFZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,MAAM,IAAI,CA2BZ;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,YAAY,EAAE,aAAa,EAAE,CAAC"}