@adecore/agents-react 0.31.12 → 0.32.0

package/dist/chat/ui/ComposerInput.js

@@ -1,10 +1,11 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
 import { useImperativeHandle, useLayoutEffect, useRef, useState } from 'react';
 import { Compartment, EditorState, Prec, Transaction } from '@codemirror/state';
 import { EditorView, placeholder as placeholderText } from '@codemirror/view';
 import { useChatHost } from '../../host.js';
 import { composerEditorExtensions, externalChange } from './composer/editor.js';
 import { insertAtSelection } from './composer/insert.js';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const NO_EXTENSIONS = [];
 const NO_ARIA = {};
 /*
@@ -12,126 +13,314 @@ const NO_ARIA = {};
  * itself, so a decoration may change a font or add padding without walking the caret off its
  * character, which a textarea with a painted layer behind it could not.
  */
-export function ComposerInput({ ref, value, placeholder, disabled, tabbable, className, dictationToolbar, extensions = NO_EXTENSIONS, aria = NO_ARIA, ...handlers }) {
-    const { dictation } = useChatHost();
-    const hostRef = useRef(null);
-    const targetRef = useRef(null);
-    const viewRef = useRef(null);
-    const [compartments] = useState(() => ({
-        attributes: new Compartment(),
-        editable: new Compartment(),
-        placeholder: new Compartment(),
-        extensions: new Compartment()
-    }));
-    const latest = useRef({ value, handlers });
-    // What the editor last reported. The parent handing that back is catching up, not setting a value of its own.
-    const reported = useRef(value);
-    useLayoutEffect(() => {
-        latest.current = { value, handlers };
-    });
-    useLayoutEffect(() => {
-        const host = hostRef.current;
-        if (!host) {
-            return;
-        }
-        const initial = latest.current.value;
-        const view = new EditorView({
-            parent: host,
-            state: EditorState.create({
-                doc: initial,
-                selection: { anchor: initial.length },
-                extensions: [
-                    composerEditorExtensions(),
-                    dictation.composer?.extensions ?? [],
-                    compartments.attributes.of([]),
-                    compartments.editable.of([]),
-                    compartments.placeholder.of([]),
-                    compartments.extensions.of([]),
-                    Prec.highest(EditorView.domEventHandlers({
-                        keydown: (event, target) => latest.current.handlers.onKeyDown?.(event, target) ?? false,
-                        paste: (event, target) => latest.current.handlers.onPaste?.(event, target) ?? false,
-                        compositionstart: () => {
-                            latest.current.handlers.onComposing?.(true);
-                            return false;
-                        },
-                        compositionend: () => {
-                            latest.current.handlers.onComposing?.(false);
-                            return false;
-                        }
-                    })),
-                    EditorView.updateListener.of((update) => {
-                        const current = latest.current.handlers;
-                        if (update.focusChanged && !update.view.hasFocus) {
-                            current.onBlur?.();
-                        }
-                        if ((!update.docChanged && !update.selectionSet) || update.transactions.some((tr) => tr.annotation(externalChange))) {
-                            return;
-                        }
-                        const text = update.state.doc.toString();
-                        const { from, to } = update.state.selection.main;
-                        if (update.docChanged) {
-                            reported.current = text;
-                            current.onChange(text, { from, to }, update.state);
-                        }
-                        else {
-                            current.onSelectionChange?.(text, { from, to }, update.state);
-                        }
-                    })
-                ]
-            })
-        });
-        viewRef.current = view;
-        return () => {
-            view.destroy();
-            viewRef.current = null;
-        };
-    }, [compartments, dictation.composer?.extensions]);
-    useLayoutEffect(() => {
-        viewRef.current?.dispatch({
-            effects: [
-                // Spellcheck stays on, as it was on the textarea this editor replaced.
-                compartments.attributes.reconfigure(EditorView.contentAttributes.of({ ...aria, spellcheck: 'true', tabindex: tabbable ? '0' : '-1' })),
-                compartments.editable.reconfigure([EditorView.editable.of(!disabled), EditorState.readOnly.of(disabled)]),
-                compartments.placeholder.reconfigure(placeholderText(placeholder)),
-                compartments.extensions.reconfigure(extensions)
-            ]
-        });
-    }, [compartments, tabbable, disabled, placeholder, extensions, aria]);
-    useLayoutEffect(() => {
-        const view = viewRef.current;
-        if (!view || value === reported.current) {
-            return;
-        }
-        reported.current = value;
-        const doc = view.state.doc.toString();
-        if (value === doc) {
-            return;
-        }
-        view.dispatch({
-            changes: { from: 0, to: doc.length, insert: value },
-            selection: { anchor: value.length },
-            annotations: [externalChange.of(true), Transaction.addToHistory.of(false)]
-        });
-    }, [value]);
-    useImperativeHandle(ref, () => ({
-        focus: () => viewRef.current?.focus(),
-        setCaret: (pos) => {
-            const view = viewRef.current;
-            if (!view) {
-                return;
+export function ComposerInput(t0) {
+  const $ = _c(45);
+  let className;
+  let dictationToolbar;
+  let disabled;
+  let handlers;
+  let placeholder;
+  let ref;
+  let t1;
+  let t2;
+  let tabbable;
+  let value;
+  if ($[0] !== t0) {
+    ({
+      ref,
+      value,
+      placeholder,
+      disabled,
+      tabbable,
+      className,
+      dictationToolbar,
+      extensions: t1,
+      aria: t2,
+      ...handlers
+    } = t0);
+    $[0] = t0;
+    $[1] = className;
+    $[2] = dictationToolbar;
+    $[3] = disabled;
+    $[4] = handlers;
+    $[5] = placeholder;
+    $[6] = ref;
+    $[7] = t1;
+    $[8] = t2;
+    $[9] = tabbable;
+    $[10] = value;
+  } else {
+    className = $[1];
+    dictationToolbar = $[2];
+    disabled = $[3];
+    handlers = $[4];
+    placeholder = $[5];
+    ref = $[6];
+    t1 = $[7];
+    t2 = $[8];
+    tabbable = $[9];
+    value = $[10];
+  }
+  const extensions = t1 === undefined ? NO_EXTENSIONS : t1;
+  const aria = t2 === undefined ? NO_ARIA : t2;
+  const {
+    dictation
+  } = useChatHost();
+  const hostRef = useRef(null);
+  const targetRef = useRef(null);
+  const viewRef = useRef(null);
+  const [compartments] = useState(_temp);
+  let t3;
+  if ($[11] !== handlers || $[12] !== value) {
+    t3 = {
+      value,
+      handlers
+    };
+    $[11] = handlers;
+    $[12] = value;
+    $[13] = t3;
+  } else {
+    t3 = $[13];
+  }
+  const latest = useRef(t3);
+  const reported = useRef(value);
+  let t4;
+  if ($[14] !== handlers || $[15] !== value) {
+    t4 = () => {
+      latest.current = {
+        value,
+        handlers
+      };
+    };
+    $[14] = handlers;
+    $[15] = value;
+    $[16] = t4;
+  } else {
+    t4 = $[16];
+  }
+  useLayoutEffect(t4);
+  let t5;
+  if ($[17] !== compartments || $[18] !== dictation.composer?.extensions) {
+    t5 = () => {
+      const host = hostRef.current;
+      if (!host) {
+        return;
+      }
+      const initial = latest.current.value;
+      const view = new EditorView({
+        parent: host,
+        state: EditorState.create({
+          doc: initial,
+          selection: {
+            anchor: initial.length
+          },
+          extensions: [composerEditorExtensions(), dictation.composer?.extensions ?? [], compartments.attributes.of([]), compartments.editable.of([]), compartments.placeholder.of([]), compartments.extensions.of([]), Prec.highest(EditorView.domEventHandlers({
+            keydown: (event, target) => latest.current.handlers.onKeyDown?.(event, target) ?? false,
+            paste: (event_0, target_0) => latest.current.handlers.onPaste?.(event_0, target_0) ?? false,
+            compositionstart: () => {
+              latest.current.handlers.onComposing?.(true);
+              return false;
+            },
+            compositionend: () => {
+              latest.current.handlers.onComposing?.(false);
+              return false;
             }
-            view.dispatch({ selection: { anchor: Math.min(pos, view.state.doc.length) }, scrollIntoView: true });
-            view.focus();
-        },
-        insert: (text) => {
-            const view = viewRef.current;
-            if (!view) {
-                return;
+          })), EditorView.updateListener.of(update => {
+            const current = latest.current.handlers;
+            if (update.focusChanged && !update.view.hasFocus) {
+              current.onBlur?.();
+            }
+            if (!update.docChanged && !update.selectionSet || update.transactions.some(_temp2)) {
+              return;
             }
-            view.dispatch(insertAtSelection(view.state, text));
-            view.focus();
+            const text = update.state.doc.toString();
+            const {
+              from,
+              to
+            } = update.state.selection.main;
+            if (update.docChanged) {
+              reported.current = text;
+              current.onChange(text, {
+                from,
+                to
+              }, update.state);
+            } else {
+              current.onSelectionChange?.(text, {
+                from,
+                to
+              }, update.state);
+            }
+          })]
+        })
+      });
+      viewRef.current = view;
+      return () => {
+        view.destroy();
+        viewRef.current = null;
+      };
+    };
+    $[17] = compartments;
+    $[18] = dictation.composer?.extensions;
+    $[19] = t5;
+  } else {
+    t5 = $[19];
+  }
+  const t6 = dictation.composer?.extensions;
+  let t7;
+  if ($[20] !== compartments || $[21] !== t6) {
+    t7 = [compartments, t6];
+    $[20] = compartments;
+    $[21] = t6;
+    $[22] = t7;
+  } else {
+    t7 = $[22];
+  }
+  useLayoutEffect(t5, t7);
+  let t8;
+  let t9;
+  if ($[23] !== aria || $[24] !== compartments || $[25] !== disabled || $[26] !== extensions || $[27] !== placeholder || $[28] !== tabbable) {
+    t8 = () => {
+      viewRef.current?.dispatch({
+        effects: [compartments.attributes.reconfigure(EditorView.contentAttributes.of({
+          ...aria,
+          spellcheck: "true",
+          tabindex: tabbable ? "0" : "-1"
+        })), compartments.editable.reconfigure([EditorView.editable.of(!disabled), EditorState.readOnly.of(disabled)]), compartments.placeholder.reconfigure(placeholderText(placeholder)), compartments.extensions.reconfigure(extensions)]
+      });
+    };
+    t9 = [compartments, tabbable, disabled, placeholder, extensions, aria];
+    $[23] = aria;
+    $[24] = compartments;
+    $[25] = disabled;
+    $[26] = extensions;
+    $[27] = placeholder;
+    $[28] = tabbable;
+    $[29] = t8;
+    $[30] = t9;
+  } else {
+    t8 = $[29];
+    t9 = $[30];
+  }
+  useLayoutEffect(t8, t9);
+  let t10;
+  let t11;
+  if ($[31] !== value) {
+    t10 = () => {
+      const view_0 = viewRef.current;
+      if (!view_0 || value === reported.current) {
+        return;
+      }
+      reported.current = value;
+      const doc = view_0.state.doc.toString();
+      if (value === doc) {
+        return;
+      }
+      view_0.dispatch({
+        changes: {
+          from: 0,
+          to: doc.length,
+          insert: value
+        },
+        selection: {
+          anchor: value.length
+        },
+        annotations: [externalChange.of(true), Transaction.addToHistory.of(false)]
+      });
+    };
+    t11 = [value];
+    $[31] = value;
+    $[32] = t10;
+    $[33] = t11;
+  } else {
+    t10 = $[32];
+    t11 = $[33];
+  }
+  useLayoutEffect(t10, t11);
+  let t12;
+  let t13;
+  if ($[34] === Symbol.for("react.memo_cache_sentinel")) {
+    t12 = () => ({
+      focus: () => viewRef.current?.focus(),
+      setCaret: pos => {
+        const view_1 = viewRef.current;
+        if (!view_1) {
+          return;
+        }
+        view_1.dispatch({
+          selection: {
+            anchor: Math.min(pos, view_1.state.doc.length)
+          },
+          scrollIntoView: true
+        });
+        view_1.focus();
+      },
+      insert: text_0 => {
+        const view_2 = viewRef.current;
+        if (!view_2) {
+          return;
         }
-    }), []);
-    const Dictation = dictation.composer?.Control;
-    return (_jsxs("div", { ref: targetRef, className: "min-w-0", children: [_jsx("div", { ref: hostRef, className: className }), Dictation && _jsx(Dictation, { buttonContainer: dictationToolbar, targetRef: targetRef, disabled: disabled, editor: () => viewRef.current })] }));
+        view_2.dispatch(insertAtSelection(view_2.state, text_0));
+        view_2.focus();
+      }
+    });
+    t13 = [];
+    $[34] = t12;
+    $[35] = t13;
+  } else {
+    t12 = $[34];
+    t13 = $[35];
+  }
+  useImperativeHandle(ref, t12, t13);
+  const Dictation = dictation.composer?.Control;
+  let t14;
+  if ($[36] !== className) {
+    t14 = /*#__PURE__*/_jsx("div", {
+      ref: hostRef,
+      className: className
+    });
+    $[36] = className;
+    $[37] = t14;
+  } else {
+    t14 = $[37];
+  }
+  let t15;
+  if ($[38] !== Dictation || $[39] !== dictationToolbar || $[40] !== disabled) {
+    t15 = Dictation && /*#__PURE__*/_jsx(Dictation, {
+      buttonContainer: dictationToolbar,
+      targetRef: targetRef,
+      disabled: disabled,
+      editor: () => viewRef.current
+    });
+    $[38] = Dictation;
+    $[39] = dictationToolbar;
+    $[40] = disabled;
+    $[41] = t15;
+  } else {
+    t15 = $[41];
+  }
+  let t16;
+  if ($[42] !== t14 || $[43] !== t15) {
+    t16 = /*#__PURE__*/_jsxs("div", {
+      ref: targetRef,
+      className: "min-w-0",
+      children: [t14, t15]
+    });
+    $[42] = t14;
+    $[43] = t15;
+    $[44] = t16;
+  } else {
+    t16 = $[44];
+  }
+  return t16;
+}
+function _temp2(tr) {
+  return tr.annotation(externalChange);
 }
+function _temp() {
+  return {
+    attributes: new Compartment(),
+    editable: new Compartment(),
+    placeholder: new Compartment(),
+    extensions: new Compartment()
+  };
+}

package/dist/chat/ui/DiffPool.js

@@ -1,26 +1,87 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
 import { useEffect } from 'react';
 import { useWorkerPool, WorkerPoolContextProvider } from '@pierre/diffs/react';
 import { useDiffTheme } from './diff-theme.js';
 // Two workers keep highlighting off the main thread without holding a shiki instance per chat node.
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const POOL_SIZE = 2;
 /* The pool reads its highlighter options once, when the singleton is made, and its theme wins over a diff's own. */
 function ThemeSync() {
-    const pool = useWorkerPool();
-    const theme = useDiffTheme();
-    useEffect(() => {
-        void pool?.setRenderOptions({ theme });
-    }, [pool, theme]);
-    return null;
+  const $ = _c(4);
+  const pool = useWorkerPool();
+  const theme = useDiffTheme();
+  let t0;
+  let t1;
+  if ($[0] !== pool || $[1] !== theme) {
+    t0 = () => {
+      pool?.setRenderOptions({
+        theme
+      });
+    };
+    t1 = [pool, theme];
+    $[0] = pool;
+    $[1] = theme;
+    $[2] = t0;
+    $[3] = t1;
+  } else {
+    t0 = $[2];
+    t1 = $[3];
+  }
+  useEffect(t0, t1);
+  return null;
 }
 /*
  * Shares one highlighter pool between every diff under it; the provider keeps a singleton behind the
  * scenes. How a worker of `@pierre/diffs/worker` is made is the bundler's business, so the app says.
  */
-export default function DiffPool({ workerFactory, children }) {
-    const theme = useDiffTheme();
-    return (_jsxs(WorkerPoolContextProvider, { poolOptions: {
-            poolSize: POOL_SIZE,
-            workerFactory
-        }, highlighterOptions: { theme }, children: [_jsx(ThemeSync, {}), children] }));
-}
+export default function DiffPool(t0) {
+  const $ = _c(9);
+  const {
+    workerFactory,
+    children
+  } = t0;
+  const theme = useDiffTheme();
+  let t1;
+  if ($[0] !== workerFactory) {
+    t1 = {
+      poolSize: POOL_SIZE,
+      workerFactory
+    };
+    $[0] = workerFactory;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] !== theme) {
+    t2 = {
+      theme
+    };
+    $[2] = theme;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  let t3;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = /*#__PURE__*/_jsx(ThemeSync, {});
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== children || $[6] !== t1 || $[7] !== t2) {
+    t4 = /*#__PURE__*/_jsxs(WorkerPoolContextProvider, {
+      poolOptions: t1,
+      highlighterOptions: t2,
+      children: [t3, children]
+    });
+    $[5] = children;
+    $[6] = t1;
+    $[7] = t2;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  return t4;
+}