@ai-matrx/design-system 0.18.2 → 0.18.3

package/dist/data-table/index.js

@@ -2375,6 +2375,10 @@ function materialIdentity(material) {
   }
   return `payload:${id}`;
 }
+function snapshotContent(snapshot) {
+  const { sourceId, label, payload, coverage, unsavedChanges, omissions, sections, limits } = snapshot;
+  return JSON.stringify({ sourceId, label, payload, coverage, unsavedChanges, omissions, sections, limits });
+}
 function useFence() {
   const mounted = React12.useRef(true);
   const nextId = React12.useRef(0);
@@ -2477,7 +2481,7 @@ function ContentTransferMenuSession({ source, surface, label, projection, sectio
       const captured = await material.capture(signal);
       sourceMaterial = { id: captured.snapshot.sourceId, label: captured.snapshot.label, capture: async () => captured };
     } else if ("kind" in material) {
-      sourceMaterial = applyMenuProjection ? { id: "direct", label: sourceLabel, capture: async () => directSource(material, { label: sourceLabel, ...projection ? { projection } : {}, ...sections ? { sections } : {} }) } : material;
+      sourceMaterial = { id: materialIdentity(material), label: sourceLabel, capture: async () => directSource(material, { sourceId: materialIdentity(material), label: sourceLabel, ...applyMenuProjection && projection ? { projection } : {}, ...applyMenuProjection && sections ? { sections } : {} }) };
     } else if (applyMenuProjection && (projection || sections)) {
       sourceMaterial = {
         id: material.id,
@@ -2494,7 +2498,7 @@ function ContentTransferMenuSession({ source, surface, label, projection, sectio
     } else {
       sourceMaterial = material;
     }
-    const raw = "kind" in sourceMaterial ? directSource(sourceMaterial) : await sourceMaterial.capture({ scope, signal });
+    const raw = await sourceMaterial.capture({ scope, signal });
     const constrained = resolveTransferPreferences(providerPreferences, preferences, raw.snapshot.limits);
     const result = await capture({ id: raw.snapshot.sourceId, label: raw.snapshot.label, capture: async () => ({ ...raw, snapshot: { ...raw.snapshot, limits: constrained.limits } }) }, signal, scope);
     if (scope !== "all-matching" || !collectPages) return result;
@@ -2554,31 +2558,117 @@ function ContentTransferMenuSession({ source, surface, label, projection, sectio
       fence.finish(controller);
     }
   }, [captureOne, capturePrimary, fence, formatSources, initialScope, preferences, providerPreferences, report, transport]);
-  const openWorkspace = React12.useCallback(async (key = primaryWorkspaceKey, variant) => {
-    const variantMaterial = variant && "kind" in variant.source ? { id: `variant:${key}`, label: variant.label, capture: async () => directSource(variant.source, { label: variant.label }) } : variant?.source;
-    const captureWorkspace = variantMaterial ? (scope, signal) => captureOne(variantMaterial, scope, signal, true) : capturePrimary;
-    workspaceCaptures.current.set(key, captureWorkspace);
-    if (workspaces[key]) {
-      setWorkspaceKey(key);
-      setWorkspaceOpen(true);
-      return;
-    }
-    const { controller, id } = fence.begin();
-    try {
-      const result = await captureWorkspace(initialScope, controller.signal);
-      if (!fence.valid(id, controller)) return;
-      const resolved = resolveTransferPreferences(providerPreferences, preferences, result.snapshot.limits);
-      const original = createDraft(result.snapshot);
-      const base = { ...result, key, original, draft: original, scope: initialScope, preferences: resolved, ...result.collectionError ? { error: result.collectionError } : {} };
-      setWorkspaces((current) => ({ ...current, [key]: { ...base, draft: rebuild(base, initialControls(base)) } }));
-      setWorkspaceKey(key);
-      setWorkspaceOpen(true);
-    } catch (error) {
-      if (fence.valid(id, controller)) setNotice(errorMessage(error, "Could not capture content"));
-    } finally {
-      fence.finish(controller);
-    }
-  }, [captureOne, capturePrimary, fence, initialScope, preferences, primaryWorkspaceKey, providerPreferences, workspaces]);
+  const openWorkspace = React12.useCallback(
+    async (key = primaryWorkspaceKey, variant) => {
+      const variantMaterial = variant && "kind" in variant.source ? {
+        id: `variant:${key}`,
+        label: variant.label,
+        capture: async () => directSource(variant.source, {
+          sourceId: `variant:${key}`,
+          label: variant.label
+        })
+      } : variant?.source;
+      const captureWorkspace = (scope, signal, collectPages = true) => captureOne(variantMaterial ?? primary, scope, signal, true, collectPages);
+      workspaceCaptures.current.set(key, captureWorkspace);
+      const existing = workspaces[key];
+      const { controller, id } = fence.begin();
+      if (existing) {
+        try {
+          const allMatching = existing.scope === "all-matching";
+          const fresh = await captureWorkspace(
+            existing.scope,
+            controller.signal,
+            !allMatching
+          );
+          if (!fence.valid(id, controller) || !workspaceCaptures.current.has(key))
+            return;
+          if (allMatching && (!existing.allMatching || !fresh.allMatching))
+            throw new Error(
+              "This source can no longer provide an all-matching snapshot."
+            );
+          const collectionIdentity = (value) => value && {
+            query: value.source.query,
+            projection: value.projection,
+            columns: value.columns,
+            limits: value.limits
+          };
+          const changed = allMatching ? JSON.stringify(collectionIdentity(existing.allMatching)) !== JSON.stringify(collectionIdentity(fresh.allMatching)) : snapshotContent(existing.snapshot) !== snapshotContent(fresh.snapshot);
+          setWorkspaces((current) => {
+            const retained = current[key];
+            if (!retained) return current;
+            return {
+              ...current,
+              [key]: {
+                ...retained,
+                error: fresh.collectionError,
+                ...allMatching ? { sourceStale: changed } : changed ? { pending: { ...fresh, scope: retained.scope } } : { pending: void 0 }
+              }
+            };
+          });
+          setWorkspaceKey(key);
+          setWorkspaceOpen(true);
+        } catch (error) {
+          if (fence.valid(id, controller) && workspaceCaptures.current.has(key)) {
+            setWorkspaces(
+              (current) => current[key] ? {
+                ...current,
+                [key]: {
+                  ...current[key],
+                  error: errorMessage(error, "Could not refresh source")
+                }
+              } : current
+            );
+            setWorkspaceKey(key);
+            setWorkspaceOpen(true);
+          }
+        } finally {
+          fence.finish(controller);
+        }
+        return;
+      }
+      try {
+        const result = await captureWorkspace(initialScope, controller.signal);
+        if (!fence.valid(id, controller)) return;
+        const resolved = resolveTransferPreferences(
+          providerPreferences,
+          preferences,
+          result.snapshot.limits
+        );
+        const original = createDraft(result.snapshot);
+        const base = {
+          ...result,
+          key,
+          original,
+          draft: original,
+          scope: initialScope,
+          preferences: resolved,
+          ...result.collectionError ? { error: result.collectionError } : {}
+        };
+        setWorkspaces((current) => ({
+          ...current,
+          [key]: { ...base, draft: rebuild(base, initialControls(base)) }
+        }));
+        setWorkspaceKey(key);
+        setWorkspaceOpen(true);
+      } catch (error) {
+        if (fence.valid(id, controller))
+          setNotice(errorMessage(error, "Could not capture content"));
+      } finally {
+        fence.finish(controller);
+      }
+    },
+    [
+      captureOne,
+      capturePrimary,
+      fence,
+      initialScope,
+      preferences,
+      primaryWorkspaceKey,
+      primary,
+      providerPreferences,
+      workspaces
+    ]
+  );
   React12.useImperativeHandle(controllerRef, () => ({
     focusTrigger: () => triggerRef.current?.focus(),
     prepare: async (requestedSource, options) => {
@@ -2801,7 +2891,7 @@ function PreparationWorkspace({ restoreFocus, open, state, scopes, onClose, onCh
     setBusy("capture");
     try {
       const result = await captureScope(scope, controller.signal);
-      if (fence.valid(id, controller) && latest.current.draft.revision === revision) onChange({ ...latest.current, pending: { ...result, scope }, error: result.collectionError });
+      if (fence.valid(id, controller) && latest.current.draft.revision === revision) onChange({ ...latest.current, pending: { ...result, scope }, sourceStale: false, error: result.collectionError });
     } catch (error) {
       if (fence.valid(id, controller)) onChange({ ...latest.current, error: errorMessage(error, "Refresh failed") });
     } finally {
@@ -3044,6 +3134,7 @@ function PreparationWorkspace({ restoreFocus, open, state, scopes, onClose, onCh
       /* @__PURE__ */ jsx19(Button, { type: "button", variant: "outline", onClick: () => setPendingControls(null), children: "Keep edited draft" }),
       /* @__PURE__ */ jsx19(Button, { type: "button", onClick: applyPendingControls, children: "Rebuild from source" })
     ] }) : null,
+    state.sourceStale ? /* @__PURE__ */ jsx19("p", { role: "alert", className: "matrx-alchemy-decision", children: "The source changed since this draft. Use Refresh source to review the latest data." }) : null,
     state.pending ? /* @__PURE__ */ jsxs13("div", { className: "matrx-alchemy-decision", role: "alert", children: [
       /* @__PURE__ */ jsx19("p", { children: "A fresh source snapshot is ready." }),
       /* @__PURE__ */ jsx19(Button, { type: "button", variant: "outline", onClick: () => resolveCapture("keep"), children: "Keep current snapshot and draft" }),