@adecore/agents-react 0.31.12 → 0.32.0

package/dist/chat/timeline-scroll.js

@@ -8,53 +8,65 @@ const ends = new Map();
 const listeners = new Set();
 /* The timeline hands its scroller over so the composer, which never sees it, can page through it. */
 export function registerTimeline(chatId, element, follow, coveredHeight) {
-    if (element === null) {
-        return () => undefined;
+  if (element === null) {
+    return () => undefined;
+  }
+  scrollers.set(chatId, {
+    element,
+    follow,
+    coveredHeight
+  });
+  return () => {
+    if (scrollers.get(chatId)?.element === element) {
+      scrollers.delete(chatId);
+      ends.delete(chatId);
     }
-    scrollers.set(chatId, { element, follow, coveredHeight });
-    return () => {
-        if (scrollers.get(chatId)?.element === element) {
-            scrollers.delete(chatId);
-            ends.delete(chatId);
-        }
-    };
+  };
 }
 export function setTimelineAtEnd(chatId, atEnd) {
-    if (ends.get(chatId) === atEnd) {
-        return;
-    }
-    ends.set(chatId, atEnd);
-    for (const listener of listeners) {
-        listener();
-    }
+  if (ends.get(chatId) === atEnd) {
+    return;
+  }
+  ends.set(chatId, atEnd);
+  for (const listener of listeners) {
+    listener();
+  }
 }
 export function subscribeTimelineEnd(listener) {
-    listeners.add(listener);
-    return () => {
-        listeners.delete(listener);
-    };
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
 }
 /* A thread nobody has scrolled is at its end, so the button stays away until there is a way back. */
 export function timelineAtEnd(chatId) {
-    return ends.get(chatId) ?? true;
+  return ends.get(chatId) ?? true;
 }
 export function scrollTimelineToEnd(chatId, behavior = 'smooth') {
-    const scroller = scrollers.get(chatId);
-    if (scroller) {
-        scroller.follow(true);
-        scroller.element.scrollTo({ top: scroller.element.scrollHeight, behavior });
-    }
+  const scroller = scrollers.get(chatId);
+  if (scroller) {
+    scroller.follow(true);
+    scroller.element.scrollTo({
+      top: scroller.element.scrollHeight,
+      behavior
+    });
+  }
 }
 /* Pages the thread of this chat up or down; false when it has no timeline on screen. */
 export function pageTimeline(chatId, direction) {
-    const scroller = scrollers.get(chatId);
-    if (!scroller) {
-        return false;
-    }
-    scroller.follow(false);
-    const { element } = scroller;
-    element.scrollBy({ top: direction * Math.max(0, element.clientHeight - scroller.coveredHeight()) * PAGE_OVERLAP, behavior: 'smooth' });
-    return true;
+  const scroller = scrollers.get(chatId);
+  if (!scroller) {
+    return false;
+  }
+  scroller.follow(false);
+  const {
+    element
+  } = scroller;
+  element.scrollBy({
+    top: direction * Math.max(0, element.clientHeight - scroller.coveredHeight()) * PAGE_OVERLAP,
+    behavior: 'smooth'
+  });
+  return true;
 }
 /*
  * The keyboard steps from one message of the person to the next through the timeline on screen,
@@ -63,16 +75,16 @@ export function pageTimeline(chatId, direction) {
  */
 const steppers = new Map();
 export function registerMessageStepper(key, step) {
-    steppers.set(key, step);
-    return () => {
-        if (steppers.get(key) === step) {
-            steppers.delete(key);
-        }
-    };
+  steppers.set(key, step);
+  return () => {
+    if (steppers.get(key) === step) {
+      steppers.delete(key);
+    }
+  };
 }
 /* False when that chat has no timeline on screen or no message in that direction. */
 export function stepTimelineMessage(key, direction) {
-    return steppers.get(key)?.(direction) ?? false;
+  return steppers.get(key)?.(direction) ?? false;
 }
 /*
  * Jumps asked from outside a thread (the chat's menu, a card that names a turn), keyed with the
@@ -80,72 +92,90 @@ export function stepTimelineMessage(key, direction) {
  * registers, since the asker may have to show the chat first.
  */
 function waitingJumps() {
-    const jumpers = new Map();
-    const waiting = new Map();
-    return {
-        register(key, jump) {
-            jumpers.set(key, jump);
-            const pending = waiting.get(key);
-            if (pending !== undefined) {
-                waiting.delete(key);
-                // A jump nobody picked up for long is not what the person wants any more.
-                if (Date.now() - pending.at <= PENDING_JUMP_TTL_MS) {
-                    jump(pending.target);
-                }
-            }
-            return () => {
-                if (jumpers.get(key) === jump) {
-                    jumpers.delete(key);
-                }
-            };
-        },
-        jump(key, target) {
-            const jump = jumpers.get(key);
-            if (jump === undefined) {
-                waiting.set(key, { target, at: Date.now() });
-                return false;
-            }
-            jump(target);
-            return true;
+  const jumpers = new Map();
+  const waiting = new Map();
+  return {
+    register(key, jump) {
+      jumpers.set(key, jump);
+      const pending = waiting.get(key);
+      if (pending !== undefined) {
+        waiting.delete(key);
+        // A jump nobody picked up for long is not what the person wants any more.
+        if (Date.now() - pending.at <= PENDING_JUMP_TTL_MS) {
+          jump(pending.target);
+        }
+      }
+      return () => {
+        if (jumpers.get(key) === jump) {
+          jumpers.delete(key);
         }
-    };
+      };
+    },
+    jump(key, target) {
+      const jump = jumpers.get(key);
+      if (jump === undefined) {
+        waiting.set(key, {
+          target,
+          at: Date.now()
+        });
+        return false;
+      }
+      jump(target);
+      return true;
+    }
+  };
 }
 const itemJumps = waitingJumps();
 export function registerItemJumper(key, jump) {
-    return itemJumps.register(key, ({ itemId, options }) => jump(itemId, options));
+  return itemJumps.register(key, ({
+    itemId,
+    options
+  }) => jump(itemId, options));
 }
 /* False when that chat has no thread on screen; the jump then waits for the next one that registers. */
 export function jumpToTimelineItem(key, itemId, options = {}) {
-    return itemJumps.jump(key, { itemId, options });
+  return itemJumps.jump(key, {
+    itemId,
+    options
+  });
 }
 const turnJumps = waitingJumps();
 export function registerTurnJumper(key, jump) {
-    return turnJumps.register(key, ({ turnId, target }) => jump(turnId, target));
+  return turnJumps.register(key, ({
+    turnId,
+    target
+  }) => jump(turnId, target));
 }
 /* False when that chat has no thread on screen; the jump then waits for the next one that registers. */
 export function jumpToTimelineTurn(key, turnId, target) {
-    return turnJumps.jump(key, { turnId, target });
+  return turnJumps.jump(key, {
+    turnId,
+    target
+  });
 }
 /* How near the top, in screens, the page before is asked for, so it is there before a reader reaches the edge. */
 const EARLIER_SCREENS = 1.5;
 export function wantsEarlier(scroller) {
-    return scroller.clientHeight > 0 && scroller.scrollTop < scroller.clientHeight * EARLIER_SCREENS;
+  return scroller.clientHeight > 0 && scroller.scrollTop < scroller.clientHeight * EARLIER_SCREENS;
 }
 /* The first row in view, found by the rows' `data-item-id`, for a thread that keeps every row in the document. */
 export function firstRowInView(scroller) {
-    const top = scroller.getBoundingClientRect().top;
-    for (const row of scroller.querySelectorAll('[data-item-id]')) {
-        const rect = row.getBoundingClientRect();
-        if (rect.bottom > top) {
-            return { id: row.dataset.itemId, offset: rect.top - top };
-        }
+  const top = scroller.getBoundingClientRect().top;
+  for (const row of scroller.querySelectorAll('[data-item-id]')) {
+    const rect = row.getBoundingClientRect();
+    if (rect.bottom > top) {
+      return {
+        id: row.dataset.itemId,
+        offset: rect.top - top
+      };
     }
-    return null;
+  }
+  return null;
 }
 /* Puts the anchored row back where it was; nothing moves when that row is gone. */
 export function restoreAnchor(scroller, anchor) {
-    const row = scroller.querySelector(`[data-item-id="${CSS.escape(anchor.id)}"]`);
-    if (row !== null) {
-        scroller.scrollTop += row.getBoundingClientRect().top - scroller.getBoundingClientRect().top - anchor.offset;
-    }
-}
+  const row = scroller.querySelector(`[data-item-id="${CSS.escape(anchor.id)}"]`);
+  if (row !== null) {
+    scroller.scrollTop += row.getBoundingClientRect().top - scroller.getBoundingClientRect().top - anchor.offset;
+  }
+}

package/dist/chat/ui/AccountPill.js

@@ -1,23 +1,134 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
 import { useTranslation } from 'react-i18next';
 import { AccountDot } from '../../agents/AccountDot.js';
 import { useAccountChoice } from '../account-choice.js';
 import { useChats } from '../../state/chats.js';
 import { useChatScope } from '../../scope.js';
 import { Pill, Tooltip } from '@adecore/ui';
-function AccountPillOf({ provider, account }) {
-    const { t } = useTranslation('agent-chat');
-    const choice = useAccountChoice(provider, account);
-    if (choice === null) {
-        return null;
-    }
-    const name = choice.current === null ? choice.currentId : choice.nameOf(choice.current);
-    return (_jsx(Tooltip, { label: t('account.pill', { provider: choice.providerName, account: name }), children: _jsx(Pill, { icon: _jsx(AccountDot, { color: choice.current?.account.color, className: "size-1.75" }), children: _jsx("span", { className: "max-w-32 truncate", children: name }) }) }));
+import { jsx as _jsx } from "react/jsx-runtime";
+function AccountPillOf(t0) {
+  const $ = _c(16);
+  const {
+    provider,
+    account
+  } = t0;
+  const {
+    t
+  } = useTranslation("agent-chat");
+  const choice = useAccountChoice(provider, account);
+  if (choice === null) {
+    return null;
+  }
+  let T0;
+  let name;
+  let t1;
+  if ($[0] !== choice || $[1] !== t) {
+    name = choice.current === null ? choice.currentId : choice.nameOf(choice.current);
+    T0 = Tooltip;
+    t1 = t("account.pill", {
+      provider: choice.providerName,
+      account: name
+    });
+    $[0] = choice;
+    $[1] = t;
+    $[2] = T0;
+    $[3] = name;
+    $[4] = t1;
+  } else {
+    T0 = $[2];
+    name = $[3];
+    t1 = $[4];
+  }
+  const t2 = choice.current?.account.color;
+  let t3;
+  if ($[5] !== t2) {
+    t3 = /*#__PURE__*/_jsx(AccountDot, {
+      color: t2,
+      className: "size-1.75"
+    });
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== name) {
+    t4 = /*#__PURE__*/_jsx("span", {
+      className: "max-w-32 truncate",
+      children: name
+    });
+    $[7] = name;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  let t5;
+  if ($[9] !== t3 || $[10] !== t4) {
+    t5 = /*#__PURE__*/_jsx(Pill, {
+      icon: t3,
+      children: t4
+    });
+    $[9] = t3;
+    $[10] = t4;
+    $[11] = t5;
+  } else {
+    t5 = $[11];
+  }
+  let t6;
+  if ($[12] !== T0 || $[13] !== t1 || $[14] !== t5) {
+    t6 = /*#__PURE__*/_jsx(T0, {
+      label: t1,
+      children: t5
+    });
+    $[12] = T0;
+    $[13] = t1;
+    $[14] = t5;
+    $[15] = t6;
+  } else {
+    t6 = $[15];
+  }
+  return t6;
 }
 /* Which account a chat node runs under, from the status every client gets; only while its CLI has a choice of accounts. */
-export function AccountPill({ chatId }) {
-    const { keyOf } = useChatScope();
-    const provider = useChats((s) => s.statusByKey[keyOf(chatId)]?.info.provider);
-    const account = useChats((s) => s.statusByKey[keyOf(chatId)]?.info.account);
-    return provider === undefined ? null : _jsx(AccountPillOf, { provider: provider, account: account });
-}
+export function AccountPill(t0) {
+  const $ = _c(9);
+  const {
+    chatId
+  } = t0;
+  const {
+    keyOf
+  } = useChatScope();
+  let t1;
+  if ($[0] !== chatId || $[1] !== keyOf) {
+    t1 = s => s.statusByKey[keyOf(chatId)]?.info.provider;
+    $[0] = chatId;
+    $[1] = keyOf;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const provider = useChats(t1);
+  let t2;
+  if ($[3] !== chatId || $[4] !== keyOf) {
+    t2 = s_0 => s_0.statusByKey[keyOf(chatId)]?.info.account;
+    $[3] = chatId;
+    $[4] = keyOf;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const account = useChats(t2);
+  let t3;
+  if ($[6] !== account || $[7] !== provider) {
+    t3 = provider === undefined ? null : /*#__PURE__*/_jsx(AccountPillOf, {
+      provider: provider,
+      account: account
+    });
+    $[6] = account;
+    $[7] = provider;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  return t3;
+}

package/dist/chat/ui/AnsiOutput.js

@@ -1,9 +1,65 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from 'react';
+import { c as _c } from "react/compiler-runtime";
 import { useTranslation } from 'react-i18next';
 import { parseAnsi } from '../logic/ansi.js';
-export function AnsiOutput({ text, limit, tailLines }) {
-    const { t } = useTranslation('agent-chat');
-    const { tokens, omitted } = useMemo(() => parseAnsi(text, { limit, tailLines }), [text, limit, tailLines]);
-    return (_jsxs(_Fragment, { children: [tokens.map((token, index) => (_jsx("span", { style: token.style, children: token.content }, index))), omitted > 0 && `\n${t('work.moreCharacters', { count: omitted })}`] }));
+import { Fragment as _Fragment, jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+export function AnsiOutput(t0) {
+  const $ = _c(11);
+  const {
+    text,
+    limit,
+    tailLines
+  } = t0;
+  const {
+    t
+  } = useTranslation("agent-chat");
+  let omitted;
+  let t1;
+  if ($[0] !== limit || $[1] !== tailLines || $[2] !== text) {
+    const {
+      tokens,
+      omitted: t2
+    } = parseAnsi(text, {
+      limit,
+      tailLines
+    });
+    omitted = t2;
+    t1 = tokens.map(_temp);
+    $[0] = limit;
+    $[1] = tailLines;
+    $[2] = text;
+    $[3] = omitted;
+    $[4] = t1;
+  } else {
+    omitted = $[3];
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] !== omitted || $[6] !== t) {
+    t2 = omitted > 0 && `\n${t("work.moreCharacters", {
+      count: omitted
+    })}`;
+    $[5] = omitted;
+    $[6] = t;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  let t3;
+  if ($[8] !== t1 || $[9] !== t2) {
+    t3 = /*#__PURE__*/_jsxs(_Fragment, {
+      children: [t1, t2]
+    });
+    $[8] = t1;
+    $[9] = t2;
+    $[10] = t3;
+  } else {
+    t3 = $[10];
+  }
+  return t3;
 }
+function _temp(token, index) {
+  return /*#__PURE__*/_jsx("span", {
+    style: token.style,
+    children: token.content
+  }, index);
+}