@buoy-gg/jotai 7.0.41 → 7.0.43

package/lib/module/jotai/hooks/useJotaiAtomChanges.js

@@ -1,65 +1 @@
-"use strict";
-
-/**
- * Hook for consuming Jotai atom changes from the store
- *
- * The subscribe / filter / pause / clear plumbing is shared `useChangeLog`;
- * this file owns the jotai-specific filter, stats and atom registry.
- */
-
-import { useCallback, useMemo } from "react";
-import { useChangeLog, useSubscribedValue } from "@buoy-gg/shared-ui";
-import { jotaiStateStore } from "../utils/jotaiStateStore";
-function filterChanges(changes, filter) {
-  let filtered = changes;
-  if (filter.searchText) {
-    const search = filter.searchText.toLowerCase();
-    filtered = filtered.filter(c => c.atomLabel.toLowerCase().includes(search) || c.valuePreview.toLowerCase().includes(search) || c.changedKeys.some(k => k.toLowerCase().includes(search)));
-  }
-  if (filter.atomLabels && filter.atomLabels.length > 0) {
-    filtered = filtered.filter(c => filter.atomLabels.includes(c.atomLabel));
-  }
-  if (filter.onlyWithChanges) {
-    filtered = filtered.filter(c => c.hasValueChange);
-  }
-  return filtered;
-}
-const readAtoms = () => jotaiStateStore.getAtoms();
-const subscribeToAtoms = listener => jotaiStateStore.subscribeToAtoms(listener);
-export function useJotaiAtomChanges() {
-  const log = useChangeLog(jotaiStateStore, {
-    filterItems: filterChanges
-  });
-  const atoms = useSubscribedValue(readAtoms, subscribeToAtoms);
-  const stats = useMemo(() => {
-    const total = log.items.length;
-    const withChanges = log.items.filter(c => c.hasValueChange).length;
-    return {
-      totalChanges: total,
-      changesWithValueChange: withChanges,
-      changesWithoutValueChange: total - withChanges,
-      atomCount: atoms.length
-    };
-  }, [log.items, atoms]);
-  const atomLabels = useMemo(() => {
-    return jotaiStateStore.getUniqueAtomLabels();
-  }, [atoms]);
-  const getChangeById = useCallback(id => {
-    return jotaiStateStore.getAtomChangeById(id);
-  }, []);
-  return {
-    atomChanges: log.items,
-    filteredChanges: log.filteredItems,
-    filter: log.filter,
-    setFilter: log.setFilter,
-    stats,
-    atoms,
-    // Not the shared log.clear: the store also owns each atom's change
-    // count, and only clearAtomChanges resets those with the list.
-    clearChanges: jotaiStateStore.clearAtomChanges.bind(jotaiStateStore),
-    isEnabled: log.isEnabled,
-    toggleCapture: log.toggleCapture,
-    atomLabels,
-    getChangeById
-  };
-}
+"use strict";import{useCallback as h,useMemo as i}from"react";import{useChangeLog as m,useSubscribedValue as u}from"@buoy-gg/shared-ui";import{jotaiStateStore as o}from"../utils/jotaiStateStore";function c(e,t){let s=e;if(t.searchText){const a=t.searchText.toLowerCase();s=s.filter(r=>r.atomLabel.toLowerCase().includes(a)||r.valuePreview.toLowerCase().includes(a)||r.changedKeys.some(n=>n.toLowerCase().includes(a)))}if(t.atomLabels&&t.atomLabels.length>0){s=s.filter(a=>t.atomLabels.includes(a.atomLabel))}if(t.onlyWithChanges){s=s.filter(a=>a.hasValueChange)}return s}const C=()=>o.getAtoms();const b=e=>o.subscribeToAtoms(e);export function useJotaiAtomChanges(){const e=m(o,{filterItems:c});const t=u(C,b);const s=i(()=>{const n=e.items.length;const l=e.items.filter(g=>g.hasValueChange).length;return{totalChanges:n,changesWithValueChange:l,changesWithoutValueChange:n-l,atomCount:t.length}},[e.items,t]);const a=i(()=>{return o.getUniqueAtomLabels()},[t]);const r=h(n=>{return o.getAtomChangeById(n)},[]);return{atomChanges:e.items,filteredChanges:e.filteredItems,filter:e.filter,setFilter:e.setFilter,stats:s,atoms:t,clearChanges:o.clearAtomChanges.bind(o),isEnabled:e.isEnabled,toggleCapture:e.toggleCapture,atomLabels:a,getChangeById:r}}

package/lib/module/jotai/sync/jotaiSyncAdapter.js

@@ -1,303 +1 @@
-"use strict";
-
-import { jotaiStateStore } from "../utils/jotaiStateStore";
-import { WIRE_DETAIL_LIMIT_BYTES, createSyncAdapter, capDetail, detailByIdAction, expandKeyedArrays, memoByIdentity, onDeviceMarker, patchFromPath, readParams, readPath, refusalText, shapeSummary, suggestedPatch, toWire, typedEditViolations, unshapedLists } from "@buoy-gg/shared-ui";
-
-/**
- * Sentinel used in WIRE-FORM snapshots in place of raw prevValue/nextValue.
- * Same hazard as redux/zustand: up to 200 changes × 2 values on every
- * snapshot. Dashboards fetch values via `getChangeDetail`.
- */
-export const VALUE_ON_DEVICE = onDeviceMarker("Value", "Atom values stay on the device — fetched on demand via getChangeDetail / getAtomValue.");
-const isPlainObj = v => !!v && typeof v === "object" && !Array.isArray(v);
-
-/**
- * Merge a patch into an atom's value.
- *
- * An atom is not always an object — plenty hold a number, a string or a list —
- * so a merge only means anything when BOTH sides are plain objects. Anything
- * else replaces, which is what a caller asking to merge a scalar can only have
- * meant. Arrays replace too: the id-addressed form has already been expanded to
- * a whole array by the time this runs, so merging element-wise here would undo
- * the deletion half of that expansion.
- */
-function deepMergeInto(base, patch) {
-  if (!isPlainObj(base) || !isPlainObj(patch)) return patch;
-  const out = {
-    ...base
-  };
-  for (const [k, v] of Object.entries(patch)) out[k] = k in base ? deepMergeInto(base[k], v) : v;
-  return out;
-}
-
-/**
- * Does this patch write into the list at `path`? Only then is an
- * unchecked-shape warning about that list worth saying.
- */
-function touchesList(patch, path) {
-  let cur = patch;
-  for (const seg of path.split(".")) {
-    if (!isPlainObj(cur)) return false;
-    if (!(seg in cur)) return false;
-    cur = cur[seg];
-  }
-  return Array.isArray(cur) ? cur.length > 0 : !!cur && typeof cur === "object";
-}
-
-/**
- * Per-change wire cache — the store prepends and never mutates a recorded
- * change, so identity is a correct, self-invalidating key.
- */
-const toWireChange = memoByIdentity(change => ({
-  ...change,
-  prevValue: VALUE_ON_DEVICE,
-  nextValue: VALUE_ON_DEVICE
-}));
-const toWireValue = value => toWire(value, VALUE_ON_DEVICE);
-
-/**
- * Sync adapter for the jotai tool, consumed by @buoy-gg/external-sync's
- * `useExternalSync`.
- *
- * Atom changes are captured by watchAtoms(), independent of whether a
- * dashboard is watching — subscribing here only streams what the store
- * already records. The snapshot carries both the change timeline and the
- * atom registry (with each atom's current value) so the dashboard can render
- * the atom browser.
- *
- * v2: change-log prevValue/nextValue are replaced with on-device markers.
- * Dashboards fetch values via `getChangeDetail`. Oversized / unserializable
- * `atoms[].currentValue` uses the same marker and is fetched via `getAtomValue`.
- */
-export const jotaiSyncAdapter = createSyncAdapter({
-  version: 2,
-  getSnapshot: () => ({
-    changes: jotaiStateStore.getAtomChanges().map(toWireChange),
-    atoms: jotaiStateStore.getAtomSnapshots().map(atom => ({
-      ...atom,
-      currentValue: toWireValue(atom.currentValue)
-    }))
-  }),
-  subscribe: [onChange => jotaiStateStore.subscribe(onChange), onChange => jotaiStateStore.subscribeToAtoms(onChange)],
-  actions: {
-    clearEvents: () => {
-      jotaiStateStore.clearAtomChanges();
-    },
-    /**
-     * On-demand detail: one change's real prevValue/nextValue.
-     * The per-snapshot stream stays value-free; this is the explicit,
-     * size-guarded channel for the detail pane.
-     */
-    getChangeDetail: detailByIdAction(id => jotaiStateStore.getAtomChangeById(id), (change, cap) => ({
-      prevValue: cap(change.prevValue),
-      nextValue: cap(change.nextValue)
-    })),
-    /**
-     * On-demand current value for one atom. Wire-form snapshots replace
-     * oversized / unserializable `currentValue` with VALUE_ON_DEVICE.
-     */
-    getAtomValue: params => {
-      const {
-        label,
-        path
-      } = readParams(params);
-      if (!label) return {
-        found: false,
-        reason: "missing label"
-      };
-      const atom = jotaiStateStore.getAtom(label);
-      if (!atom) return {
-        found: false,
-        reason: "unknown label"
-      };
-      let currentValue;
-      try {
-        currentValue = atom.getValue();
-      } catch {
-        currentValue = undefined;
-      }
-      try {
-        JSON.stringify(currentValue);
-      } catch {
-        return {
-          found: true,
-          label,
-          currentValue: VALUE_ON_DEVICE
-        };
-      }
-      // One slice instead of the whole atom, when asked. The reason to want it
-      // is the engine's 24,000-character result cap: a caller that never saw the
-      // field it means to edit is left inventing a shape.
-      if (path) {
-        const at = readPath(currentValue, path);
-        if (!at.ok) return {
-          found: false,
-          reason: at.error
-        };
-        return {
-          found: true,
-          label,
-          path,
-          shape: shapeSummary(at.value),
-          currentValue: at.value
-        };
-      }
-      // `shape` BEFORE `currentValue`: a result is truncated by slicing the
-      // encoded string, so what is serialised first is what survives the cut,
-      // and the sketch does not grow with the data.
-      return {
-        found: true,
-        label,
-        ...(shapeSummary(currentValue) ? {
-          shape: shapeSummary(currentValue)
-        } : {}),
-        currentValue: capDetail(currentValue, WIRE_DETAIL_LIMIT_BYTES)
-      };
-    },
-    /**
-     * Compact current-value reader for a remote driver (MCP/LLM): registered
-     * atoms with light metadata; each atom's `currentValue` stays on the device
-     * unless `includeValues` is set. `writable` tells the caller which atoms
-     * can be set via `setAtom`.
-     */
-    listAtoms: params => {
-      const {
-        includeValues = false,
-        limit
-      } = readParams(params);
-      const all = jotaiStateStore.getAtoms();
-      const capped = typeof limit === "number" && limit > 0 ? all.slice(0, limit) : all;
-      const atoms = capped.map(a => {
-        let value;
-        if (includeValues) {
-          try {
-            value = a.getValue();
-          } catch {
-            value = undefined;
-          }
-        }
-        // The compact view is what a caller reaches for precisely because it
-        // does not want the data; the item shape of a list is the one thing it
-        // cannot infer without it, and it costs a line.
-        let shape;
-        try {
-          shape = shapeSummary(a.getValue());
-        } catch {
-          shape = undefined;
-        }
-        return {
-          label: a.label,
-          changes: a.changeCount,
-          writable: typeof a.setValue === "function",
-          ...(shape ? {
-            shape
-          } : {}),
-          ...(includeValues ? {
-            currentValue: value
-          } : {})
-        };
-      });
-      return {
-        atoms,
-        total: all.length,
-        returned: atoms.length,
-        includedValues: includeValues
-      };
-    },
-    /**
-     * Write to a writable atom (throws for unknown/read-only atoms).
-     *
-     * THIS USED TO BE FOUR LINES WITH NO GUARD. `setAtom` took whatever it was
-     * given and wrote it: a string over a number, `null` over a list the screen
-     * maps, a one-item array over a fifty-item one — every failure mode the
-     * zustand and react-query adapters refuse, jotai accepted silently. It was
-     * the only writable state tool with no protection at all, and it had never
-     * had an eval case, so nothing had ever measured it.
-     *
-     * It now takes the same three forms as `zustand.setState`, backed by the
-     * same shared implementations:
-     *   { value }                    replace (guarded unless force)
-     *   { value, merge: true }       merge a patch, id-addressed lists allowed
-     *   { path, value }              set one value; no depth to get wrong
-     */
-    setAtom: params => {
-      const {
-        label,
-        value,
-        merge,
-        path,
-        force
-      } = readParams(params);
-      if (!label) throw new Error("setAtom requires a `label`");
-      const atom = jotaiStateStore.getAtom(label);
-      let current;
-      try {
-        current = atom?.getValue();
-      } catch {
-        current = undefined;
-      }
-
-      // A replace with no guard is the old behaviour; keep it reachable via
-      // `force`, and keep it the ONLY way to get it.
-      let effective = value;
-      let keyedNotes = [];
-      let unchecked = [];
-      const merging = merge === true || path !== undefined;
-      if (path !== undefined) {
-        if (value === undefined) {
-          return {
-            ok: false,
-            error: `Refused: sent \`path\` without \`value\`. Say what to set "${path}" to.`
-          };
-        }
-        const built = patchFromPath(current, path, value);
-        if (!built.ok) return {
-          ok: false,
-          error: `Refused: ${built.error}`
-        };
-        effective = built.patch;
-      }
-      if (!force && merging && current !== undefined) {
-        const expanded = expandKeyedArrays(current, effective);
-        // See keyedArrays.ts: an added item whose id disagrees with the key it
-        // was sent under is ambiguous, and only this layer can say so.
-        if (expanded.error) {
-          return {
-            ok: false,
-            error: `Refused: ${expanded.error}`
-          };
-        }
-        effective = expanded.patch;
-        keyedNotes = expanded.notes;
-        unchecked = unshapedLists(current).filter(p => touchesList(effective, p));
-        const violations = typedEditViolations(current, effective, {
-          noun: "atom"
-        });
-        if (violations.length) {
-          const suggestion = suggestedPatch(effective, violations);
-          return {
-            ok: false,
-            error: refusalText(violations, "atom", suggestion),
-            violations,
-            ...(suggestion ? {
-              suggestedValue: suggestion
-            } : {})
-          };
-        }
-      }
-      jotaiStateStore.setAtomValue(label, merging ? deepMergeInto(current, effective) : effective);
-      return {
-        ok: true,
-        ...(path !== undefined ? {
-          path
-        } : {}),
-        ...(keyedNotes.length ? {
-          keyed: keyedNotes
-        } : {}),
-        ...(unchecked.length ? {
-          unchecked: unchecked.map(p => `\`${p}\` was empty, so nothing knows what its items look like and the shape of what you added was NOT checked.`)
-        } : {})
-      };
-    }
-  }
-});
+"use strict";import{jotaiStateStore as l}from"../utils/jotaiStateStore";import{WIRE_DETAIL_LIMIT_BYTES as k,createSyncAdapter as b,capDetail as v,detailByIdAction as w,expandKeyedArrays as S,memoByIdentity as E,onDeviceMarker as I,patchFromPath as x,readParams as p,readPath as C,refusalText as j,shapeSummary as h,suggestedPatch as D,toWire as T,typedEditViolations as L,unshapedLists as O}from"@buoy-gg/shared-ui";export const VALUE_ON_DEVICE=I("Value","Atom values stay on the device \u2014 fetched on demand via getChangeDetail / getAtomValue.");const y=e=>!!e&&typeof e==="object"&&!Array.isArray(e);function A(e,r){if(!y(e)||!y(r))return r;const t={...e};for(const[a,n]of Object.entries(r))t[a]=a in e?A(e[a],n):n;return t}function P(e,r){let t=e;for(const a of r.split(".")){if(!y(t))return false;if(!(a in t))return false;t=t[a]}return Array.isArray(t)?t.length>0:!!t&&typeof t==="object"}const _=E(e=>({...e,prevValue:VALUE_ON_DEVICE,nextValue:VALUE_ON_DEVICE}));const B=e=>T(e,VALUE_ON_DEVICE);export const jotaiSyncAdapter=b({version:2,getSnapshot:()=>({changes:l.getAtomChanges().map(_),atoms:l.getAtomSnapshots().map(e=>({...e,currentValue:B(e.currentValue)}))}),subscribe:[e=>l.subscribe(e),e=>l.subscribeToAtoms(e)],actions:{clearEvents:()=>{l.clearAtomChanges()},getChangeDetail:w(e=>l.getAtomChangeById(e),(e,r)=>({prevValue:r(e.prevValue),nextValue:r(e.nextValue)})),getAtomValue:e=>{const{label:r,path:t}=p(e);if(!r)return{found:false,reason:"missing label"};const a=l.getAtom(r);if(!a)return{found:false,reason:"unknown label"};let n;try{n=a.getValue()}catch{n=void 0}try{JSON.stringify(n)}catch{return{found:true,label:r,currentValue:VALUE_ON_DEVICE}}if(t){const i=C(n,t);if(!i.ok)return{found:false,reason:i.error};return{found:true,label:r,path:t,shape:h(i.value),currentValue:i.value}}return{found:true,label:r,...h(n)?{shape:h(n)}:{},currentValue:v(n,k)}},listAtoms:e=>{const{includeValues:r=false,limit:t}=p(e);const a=l.getAtoms();const n=typeof t==="number"&&t>0?a.slice(0,t):a;const i=n.map(c=>{let u;if(r){try{u=c.getValue()}catch{u=void 0}}let o;try{o=h(c.getValue())}catch{o=void 0}return{label:c.label,changes:c.changeCount,writable:typeof c.setValue==="function",...o?{shape:o}:{},...r?{currentValue:u}:{}}});return{atoms:i,total:a.length,returned:i.length,includedValues:r}},setAtom:e=>{const{label:r,value:t,merge:a,path:n,force:i}=p(e);if(!r)throw new Error("setAtom requires a `label`");const c=l.getAtom(r);let u;try{u=c?.getValue()}catch{u=void 0}let o=t;let g=[];let m=[];const V=a===true||n!==void 0;if(n!==void 0){if(t===void 0){return{ok:false,error:`Refused: sent \`path\` without \`value\`. Say what to set "${n}" to.`}}const s=x(u,n,t);if(!s.ok)return{ok:false,error:`Refused: ${s.error}`};o=s.patch}if(!i&&V&&u!==void 0){const s=S(u,o);if(s.error){return{ok:false,error:`Refused: ${s.error}`}}o=s.patch;g=s.notes;m=O(u).filter(f=>P(o,f));const d=L(u,o,{noun:"atom"});if(d.length){const f=D(o,d);return{ok:false,error:j(d,"atom",f),violations:d,...f?{suggestedValue:f}:{}}}}l.setAtomValue(r,V?A(u,o):o);return{ok:true,...n!==void 0?{path:n}:{},...g.length?{keyed:g}:{},...m.length?{unchecked:m.map(s=>`\`${s}\` was empty, so nothing knows what its items look like and the shape of what you added was NOT checked.`)}:{}}}}});

package/lib/module/jotai/types/index.js

@@ -1 +1 @@
-"use strict";
+"use strict";