@adecore/agents-react 0.31.12 → 0.32.0

package/dist/chat/ui/diff/use-review-stack.js

@@ -1,30 +1,151 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { c as _c } from "react/compiler-runtime";
+import { useEffect, useState } from 'react';
 import { planReview } from './review-plan.js';
 export function useReviewStack(entries) {
-    const [promoted, setPromoted] = useState(null);
-    const slots = useMemo(() => planReview(entries, promoted), [entries, promoted]);
-    const selected = [...slots].filter(([, slot]) => slot === 'editor').map(([key]) => key);
-    const [admitted, setAdmitted] = useState(() => selected.slice(0, 1));
-    const retained = admitted.filter((key) => selected.includes(key));
-    const live = retained.length === 0 ? selected.slice(0, 1) : retained;
-    if (live.length !== admitted.length || live.some((key, index) => key !== admitted[index])) {
-        setAdmitted(live);
+  const $ = _c(30);
+  const [promoted, setPromoted] = useState(null);
+  let slots;
+  let t0;
+  if ($[0] !== entries || $[1] !== promoted) {
+    slots = planReview(entries, promoted);
+    t0 = [...slots].filter(_temp).map(_temp2);
+    $[0] = entries;
+    $[1] = promoted;
+    $[2] = slots;
+    $[3] = t0;
+  } else {
+    slots = $[2];
+    t0 = $[3];
+  }
+  const selected = t0;
+  let t1;
+  if ($[4] !== selected) {
+    t1 = () => selected.slice(0, 1);
+    $[4] = selected;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const [admitted, setAdmitted] = useState(t1);
+  let live;
+  let t2;
+  if ($[6] !== admitted || $[7] !== selected) {
+    let t3;
+    if ($[10] !== selected) {
+      t3 = key_0 => selected.includes(key_0);
+      $[10] = selected;
+      $[11] = t3;
+    } else {
+      t3 = $[11];
     }
-    const [settled, setSettled] = useState(() => new Set());
-    if ([...settled].some((key) => !selected.includes(key))) {
-        setSettled(new Set([...settled].filter((key) => selected.includes(key))));
+    const retained = admitted.filter(t3);
+    live = retained.length === 0 ? selected.slice(0, 1) : retained;
+    t2 = live.length !== admitted.length || live.some((key_1, index) => key_1 !== admitted[index]);
+    $[6] = admitted;
+    $[7] = selected;
+    $[8] = live;
+    $[9] = t2;
+  } else {
+    live = $[8];
+    t2 = $[9];
+  }
+  if (t2) {
+    setAdmitted(live);
+  }
+  const [settled, setSettled] = useState(_temp3);
+  if ([...settled].some(key_3 => !selected.includes(key_3))) {
+    setSettled(new Set([...settled].filter(key_2 => selected.includes(key_2))));
+  }
+  let t3;
+  if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = key_4 => {
+      setSettled(previous => previous.has(key_4) ? previous : new Set([...previous, key_4]));
+    };
+    $[12] = t3;
+  } else {
+    t3 = $[12];
+  }
+  const settle = t3;
+  let t4;
+  if ($[13] !== live || $[14] !== settled) {
+    let t5;
+    if ($[16] !== settled) {
+      t5 = key_5 => settled.has(key_5);
+      $[16] = settled;
+      $[17] = t5;
+    } else {
+      t5 = $[17];
     }
-    const settle = useCallback((key) => {
-        setSettled((previous) => (previous.has(key) ? previous : new Set([...previous, key])));
-    }, []);
-    const allSettled = live.every((key) => settled.has(key));
-    const next = selected.find((key) => !live.includes(key));
-    useEffect(() => {
-        if (next === undefined || !allSettled) {
-            return;
-        }
-        const frame = window.requestAnimationFrame(() => setAdmitted((previous) => [...previous, next]));
-        return () => window.cancelAnimationFrame(frame);
-    }, [next, allSettled]);
-    return { slots, ready: new Set(live), promote: setPromoted, settle };
+    t4 = live.every(t5);
+    $[13] = live;
+    $[14] = settled;
+    $[15] = t4;
+  } else {
+    t4 = $[15];
+  }
+  const allSettled = t4;
+  let t5;
+  if ($[18] !== live || $[19] !== selected) {
+    t5 = selected.find(key_6 => !live.includes(key_6));
+    $[18] = live;
+    $[19] = selected;
+    $[20] = t5;
+  } else {
+    t5 = $[20];
+  }
+  const next = t5;
+  let t6;
+  let t7;
+  if ($[21] !== allSettled || $[22] !== next) {
+    t6 = () => {
+      if (next === undefined || !allSettled) {
+        return;
+      }
+      const frame = window.requestAnimationFrame(() => setAdmitted(previous_0 => [...previous_0, next]));
+      return () => window.cancelAnimationFrame(frame);
+    };
+    t7 = [next, allSettled];
+    $[21] = allSettled;
+    $[22] = next;
+    $[23] = t6;
+    $[24] = t7;
+  } else {
+    t6 = $[23];
+    t7 = $[24];
+  }
+  useEffect(t6, t7);
+  let t8;
+  if ($[25] !== live) {
+    t8 = new Set(live);
+    $[25] = live;
+    $[26] = t8;
+  } else {
+    t8 = $[26];
+  }
+  let t9;
+  if ($[27] !== slots || $[28] !== t8) {
+    t9 = {
+      slots,
+      ready: t8,
+      promote: setPromoted,
+      settle
+    };
+    $[27] = slots;
+    $[28] = t8;
+    $[29] = t9;
+  } else {
+    t9 = $[29];
+  }
+  return t9;
 }
+function _temp3() {
+  return new Set();
+}
+function _temp2(t0) {
+  const [key] = t0;
+  return key;
+}
+function _temp(t0) {
+  const [, slot] = t0;
+  return slot === "editor";
+}

package/dist/chat/ui/diff-syntax.js

@@ -2,61 +2,73 @@ import { lineTokensOf } from '@adecore/editor/shiki-worker';
 export { createDiffSyntaxRuntime, diffSyntaxRuntime } from './diff/syntax-runtime.js';
 /* Structurally accepts the editor's source mapping without depending on its React renderer. */
 export function diffSourceTokens(document, mapping, runtime) {
-    const sides = { old: runtime.open(mapping.documents.old), new: runtime.open(mapping.documents.new) };
-    const cache = { old: new Map(), new: new Map() };
-    const pending = { old: new Set(), new: new Set() };
-    const listeners = new Set();
-    let disposed = false;
-    return {
-        get(side, index) {
-            const location = mapping.locate(side, index);
-            if (disposed || location === undefined || document.sides[side][index] === undefined) {
-                return null;
-            }
-            const { block, line } = location;
-            const known = cache[side].get(block);
-            if (known !== undefined) {
-                return known[line] ?? null;
-            }
-            if (!pending[side].has(block)) {
-                pending[side].add(block);
-                const text = mapping.documents[side].blocks[block].split('\n');
-                const publish = (lines) => {
-                    if (disposed) {
-                        return;
-                    }
-                    pending[side].delete(block);
-                    cache[side].set(block, lines);
-                    for (const listener of [...listeners]) {
-                        listener();
-                    }
-                };
-                const count = text.length;
-                void sides[side].request(block).then((packet) => {
-                    if (!disposed) {
-                        publish(text.map((text, line) => (packet === null || packet.lines.length !== count + 1 ? null : lineTokensOf(packet, line, text))));
-                    }
-                }, () => publish(text.map(() => null)));
-            }
-            return undefined;
-        },
-        subscribe(listener) {
-            if (!disposed) {
-                listeners.add(listener);
-            }
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        dispose() {
-            disposed = true;
-            listeners.clear();
-            sides.old.dispose();
-            sides.new.dispose();
-            cache.old.clear();
-            cache.new.clear();
-            pending.old.clear();
-            pending.new.clear();
-        }
-    };
-}
+  const sides = {
+    old: runtime.open(mapping.documents.old),
+    new: runtime.open(mapping.documents.new)
+  };
+  const cache = {
+    old: new Map(),
+    new: new Map()
+  };
+  const pending = {
+    old: new Set(),
+    new: new Set()
+  };
+  const listeners = new Set();
+  let disposed = false;
+  return {
+    get(side, index) {
+      const location = mapping.locate(side, index);
+      if (disposed || location === undefined || document.sides[side][index] === undefined) {
+        return null;
+      }
+      const {
+        block,
+        line
+      } = location;
+      const known = cache[side].get(block);
+      if (known !== undefined) {
+        return known[line] ?? null;
+      }
+      if (!pending[side].has(block)) {
+        pending[side].add(block);
+        const text = mapping.documents[side].blocks[block].split('\n');
+        const publish = lines => {
+          if (disposed) {
+            return;
+          }
+          pending[side].delete(block);
+          cache[side].set(block, lines);
+          for (const listener of [...listeners]) {
+            listener();
+          }
+        };
+        const count = text.length;
+        void sides[side].request(block).then(packet => {
+          if (!disposed) {
+            publish(text.map((text, line) => packet === null || packet.lines.length !== count + 1 ? null : lineTokensOf(packet, line, text)));
+          }
+        }, () => publish(text.map(() => null)));
+      }
+      return undefined;
+    },
+    subscribe(listener) {
+      if (!disposed) {
+        listeners.add(listener);
+      }
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    dispose() {
+      disposed = true;
+      listeners.clear();
+      sides.old.dispose();
+      sides.new.dispose();
+      cache.old.clear();
+      cache.new.clear();
+      pending.old.clear();
+      pending.new.clear();
+    }
+  };
+}

package/dist/chat/ui/diff-theme.js

@@ -1,6 +1,7 @@
-import { useMemo } from 'react';
+import { c as _c } from "react/compiler-runtime";
 import { registerCustomTheme } from '@pierre/diffs';
 import { useChatHost } from '../../host.js';
+import { useHostCodeThemes } from '../../host-hooks.js';
 // The library's registry is global and refuses a name twice, so what is registered is kept by name.
 const registered = new Set();
 /*
@@ -8,18 +9,36 @@ const registered = new Set();
  * Read on every render, so a theme the host adds to `custom` later is in before a diff is drawn in it.
  */
 function registerThemes(custom) {
-    for (const theme of custom) {
-        if (registered.has(theme.name)) {
-            continue;
-        }
-        registered.add(theme.name);
-        registerCustomTheme(theme.name, () => Promise.resolve(theme));
+  for (const theme of custom) {
+    if (registered.has(theme.name)) {
+      continue;
     }
+    registered.add(theme.name);
+    registerCustomTheme(theme.name, () => Promise.resolve(theme));
+  }
 }
 /* The code themes a diff is drawn in, the same pair a chat's code blocks use. */
 export function useDiffTheme() {
-    const { code } = useChatHost();
-    registerThemes(code.custom);
-    const { light, dark } = code.useThemes();
-    return useMemo(() => ({ light, dark }), [light, dark]);
-}
+  const $ = _c(3);
+  const {
+    code
+  } = useChatHost();
+  registerThemes(code.custom);
+  const {
+    light,
+    dark
+  } = useHostCodeThemes();
+  let t0;
+  if ($[0] !== dark || $[1] !== light) {
+    t0 = {
+      light,
+      dark
+    };
+    $[0] = dark;
+    $[1] = light;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}

package/dist/chat/ui/file-links.js

@@ -1,4 +1,5 @@
-import { createContext, useContext, useMemo } from 'react';
+import { c as _c } from "react/compiler-runtime";
+import { createContext, useContext } from 'react';
 import { useChatHost } from '../../host.js';
 import { ChatScopeContext } from '../../scope.js';
 /*
@@ -8,20 +9,48 @@ import { ChatScopeContext } from '../../scope.js';
  */
 export const FileLinkContext = createContext(null);
 export function useFileLinkCwd() {
-    return useContext(FileLinkContext);
+  return useContext(FileLinkContext);
 }
 export function useFileLinkScopeId() {
-    return useContext(ChatScopeContext)?.id ?? null;
+  return useContext(ChatScopeContext)?.id ?? null;
 }
 /* The reference a piece of text names, only where this spot on screen could open it. */
 export function useFileLinkTarget(text) {
-    const cwd = useFileLinkCwd();
-    const scopeId = useFileLinkScopeId();
-    const { fileLinks } = useChatHost();
-    return useMemo(() => fileLinks?.target(text, cwd, scopeId) ?? null, [fileLinks, text, cwd, scopeId]);
+  const $ = _c(5);
+  const cwd = useFileLinkCwd();
+  const scopeId = useFileLinkScopeId();
+  const {
+    fileLinks
+  } = useChatHost();
+  let t0;
+  if ($[0] !== cwd || $[1] !== fileLinks || $[2] !== scopeId || $[3] !== text) {
+    t0 = fileLinks?.target(text, cwd, scopeId) ?? null;
+    $[0] = cwd;
+    $[1] = fileLinks;
+    $[2] = scopeId;
+    $[3] = text;
+    $[4] = t0;
+  } else {
+    t0 = $[4];
+  }
+  return t0;
 }
 /* Follows a reference the way the app opens a file or a folder. */
 export function useOpenFileLink() {
-    const { fileLinks } = useChatHost();
-    return (cwd, ref, scopeId = null) => fileLinks?.open(cwd, ref, scopeId);
-}
+  const $ = _c(2);
+  const {
+    fileLinks
+  } = useChatHost();
+  let t0;
+  if ($[0] !== fileLinks) {
+    t0 = (cwd, ref, t1) => {
+      const scopeId = t1 === undefined ? null : t1;
+      return fileLinks?.open(cwd, ref, scopeId);
+    };
+    $[0] = fileLinks;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}

package/dist/chat/ui/find-reveal.js

@@ -1,13 +1,34 @@
+import { c as _c } from "react/compiler-runtime";
 import { createContext, useContext, useEffect } from 'react';
 /* The hit the find bar is on, so the row that folds it away can open. */
 export const FindRevealContext = createContext(null);
 /* Opens a fold of this item while the find bar is on a hit inside it; it stays open once the bar moves on, as if a person opened it. */
 export function useOpenForFind(itemId, field, setOpen) {
-    const reveal = useContext(FindRevealContext);
-    const wanted = reveal !== null && reveal.itemId === itemId && reveal.field === field;
-    useEffect(() => {
-        if (wanted) {
-            setOpen(true);
-        }
-    }, [wanted, reveal, setOpen]);
-}
+  const $ = _c(7);
+  const reveal = useContext(FindRevealContext);
+  const wanted = reveal !== null && reveal.itemId === itemId && reveal.field === field;
+  let t0;
+  if ($[0] !== setOpen || $[1] !== wanted) {
+    t0 = () => {
+      if (wanted) {
+        setOpen(true);
+      }
+    };
+    $[0] = setOpen;
+    $[1] = wanted;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== reveal || $[4] !== setOpen || $[5] !== wanted) {
+    t1 = [wanted, reveal, setOpen];
+    $[3] = reveal;
+    $[4] = setOpen;
+    $[5] = wanted;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  useEffect(t0, t1);
+}

package/dist/chat/ui/full-diff.js

@@ -5,15 +5,20 @@ import { processFile } from '@pierre/diffs';
  * keeps its counts. Null when there is no hunk to lay over them, and the patch alone is drawn.
  */
 export function fullFileDiff(patch, name, contents) {
-    try {
-        const parsed = processFile(patch, {
-            oldFile: { name, contents: contents.old },
-            newFile: { name, contents: contents.new },
-            throwOnError: true
-        });
-        return parsed === undefined || parsed.isPartial || parsed.hunks.length === 0 ? null : parsed;
-    }
-    catch {
-        return null;
-    }
-}
+  try {
+    const parsed = processFile(patch, {
+      oldFile: {
+        name,
+        contents: contents.old
+      },
+      newFile: {
+        name,
+        contents: contents.new
+      },
+      throwOnError: true
+    });
+    return parsed === undefined || parsed.isPartial || parsed.hunks.length === 0 ? null : parsed;
+  } catch {
+    return null;
+  }
+}