@dxos/plugin-script 0.8.4-main.67995b8 → 0.8.4-main.6fa680abb7

package/dist/lib/browser/chunk-MVIWELNH.mjs

@@ -0,0 +1,789 @@
+import {
+  Compiler
+} from "./chunk-ATTZUDT7.mjs";
+import {
+  createDeploy,
+  createFormat,
+  createTemplateSelect,
+  useDeployDeps
+} from "./chunk-7LHEB2QO.mjs";
+import {
+  meta
+} from "./chunk-37XPSUAH.mjs";
+
+// src/components/FramePanel/FramePanel.tsx
+import React, { useEffect, useRef } from "react";
+import { clientServiceBundle } from "@dxos/client-protocol";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { useClient } from "@dxos/react-client";
+import { createProtoRpcPeer } from "@dxos/rpc";
+import { createIFramePort } from "@dxos/rpc-tunnel";
+import { mx } from "@dxos/ui-theme";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/FramePanel/FramePanel.tsx";
+var FramePanel = ({ containerUrl, result, debug = true }) => {
+  const client = useClient();
+  const iframeRef = useRef(null);
+  useEffect(() => {
+    if (iframeRef.current) {
+      const rpc = createProtoRpcPeer({
+        exposed: clientServiceBundle,
+        handlers: client._services.services,
+        port: createIFramePort({
+          channel: "frame",
+          iframe: iframeRef.current,
+          origin: "*"
+        })
+      });
+      rpc.open().catch((e) => log.catch(e, void 0, {
+        F: __dxlog_file,
+        L: 41,
+        S: void 0,
+        C: (f, a) => f(...a)
+      }));
+      return () => {
+        rpc.close().catch((e) => log.catch(e, void 0, {
+          F: __dxlog_file,
+          L: 43,
+          S: void 0,
+          C: (f, a) => f(...a)
+        }));
+      };
+    }
+  }, [
+    iframeRef
+  ]);
+  invariant(result.sourceHash, "Source hash is required.", {
+    F: __dxlog_file,
+    L: 49,
+    S: void 0,
+    A: [
+      "result.sourceHash",
+      "'Source hash is required.'"
+    ]
+  });
+  const sourceHash = Buffer.from(result.sourceHash).toString("hex");
+  const src = "bundle" in result ? `${containerUrl}?ts=${sourceHash}#code=${encodeURIComponent(new TextDecoder().decode(Object.values(result.bundle)[0]))}` : void 0;
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("iframe", {
+    ref: iframeRef,
+    sandbox: "allow-scripts",
+    src,
+    style: {
+      width: "100%",
+      height: "100%"
+    }
+  }), debug && /* @__PURE__ */ React.createElement("div", {
+    className: "relative"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: mx("flex absolute right-2 bottom-2 w-[30rem] h-[200px] bg-base-surface ring rounded-sm", "z-20 overflow-x-hidden overflow-y-auto")
+  }, /* @__PURE__ */ React.createElement("pre", {
+    className: "text-xs whitespace-break-spaces break-all p-2"
+  }, JSON.stringify({
+    timestamp: result.timestamp,
+    sourceHash,
+    error: "error" in result ? result.error : void 0,
+    src
+  }, void 0, 2)))));
+};
+
+// src/components/NotebookStack/NotebookMenu.tsx
+import React2 from "react";
+import { DropdownMenu, useTranslation } from "@dxos/react-ui";
+var NotebookMenu = ({ cell, onCellInsert, onCellDelete }) => {
+  const { t } = useTranslation(meta.id);
+  return /* @__PURE__ */ React2.createElement(DropdownMenu.Portal, null, /* @__PURE__ */ React2.createElement(DropdownMenu.Content, null, /* @__PURE__ */ React2.createElement(DropdownMenu.Viewport, null, /* @__PURE__ */ React2.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("script", cell?.id)
+  }, t("notebook cell insert script label")), /* @__PURE__ */ React2.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("prompt", cell?.id)
+  }, t("notebook cell insert prompt label")), /* @__PURE__ */ React2.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("query", cell?.id)
+  }, t("notebook cell insert query label")), /* @__PURE__ */ React2.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("markdown", cell?.id)
+  }, t("notebook cell insert markdown label")), cell && onCellDelete && /* @__PURE__ */ React2.createElement(DropdownMenu.Item, {
+    onClick: () => onCellDelete?.(cell.id)
+  }, t("notebook cell delete label"))), /* @__PURE__ */ React2.createElement(DropdownMenu.Arrow, null)));
+};
+
+// src/components/TypescriptEditor/TypescriptEditor.tsx
+import { autocompletion, completionKeymap } from "@codemirror/autocomplete";
+import { javascript } from "@codemirror/lang-javascript";
+import { HighlightStyle } from "@codemirror/language";
+import { lintKeymap } from "@codemirror/lint";
+import { Prec } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+import { tags } from "@lezer/highlight";
+import { continueKeymap } from "@valtown/codemirror-continue";
+import { tsAutocomplete, tsFacet, tsHover, tsLinter, tsSync } from "@valtown/codemirror-ts";
+import React3, { memo } from "react";
+import { useThemeContext } from "@dxos/react-ui";
+import { useTextEditor } from "@dxos/react-ui-editor";
+import { Domino } from "@dxos/ui";
+import { InputModeExtensions, createBasicExtensions, createThemeExtensions, defaultStyles } from "@dxos/ui-editor";
+import { mx as mx2 } from "@dxos/ui-theme";
+import { isNonNullable } from "@dxos/util";
+var TypescriptEditor = /* @__PURE__ */ memo(({ classNames, id, role = "article", inputMode = "vscode", env, options, initialValue, extensions, scrollTo, selection }) => {
+  const { themeMode } = useThemeContext();
+  const { parentRef, focusAttributes } = useTextEditor(() => ({
+    id,
+    initialValue,
+    selection,
+    scrollTo,
+    extensions: [
+      extensions,
+      createBasicExtensions({
+        highlightActiveLine: true,
+        indentWithTab: true,
+        lineNumbers: true,
+        lineWrapping: false,
+        scrollPastEnd: role !== "section",
+        search: true,
+        ...options
+      }),
+      createThemeExtensions({
+        monospace: true,
+        themeMode,
+        syntaxHighlighting: true
+      }),
+      InputModeExtensions[inputMode],
+      javascript({
+        typescript: true
+      }),
+      autocompletion({
+        override: env ? [
+          tsAutocomplete()
+        ] : void 0
+      }),
+      // Continues block comments when pressing Enter.
+      Prec.high(keymap.of(continueKeymap)),
+      keymap.of(completionKeymap),
+      keymap.of(lintKeymap),
+      // https://github.com/val-town/codemirror-ts
+      env && [
+        // TODO(burdon): Fix type.
+        tsFacet.of({
+          env,
+          path: `./src/${id}.ts`
+        }),
+        tsSync(),
+        tsLinter(),
+        tsHover({
+          renderTooltip: createTooltipRenderer(themeMode)
+        })
+      ]
+    ].filter(isNonNullable)
+  }), [
+    themeMode,
+    id,
+    extensions,
+    inputMode,
+    selection,
+    scrollTo,
+    env
+  ]);
+  return /* @__PURE__ */ React3.createElement("div", {
+    ref: parentRef,
+    className: mx2(classNames),
+    ...focusAttributes
+  });
+});
+var createTooltipRenderer = (themeMode) => {
+  const theme = HighlightStyle.define(themeMode === "dark" ? defaultStyles.dark : defaultStyles.light);
+  const classFromKind = (_kind) => {
+    const kind = _kind.endsWith("Name") ? "name" : _kind;
+    const validTag = kind in tags;
+    if (!validTag) {
+      return "";
+    }
+    const tag = tags[kind];
+    if (typeof tag === "function") {
+      return "";
+    }
+    return theme.style([
+      tag
+    ]) ?? "";
+  };
+  return (info) => {
+    const children = info.quickInfo?.displayParts?.map(({ kind, text }) => Domino.of("span").classNames(classFromKind(kind)).text(text)) ?? [];
+    return {
+      dom: Domino.of("div").classNames("xs:max-w-80 max-w-lg p-1 bg-base-surface rounded-sm border border-separator").children(...children).root
+    };
+  };
+};
+
+// src/components/NotebookStack/NotebookStack.tsx
+import React5 from "react";
+import { DropdownMenu as DropdownMenu2, IconButton, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { Stack, StackItem } from "@dxos/react-ui-stack";
+
+// src/components/NotebookStack/NotebookCell.tsx
+import React4, { useCallback, useMemo } from "react";
+import { Surface } from "@dxos/app-framework/ui";
+import { Obj } from "@dxos/echo";
+import { createDocAccessor } from "@dxos/echo-db";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { TemplateEditor } from "@dxos/plugin-assistant";
+import { useThemeContext as useThemeContext2, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { QueryEditor } from "@dxos/react-ui-components";
+import { EditorContent } from "@dxos/react-ui-editor";
+import { createBasicExtensions as createBasicExtensions2, createDataExtensions, createMarkdownExtensions, createThemeExtensions as createThemeExtensions2, decorateMarkdown } from "@dxos/ui-editor";
+import { mx as mx3 } from "@dxos/ui-theme";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/NotebookStack/NotebookCell.tsx";
+var editorStyles = "p-2 ps-3";
+var valueStyles = "p-1 ps-3";
+var NotebookCell = ({ db, graph, dragging, cell, promptResults, env }) => {
+  const { t } = useTranslation2(meta.id);
+  const extensions = useMemo(() => {
+    return cell.source?.target ? [
+      createDataExtensions({
+        id: cell.id,
+        text: createDocAccessor(cell.source.target, [
+          "content"
+        ])
+      })
+    ].filter(isNonNullable2) : [];
+  }, [
+    cell.source?.target
+  ]);
+  const explorerGraph = cell.graph?.target;
+  const handleQueryChange = useCallback((value) => {
+    invariant2(cell.source?.target, void 0, {
+      F: __dxlog_file2,
+      L: 63,
+      S: void 0,
+      A: [
+        "cell.source?.target",
+        ""
+      ]
+    });
+    Obj.change(cell.source.target, (s) => {
+      s.content = value;
+    });
+  }, [
+    cell
+  ]);
+  switch (cell.type) {
+    case "markdown":
+      if (!cell.source?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React4.createElement(NotebookTextEditor, {
+        id: cell.id,
+        classNames: editorStyles,
+        initialValue: cell.source.target.content,
+        extensions
+      });
+    case "script":
+      if (!cell.source?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(TypescriptEditor, {
+        id: cell.id,
+        role: "section",
+        classNames: editorStyles,
+        initialValue: cell.source.target.content,
+        extensions,
+        env,
+        options: {
+          placeholder: t("notebook cell placeholder"),
+          highlightActiveLine: false,
+          lineNumbers: false
+        }
+      }), /* @__PURE__ */ React4.createElement(NotebookCellValue, {
+        cell,
+        graph
+      }));
+    case "query":
+      if (!cell.source?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React4.createElement("div", {
+        className: mx3("h-full overflow-hidden grid", explorerGraph && !dragging && "grid-rows-[min-content_1fr]")
+      }, /* @__PURE__ */ React4.createElement(QueryEditor, {
+        id: cell.id,
+        classNames: [
+          editorStyles,
+          "border-b border-subdued-separator"
+        ],
+        db,
+        value: cell.source.target.content,
+        onChange: handleQueryChange
+      }), explorerGraph && !dragging && /* @__PURE__ */ React4.createElement(Surface.Surface, {
+        role: "section",
+        limit: 1,
+        data: {
+          subject: explorerGraph
+        }
+      }));
+    // TODO(burdon): Use streaming response from Chat.
+    case "prompt":
+      if (!cell.prompt?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(TemplateEditor, {
+        id: cell.id,
+        template: cell.prompt.target.instructions,
+        lineNumbers: false,
+        classNames: editorStyles
+      }), /* @__PURE__ */ React4.createElement(NotebookPromptResult, {
+        cell,
+        promptResults
+      }));
+    default:
+      return null;
+  }
+};
+var NotebookCellValue = ({ cell, graph }) => {
+  const name = graph?.getExpressions()[cell.id]?.name;
+  const value = graph?.getValue(cell.id);
+  if (value == null) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement("div", {
+    className: mx3("flex w-full bg-group-surface border-y border-subdued-separator text-description font-mono", valueStyles)
+  }, name && /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement("span", {
+    className: "text-success-text"
+  }, name), /* @__PURE__ */ React4.createElement("span", {
+    className: "text-description"
+  }, "\xA0=\xA0")), /* @__PURE__ */ React4.createElement("span", null, value));
+};
+var NotebookPromptResult = ({ cell, promptResults }) => {
+  if (!cell.prompt) {
+    return null;
+  }
+  const value = promptResults?.[cell.prompt.dxn.toString()];
+  if (value == null) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement("div", {
+    className: mx3("flex w-full bg-group-surface text-description border-y border-subdued-separator", valueStyles)
+  }, /* @__PURE__ */ React4.createElement(NotebookTextEditor, {
+    readOnly: true,
+    value
+  }));
+};
+var NotebookTextEditor = ({ extensions: extensionsProp, readOnly, ...props }) => {
+  const { t } = useTranslation2(meta.id);
+  const { themeMode } = useThemeContext2();
+  const extensions = useMemo(() => {
+    return [
+      createBasicExtensions2({
+        placeholder: t("notebook markdown placeholder"),
+        readOnly
+      }),
+      createThemeExtensions2({
+        themeMode,
+        syntaxHighlighting: true
+      }),
+      createMarkdownExtensions(),
+      decorateMarkdown(),
+      extensionsProp
+    ].filter(isNonNullable2);
+  }, [
+    extensionsProp
+  ]);
+  return /* @__PURE__ */ React4.createElement(EditorContent, {
+    ...props,
+    extensions,
+    selectionEnd: true
+  });
+};
+
+// src/components/NotebookStack/NotebookStack.tsx
+var minSectionHeight = "min-h-[16rem]";
+var NotebookStack = ({ classNames, notebook, onRearrange, ...props }) => {
+  return /* @__PURE__ */ React5.createElement(Stack, {
+    classNames,
+    orientation: "vertical",
+    size: "contain",
+    rail: true,
+    onRearrange
+  }, notebook?.cells.map((cell, i) => /* @__PURE__ */ React5.createElement(NotebookSection, {
+    key: i,
+    cell,
+    ...props
+  })));
+};
+var NotebookSection = ({ cell, db, env, promptResults, onCellInsert, onCellDelete, ...props }) => {
+  const { t } = useTranslation3(meta.id);
+  const resizable = cell.type === "query";
+  return /* @__PURE__ */ React5.createElement(StackItem.Root, {
+    role: "section",
+    item: cell,
+    draggable: true,
+    classNames: resizable && minSectionHeight
+  }, /* @__PURE__ */ React5.createElement(StackItem.Heading, {
+    classNames: "h-full p-1 justify-between dx-attention-surface"
+  }, /* @__PURE__ */ React5.createElement(StackItem.DragHandle, {
+    asChild: true
+  }, /* @__PURE__ */ React5.createElement(IconButton, {
+    variant: "ghost",
+    icon: "ph--dots-six-vertical--regular",
+    iconOnly: true,
+    label: "Drag handle"
+  })), /* @__PURE__ */ React5.createElement(DropdownMenu2.Root, null, /* @__PURE__ */ React5.createElement(DropdownMenu2.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React5.createElement(IconButton, {
+    variant: "ghost",
+    icon: "ph--dots-three--regular",
+    iconOnly: true,
+    label: t("notebook cell insert label")
+  })), /* @__PURE__ */ React5.createElement(NotebookMenu, {
+    cell,
+    onCellInsert,
+    onCellDelete
+  })), resizable && /* @__PURE__ */ React5.createElement(StackItem.ResizeHandle, null)), /* @__PURE__ */ React5.createElement(StackItem.DragPreview, null, ({ item: cell2 }) => /* @__PURE__ */ React5.createElement(StackItem.Content, {
+    classNames: "overflow-visible bg-group-surface border border-subdued-separator"
+  }, /* @__PURE__ */ React5.createElement(NotebookCell, {
+    db,
+    cell: cell2,
+    env,
+    dragging: true
+  }))), /* @__PURE__ */ React5.createElement(StackItem.Content, {
+    classNames: "overflow-visible"
+  }, /* @__PURE__ */ React5.createElement(NotebookCell, {
+    db,
+    cell,
+    env,
+    promptResults,
+    ...props
+  })));
+};
+
+// src/components/QueryEditor/QueryEditor.tsx
+import React6, { useState } from "react";
+import { ScriptTarget } from "typescript";
+import queryApi from "@dxos/echo-query/api.d.ts?raw";
+import { useAsyncEffect } from "@dxos/react-ui";
+var GLOBALS = `
+  namespace QueryAPI {
+    ${queryApi}
+  }
+
+  declare global {
+    const Query: typeof QueryAPI.Query;
+    const Filter: typeof QueryAPI.Filter;
+    const Order: typeof QueryAPI.Order;
+  }
+
+  export {};
+`;
+var QueryEditor2 = (props) => {
+  const [compiler, setCompiler] = useState();
+  useAsyncEffect(async () => {
+    const compiler2 = new Compiler({
+      lib: [
+        "ES5"
+      ],
+      target: ScriptTarget.ES2022
+    });
+    await compiler2.initialize(GLOBALS);
+    setCompiler(compiler2);
+  }, []);
+  if (!compiler) {
+    return null;
+  }
+  return /* @__PURE__ */ React6.createElement(TypescriptEditor, {
+    ...props,
+    env: compiler.environment
+  });
+};
+
+// src/components/ScriptToolbar/ScriptToolbar.tsx
+import { Atom } from "@effect-atom/atom-react";
+import React7, { useMemo as useMemo2 } from "react";
+import { Obj as Obj2 } from "@dxos/echo";
+import { ElevationProvider, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { Menu, createGapSeparator, useMenuActions } from "@dxos/react-ui-menu";
+var ScriptToolbar = ({ script, role, state, ...props }) => {
+  const { t } = useTranslation4(meta.id);
+  const options = useDeployDeps({
+    script
+  });
+  const menu = useMemo2(() => createToolbarActions({
+    state,
+    script,
+    t,
+    ...options
+  }), [
+    state,
+    script,
+    options,
+    t
+  ]);
+  const actions = useMenuActions(menu);
+  return /* @__PURE__ */ React7.createElement(ElevationProvider, {
+    elevation: role === "section" ? "positioned" : "base"
+  }, /* @__PURE__ */ React7.createElement(Menu.Root, {
+    ...props,
+    ...actions,
+    attendableId: Obj2.getDXN(script).toString()
+  }, /* @__PURE__ */ React7.createElement(Menu.Toolbar, null)));
+};
+var createToolbarActions = ({ state, script, ...options }) => Atom.make((get) => {
+  get(state.atom);
+  const templateSelect = createTemplateSelect(script);
+  const format = createFormat(script);
+  const gap = createGapSeparator();
+  const deploy = createDeploy({
+    state,
+    script,
+    ...options
+  });
+  return {
+    nodes: [
+      ...templateSelect.nodes,
+      ...format.nodes,
+      ...gap.nodes,
+      ...deploy.nodes
+    ],
+    edges: [
+      ...templateSelect.edges,
+      ...format.edges,
+      ...gap.edges,
+      ...deploy.edges
+    ]
+  };
+});
+
+// src/components/TestPanel/TestPanel.tsx
+import React8, { forwardRef, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { log as log2 } from "@dxos/log";
+import { Avatar, Icon, Input, ScrollArea, Toolbar, useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { SyntaxHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import { mx as mx4 } from "@dxos/ui-theme";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/TestPanel/TestPanel.tsx";
+var TestPanel = ({ classNames, functionUrl }) => {
+  const { t } = useTranslation5(meta.id);
+  const inputRef = useRef2(null);
+  const [input, setInput] = useState2("");
+  const [result, setResult] = useState2("");
+  const [state, setState] = useState2(null);
+  const [history, setHistory] = useState2([]);
+  const scrollerRef = useRef2(null);
+  const handleScroll = () => {
+    if (scrollerRef.current) {
+      scrollerRef.current.scrollTop = scrollerRef.current.scrollHeight;
+    }
+  };
+  const controller = useRef2(null);
+  useEffect2(() => {
+    return () => {
+      handleStop();
+    };
+  }, []);
+  const handleStop = () => {
+    controller.current?.abort("stop");
+    controller.current = null;
+  };
+  const handleClear = () => {
+    handleStop();
+    setInput("");
+    setResult("");
+    setHistory([]);
+    inputRef.current?.focus();
+  };
+  const handleResponse = ({ text, data, error } = {}) => {
+    controller.current = null;
+    setHistory((history2) => [
+      ...history2,
+      {
+        type: "response",
+        text,
+        data,
+        error
+      }
+    ]);
+    setResult("");
+    setState(null);
+    handleScroll();
+  };
+  const handleRequest = async (input2) => {
+    try {
+      setState("pending");
+      let data = null;
+      if (input2.charAt(0) === "{") {
+        try {
+          const validJsonString = input2.replace(/'/g, '"').replace(/([{,]\s*)([a-zA-Z0-9_]+)(\s*:)/g, '$1"$2"$3');
+          data = JSON.parse(validJsonString);
+          input2 = JSON.stringify(data, null, 2);
+        } catch (err) {
+          inputRef.current?.focus();
+          return;
+        }
+      }
+      setInput("");
+      setResult("");
+      setHistory((history2) => [
+        ...history2,
+        {
+          type: "request",
+          text: input2
+        }
+      ]);
+      setTimeout(() => {
+        handleScroll();
+      });
+      controller.current = new AbortController();
+      const response = await fetch(functionUrl, {
+        signal: controller.current.signal,
+        method: "POST",
+        body: input2,
+        headers: {
+          "Content-Type": data ? "application/json" : "text/plain"
+        }
+      });
+      if (!response.ok) {
+        const text2 = await response.text();
+        handleResponse({
+          error: new Error(text2 || response.statusText || String(response.status))
+        });
+        return;
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType === "application/json") {
+        const data2 = await response.json();
+        handleResponse({
+          data: data2
+        });
+        return;
+      }
+      setState("responding");
+      let text = "";
+      const reader = response.body.getReader();
+      const pump = async ({ done, value }) => {
+        text = text + new TextDecoder().decode(value);
+        if (!controller.current || done) {
+          handleResponse({
+            text
+          });
+          return;
+        }
+        setResult(text);
+        setTimeout(() => {
+          handleScroll();
+        });
+        return reader.read().then(pump);
+      };
+      void reader.read().then(pump).catch((err) => {
+        if (err.name !== "AbortError") {
+          log2.catch(err, void 0, {
+            F: __dxlog_file3,
+            L: 162,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      });
+    } catch (err) {
+      if (err !== "stop") {
+        const error = err instanceof Error ? err : new Error(err);
+        handleResponse({
+          error
+        });
+        log2.catch(err, void 0, {
+          F: __dxlog_file3,
+          L: 169,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      } else {
+        handleResponse();
+      }
+    }
+  };
+  return /* @__PURE__ */ React8.createElement("div", {
+    className: mx4("flex flex-col h-full overflow-hidden", classNames)
+  }, /* @__PURE__ */ React8.createElement(MessageThread, {
+    ref: scrollerRef,
+    state,
+    result,
+    history
+  }), /* @__PURE__ */ React8.createElement(Toolbar.Root, null, /* @__PURE__ */ React8.createElement(Input.Root, null, /* @__PURE__ */ React8.createElement(Input.TextInput, {
+    ref: inputRef,
+    autoFocus: true,
+    placeholder: t("function request placeholder"),
+    value: input,
+    onChange: (ev) => setInput(ev.target.value),
+    onKeyDown: (ev) => ev.key === "Enter" && handleRequest(input)
+  })), /* @__PURE__ */ React8.createElement(Toolbar.IconButton, {
+    icon: "ph--play--regular",
+    size: 4,
+    label: "Execute",
+    iconOnly: true,
+    onClick: () => handleRequest(input)
+  }), /* @__PURE__ */ React8.createElement(Toolbar.IconButton, {
+    icon: state ? "ph--stop--regular" : "ph--trash--regular",
+    size: 4,
+    label: state ? "Stop" : "Clear",
+    iconOnly: true,
+    onClick: () => state ? handleStop() : handleClear()
+  })));
+};
+var MessageThread = /* @__PURE__ */ forwardRef(({ state, history, result }, forwardedRef) => {
+  return /* @__PURE__ */ React8.createElement(ScrollArea.Root, {
+    orientation: "vertical",
+    classNames: "h-full",
+    ref: forwardedRef
+  }, /* @__PURE__ */ React8.createElement(ScrollArea.Viewport, {
+    classNames: "gap-6 p-2"
+  }, history.map((message, i) => /* @__PURE__ */ React8.createElement("div", {
+    key: i,
+    className: "grid grid-cols-[2rem_1fr_2rem]"
+  }, /* @__PURE__ */ React8.createElement("div", {
+    className: "p-1"
+  }, message.type === "response" && /* @__PURE__ */ React8.createElement(RobotAvatar, null)), /* @__PURE__ */ React8.createElement("div", {
+    className: "overflow-auto"
+  }, /* @__PURE__ */ React8.createElement(MessageItem, {
+    message
+  })))), result?.length > 0 && /* @__PURE__ */ React8.createElement("div", {
+    className: "grid grid-cols-[2rem_1fr_2rem]"
+  }, /* @__PURE__ */ React8.createElement("div", {
+    className: "p-1"
+  }, state === "pending" && /* @__PURE__ */ React8.createElement(Icon, {
+    icon: "ph--spinner--regular",
+    size: 6,
+    classNames: "animate-spin"
+  }) || /* @__PURE__ */ React8.createElement(Icon, {
+    icon: "ph--robot--regular",
+    size: 6,
+    classNames: "animate-[pulse_1s_ease-in-out_infinite]"
+  })), /* @__PURE__ */ React8.createElement("div", {
+    className: "overflow-auto"
+  }, /* @__PURE__ */ React8.createElement(MessageItem, {
+    message: {
+      type: "response",
+      text: result
+    }
+  })))));
+});
+var MessageItem = ({ classNames, message }) => {
+  const { type, text, data, error } = message;
+  const wrapper = "p-1 px-2 rounded-md bg-hover-surface overflow-auto";
+  return /* @__PURE__ */ React8.createElement("div", {
+    className: mx4("flex", type === "request" ? "ml-[1rem] justify-end" : "mr-[1rem]", classNames)
+  }, error && /* @__PURE__ */ React8.createElement("div", {
+    className: mx4(wrapper, "whitespace-pre text-error-text")
+  }, String(error)), text !== void 0 && /* @__PURE__ */ React8.createElement("div", {
+    className: mx4(wrapper, type === "request" && "bg-primary-500 dark:bg-primary-600")
+  }, text || "\xD8"), data && /* @__PURE__ */ React8.createElement(SyntaxHighlighter, {
+    language: "json",
+    className: mx4(wrapper, "text-xs")
+  }, JSON.stringify(data, null, 2)));
+};
+var RobotAvatar = () => /* @__PURE__ */ React8.createElement(Avatar.Root, null, /* @__PURE__ */ React8.createElement(Avatar.Content, {
+  size: 6,
+  variant: "circle",
+  icon: "ph--robot--regular"
+}));
+
+export {
+  FramePanel,
+  NotebookMenu,
+  TypescriptEditor,
+  NotebookStack,
+  QueryEditor2 as QueryEditor,
+  ScriptToolbar,
+  TestPanel
+};
+//# sourceMappingURL=chunk-MVIWELNH.mjs.map