@dxos/plugin-script 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/dist/lib/neutral/components/index.mjs

@@ -0,0 +1,664 @@
+import {
+  Compiler
+} from "../chunk-2REUEDUA.mjs";
+import "../chunk-J5LGTIGS.mjs";
+
+// src/components/index.ts
+import { lazy } from "react";
+
+// src/components/NotebookStack/NotebookMenu.tsx
+import React from "react";
+import { DropdownMenu, useTranslation } from "@dxos/react-ui";
+import { meta } from "#meta";
+var NotebookMenu = ({ cell, onCellInsert, onCellDelete }) => {
+  const { t } = useTranslation(meta.id);
+  return /* @__PURE__ */ React.createElement(DropdownMenu.Portal, null, /* @__PURE__ */ React.createElement(DropdownMenu.Content, null, /* @__PURE__ */ React.createElement(DropdownMenu.Viewport, null, /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("script", cell?.id)
+  }, t("notebook-cell-insert-script.label")), /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("prompt", cell?.id)
+  }, t("notebook-cell-insert-prompt.label")), /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("query", cell?.id)
+  }, t("notebook-cell-insert-query.label")), /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
+    onClick: () => onCellInsert?.("markdown", cell?.id)
+  }, t("notebook-cell-insert-markdown.label")), cell && onCellDelete && /* @__PURE__ */ React.createElement(DropdownMenu.Item, {
+    onClick: () => onCellDelete?.(cell.id)
+  }, t("notebook-cell-delete.label"))), /* @__PURE__ */ React.createElement(DropdownMenu.Arrow, null)));
+};
+
+// src/components/NotebookStack/NotebookStack.tsx
+import React4 from "react";
+import { DropdownMenu as DropdownMenu2, IconButton, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { composable as composable2, composableProps as composableProps2 } from "@dxos/react-ui";
+import { Stack, StackItem } from "@dxos/react-ui-stack";
+import { meta as meta3 } from "#meta";
+
+// src/components/NotebookStack/NotebookCell.tsx
+import React3, { useCallback, useMemo } from "react";
+import { Surface } from "@dxos/app-framework/ui";
+import { AppSurface } from "@dxos/app-toolkit/ui";
+import { Obj } from "@dxos/echo";
+import { createDocAccessor } from "@dxos/echo-client";
+import { invariant } from "@dxos/invariant";
+import { TemplateEditor } from "@dxos/plugin-assistant/components";
+import { useThemeContext as useThemeContext2, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { QueryEditor } from "@dxos/react-ui-components";
+import { Editor } from "@dxos/react-ui-editor";
+import { createBasicExtensions as createBasicExtensions2, createDataExtensions, createMarkdownExtensions, createThemeExtensions as createThemeExtensions2, decorateMarkdown } from "@dxos/ui-editor";
+import { mx } from "@dxos/ui-theme";
+import { isNonNullable as isNonNullable2 } from "@dxos/util";
+import { meta as meta2 } from "#meta";
+
+// 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 { composeRefs } from "@radix-ui/react-compose-refs";
+import { continueKeymap } from "@valtown/codemirror-continue";
+import { tsAutocomplete, tsFacet, tsHover, tsLinter, tsSync } from "@valtown/codemirror-ts";
+import React2 from "react";
+import { useThemeContext } from "@dxos/react-ui";
+import { composable, composableProps } 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 { isNonNullable } from "@dxos/util";
+var TypescriptEditor = composable(({ classNames, id, role = "article", inputMode = "vscode", env, options, initialValue, extensions, scrollTo, selection, ...props }, forwardedRef) => {
+  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__ */ React2.createElement("div", {
+    ...composableProps(props, {
+      classNames,
+      ...focusAttributes
+    }),
+    ref: composeRefs(parentRef, forwardedRef)
+  });
+});
+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").append(...children).root
+    };
+  };
+};
+
+// src/components/NotebookStack/NotebookCell.tsx
+var __dxlog_file = "/__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(meta2.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) => {
+    invariant(cell.source?.target, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 38, S: void 0, A: ["cell.source?.target", ""] });
+    Obj.update(cell.source.target, (obj) => {
+      obj.content = value;
+    });
+  }, [
+    cell
+  ]);
+  switch (cell.type) {
+    case "markdown":
+      if (!cell.source?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React3.createElement(NotebookTextEditor, {
+        id: cell.id,
+        classNames: editorStyles,
+        initialValue: cell.source.target.content,
+        extensions
+      });
+    case "script":
+      if (!cell.source?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.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__ */ React3.createElement(NotebookCellValue, {
+        cell,
+        graph
+      }));
+    case "query":
+      if (!cell.source?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React3.createElement("div", {
+        className: mx("h-full overflow-hidden grid", explorerGraph && !dragging && "grid-rows-[min-content_1fr]")
+      }, /* @__PURE__ */ React3.createElement(QueryEditor, {
+        id: cell.id,
+        classNames: [
+          editorStyles,
+          "border-b border-subdued-separator"
+        ],
+        db,
+        value: cell.source.target.content,
+        onChange: handleQueryChange
+      }), explorerGraph && !dragging && /* @__PURE__ */ React3.createElement(Surface.Surface, {
+        type: AppSurface.Section,
+        limit: 1,
+        data: {
+          subject: explorerGraph,
+          attendableId: cell.id
+        }
+      }));
+    // TODO(burdon): Use streaming response from Chat.
+    case "prompt":
+      if (!cell.prompt?.target) {
+        return null;
+      }
+      return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(TemplateEditor, {
+        id: cell.id,
+        source: cell.prompt.target.instructions,
+        lineNumbers: false,
+        classNames: editorStyles
+      }), /* @__PURE__ */ React3.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__ */ React3.createElement("div", {
+    className: mx("flex w-full bg-group-surface border-y border-subdued-separator text-description font-mono", valueStyles)
+  }, name && /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement("span", {
+    className: "text-success-text"
+  }, name), /* @__PURE__ */ React3.createElement("span", {
+    className: "text-description"
+  }, "\xA0=\xA0")), /* @__PURE__ */ React3.createElement("span", null, value));
+};
+var NotebookPromptResult = ({ cell, promptResults }) => {
+  if (!cell.prompt) {
+    return null;
+  }
+  const value = promptResults?.[cell.prompt.uri];
+  if (value == null) {
+    return null;
+  }
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: mx("flex w-full bg-group-surface text-description border-y border-subdued-separator", valueStyles)
+  }, /* @__PURE__ */ React3.createElement(NotebookTextEditor, {
+    readOnly: true,
+    value
+  }));
+};
+var NotebookTextEditor = ({ extensions: extensionsProp, readOnly, ...props }) => {
+  const { t } = useTranslation2(meta2.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__ */ React3.createElement(Editor.Root, null, /* @__PURE__ */ React3.createElement(Editor.View, {
+    ...props,
+    extensions,
+    selectionEnd: true
+  }));
+};
+
+// src/components/NotebookStack/NotebookStack.tsx
+var minSectionHeight = "min-h-[16rem]";
+var NotebookStack = composable2(({ notebook, onRearrange, db, graph, promptResults, onCellInsert, onCellDelete, env, ...props }, forwardedRef) => {
+  const sectionProps = {
+    db,
+    graph,
+    promptResults,
+    onCellInsert,
+    onCellDelete,
+    env
+  };
+  return /* @__PURE__ */ React4.createElement(Stack, {
+    ...composableProps2(props),
+    orientation: "vertical",
+    size: "contain",
+    rail: true,
+    onRearrange,
+    ref: forwardedRef
+  }, notebook?.cells.map((cell, i) => /* @__PURE__ */ React4.createElement(NotebookSection, {
+    key: i,
+    cell,
+    ...sectionProps
+  })));
+});
+var NotebookSection = ({ cell, db, env, promptResults, onCellInsert, onCellDelete, ...props }) => {
+  const { t } = useTranslation3(meta3.id);
+  const resizable = cell.type === "query";
+  return /* @__PURE__ */ React4.createElement(StackItem.Root, {
+    role: "section",
+    item: cell,
+    draggable: true,
+    classNames: resizable && minSectionHeight
+  }, /* @__PURE__ */ React4.createElement(StackItem.Heading, {
+    classNames: "h-full p-1 justify-between dx-attention-surface"
+  }, /* @__PURE__ */ React4.createElement(StackItem.DragHandle, {
+    asChild: true
+  }, /* @__PURE__ */ React4.createElement(IconButton, {
+    variant: "ghost",
+    icon: "ph--dots-six-vertical--regular",
+    iconOnly: true,
+    label: "Drag handle"
+  })), /* @__PURE__ */ React4.createElement(DropdownMenu2.Root, null, /* @__PURE__ */ React4.createElement(DropdownMenu2.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React4.createElement(IconButton, {
+    variant: "ghost",
+    icon: "ph--dots-three--regular",
+    iconOnly: true,
+    label: t("notebook-cell-insert.label")
+  })), /* @__PURE__ */ React4.createElement(NotebookMenu, {
+    cell,
+    onCellInsert,
+    onCellDelete
+  })), resizable && /* @__PURE__ */ React4.createElement(StackItem.ResizeHandle, null)), /* @__PURE__ */ React4.createElement(StackItem.DragPreview, null, ({ item: cell2 }) => /* @__PURE__ */ React4.createElement(StackItem.Content, {
+    classNames: "overflow-visible bg-group-surface border border-subdued-separator"
+  }, /* @__PURE__ */ React4.createElement(NotebookCell, {
+    db,
+    cell: cell2,
+    env,
+    dragging: true
+  }))), /* @__PURE__ */ React4.createElement(StackItem.Content, {
+    classNames: "overflow-visible"
+  }, /* @__PURE__ */ React4.createElement(NotebookCell, {
+    db,
+    cell,
+    env,
+    promptResults,
+    ...props
+  })));
+};
+
+// src/components/QueryEditor/QueryEditor.tsx
+import React5, { useState } from "react";
+import { ModuleResolutionKind, 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,
+      // Avoid `@typescript/vfs`'s deprecated `node10` default (rejected by TS 6).
+      moduleResolution: ModuleResolutionKind.Bundler
+    });
+    await compiler2.initialize(GLOBALS);
+    setCompiler(compiler2);
+  }, []);
+  if (!compiler) {
+    return null;
+  }
+  return /* @__PURE__ */ React5.createElement(TypescriptEditor, {
+    ...props,
+    env: compiler.environment
+  });
+};
+
+// src/components/ScriptToolbar/ScriptToolbar.tsx
+import { Atom } from "@effect-atom/atom-react";
+import React6, { useMemo as useMemo2 } from "react";
+import { ElevationProvider, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { composable as composable3, composableProps as composableProps3 } from "@dxos/react-ui";
+import { Menu, createGapSeparator, useMenuActions } from "@dxos/react-ui-menu";
+import { createDeploy, createFormat, createTemplateSelect, useDeployDeps } from "#hooks";
+import { meta as meta4 } from "#meta";
+var ScriptToolbar = composable3(({ script, attendableId, role, state, ...props }, forwardedRef) => {
+  const { t } = useTranslation4(meta4.id);
+  const options = useDeployDeps({
+    script
+  });
+  const menuCreator = useMemo2(() => createToolbarActions({
+    state,
+    script,
+    t,
+    ...options
+  }), [
+    state,
+    script,
+    options,
+    t
+  ]);
+  const menuActions = useMenuActions(menuCreator);
+  return /* @__PURE__ */ React6.createElement(ElevationProvider, {
+    elevation: role === "section" ? "positioned" : "base"
+  }, /* @__PURE__ */ React6.createElement(Menu.Root, {
+    ...menuActions,
+    attendableId
+  }, /* @__PURE__ */ React6.createElement(Menu.Toolbar, {
+    ...composableProps3(props),
+    ref: forwardedRef
+  })));
+});
+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 React7, { forwardRef, useRef, useState as useState2 } from "react";
+import { log } from "@dxos/log";
+import { Avatar, Icon, Input, ScrollArea, Toolbar, useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { composable as composable4, composableProps as composableProps4 } from "@dxos/react-ui";
+import { JsonHighlighter } from "@dxos/react-ui-syntax-highlighter";
+import { mx as mx2 } from "@dxos/ui-theme";
+import { meta as meta5 } from "#meta";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/TestPanel/TestPanel.tsx";
+var TestPanel = composable4(({ classNames, onInvoke, ...props }, forwardedRef) => {
+  const { t } = useTranslation5(meta5.id);
+  const inputRef = useRef(null);
+  const [input, setInput] = useState2("");
+  const [state, setState] = useState2(null);
+  const [history, setHistory] = useState2([]);
+  const scrollerRef = useRef(null);
+  const handleScroll = () => {
+    if (scrollerRef.current) {
+      scrollerRef.current.scrollTop = scrollerRef.current.scrollHeight;
+    }
+  };
+  const handleClear = () => {
+    setInput("");
+    setHistory([]);
+    inputRef.current?.focus();
+  };
+  const handleResponse = ({ text, data, error } = {}) => {
+    setHistory((history2) => [
+      ...history2,
+      {
+        type: "response",
+        text,
+        data,
+        error
+      }
+    ]);
+    setState(null);
+    handleScroll();
+  };
+  const handleRequest = async (input2) => {
+    if (!onInvoke) {
+      handleResponse({
+        error: new Error("Function not deployed")
+      });
+      return;
+    }
+    let data = input2;
+    let displayText = input2;
+    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);
+        displayText = JSON.stringify(data, null, 2);
+      } catch (err) {
+        handleResponse({
+          error: new Error("Invalid JSON input")
+        });
+        return;
+      }
+    }
+    try {
+      setState("pending");
+      setInput("");
+      setHistory((history2) => [
+        ...history2,
+        {
+          type: "request",
+          text: displayText
+        }
+      ]);
+      setTimeout(handleScroll);
+      const result = await onInvoke(data);
+      if (typeof result === "string") {
+        handleResponse({
+          text: result
+        });
+      } else {
+        handleResponse({
+          data: result
+        });
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      handleResponse({
+        error
+      });
+      log.catch(err, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 90, S: void 0 });
+    }
+  };
+  return /* @__PURE__ */ React7.createElement("div", {
+    ...composableProps4(props, {
+      classNames: [
+        "flex flex-col h-full overflow-hidden",
+        classNames
+      ]
+    }),
+    ref: forwardedRef
+  }, /* @__PURE__ */ React7.createElement(MessageThread, {
+    ref: scrollerRef,
+    state,
+    history
+  }), /* @__PURE__ */ React7.createElement(Toolbar.Root, null, /* @__PURE__ */ React7.createElement(Input.Root, null, /* @__PURE__ */ React7.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__ */ React7.createElement(Toolbar.IconButton, {
+    icon: "ph--play--regular",
+    label: "Execute",
+    iconOnly: true,
+    onClick: () => handleRequest(input)
+  }), /* @__PURE__ */ React7.createElement(Toolbar.IconButton, {
+    icon: "ph--trash--regular",
+    label: "Clear",
+    iconOnly: true,
+    onClick: handleClear
+  })));
+});
+var MessageThread = /* @__PURE__ */ forwardRef(({ state, history }, forwardedRef) => {
+  return /* @__PURE__ */ React7.createElement(ScrollArea.Root, {
+    orientation: "vertical",
+    classNames: "h-full",
+    ref: forwardedRef
+  }, /* @__PURE__ */ React7.createElement(ScrollArea.Viewport, {
+    classNames: "gap-6 p-2"
+  }, history.map((message, i) => /* @__PURE__ */ React7.createElement("div", {
+    key: i,
+    className: "grid grid-cols-[2rem_1fr_2rem]"
+  }, /* @__PURE__ */ React7.createElement("div", {
+    className: "p-1"
+  }, message.type === "response" && /* @__PURE__ */ React7.createElement(RobotAvatar, null)), /* @__PURE__ */ React7.createElement("div", {
+    className: "overflow-auto"
+  }, /* @__PURE__ */ React7.createElement(MessageItem, {
+    message
+  })))), state === "pending" && /* @__PURE__ */ React7.createElement("div", {
+    className: "grid grid-cols-[2rem_1fr_2rem]"
+  }, /* @__PURE__ */ React7.createElement("div", {
+    className: "p-1"
+  }, /* @__PURE__ */ React7.createElement(Icon, {
+    icon: "ph--spinner--regular",
+    size: 6,
+    classNames: "animate-spin"
+  })))));
+});
+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__ */ React7.createElement("div", {
+    className: mx2("flex", type === "request" ? "ml-[1rem] justify-end" : "mr-[1rem]", classNames)
+  }, error && /* @__PURE__ */ React7.createElement("div", {
+    className: mx2(wrapper, "whitespace-pre text-error-text")
+  }, String(error)), text !== void 0 && /* @__PURE__ */ React7.createElement("div", {
+    className: mx2(wrapper, type === "request" && "bg-primary-500 dark:bg-primary-600")
+  }, text || "\xD8"), data && /* @__PURE__ */ React7.createElement(JsonHighlighter, {
+    data,
+    classNames: mx2(wrapper, "text-xs")
+  }));
+};
+var RobotAvatar = () => /* @__PURE__ */ React7.createElement(Avatar.Root, null, /* @__PURE__ */ React7.createElement(Avatar.Content, {
+  size: 6,
+  variant: "circle",
+  icon: "ph--drone--regular"
+}));
+
+// src/components/index.ts
+var ScriptPluginSettings = lazy(() => import("../ScriptPluginSettings-T4JMUSHN.mjs"));
+export {
+  NotebookMenu,
+  NotebookStack,
+  QueryEditor2 as QueryEditor,
+  ScriptPluginSettings,
+  ScriptToolbar,
+  TestPanel,
+  TypescriptEditor
+};
+//# sourceMappingURL=index.mjs.map