@dxfeed/dxlink-console-rpc 0.0.0-stage → 0.10.0

package/build/index.mjs

@@ -0,0 +1,775 @@
+// src/plugin.tsx
+import { defineChannelPlugin } from "@dxfeed/dxlink-console-core";
+import SwapHorizIcon2 from "@mui/icons-material/SwapHoriz";
+
+// src/descriptors.ts
+import {
+  createFileRegistry,
+  fromBinary,
+  fromJson,
+  ScalarType,
+  toJson
+} from "@bufbuild/protobuf";
+import { protoCamelCase } from "@bufbuild/protobuf/reflect";
+import { FileDescriptorSetSchema } from "@bufbuild/protobuf/wkt";
+var METHOD_MODELS = {
+  unary: {
+    label: "REQUEST_RESPONSE",
+    supported: true,
+    description: "One request, one response."
+  },
+  server_streaming: {
+    label: "REQUEST_STREAM",
+    supported: true,
+    description: "One request, a stream of responses."
+  },
+  bidi_streaming: {
+    label: "STREAM_STREAM",
+    supported: true,
+    description: "A stream of requests, a stream of responses."
+  },
+  client_streaming: {
+    label: "STREAM_RESPONSE",
+    supported: false,
+    description: "Not supported \u2014 the dxLink v1.0 wire has no graceful request half-close, so the server is never told the requests ended."
+  }
+};
+var methodModel = (method) => METHOD_MODELS[method.methodKind];
+var isMethodSupported = (method) => methodModel(method).supported;
+var decodeDescriptorSet = (bytes) => {
+  const firstByte = bytes.find((byte) => byte > 32);
+  if (firstByte === 123) {
+    return fromJson(FileDescriptorSetSchema, JSON.parse(new TextDecoder().decode(bytes)));
+  }
+  return fromBinary(FileDescriptorSetSchema, bytes);
+};
+var deduceMissingJsonNames = (registry) => {
+  for (const desc of registry) {
+    if (desc.kind !== "message") continue;
+    for (const field of desc.fields) {
+      if (field.jsonName === "") {
+        ;
+        field.jsonName = protoCamelCase(field.name);
+      }
+    }
+  }
+  return registry;
+};
+var parseDescriptorSet = (bytes) => deduceMissingJsonNames(createFileRegistry(decodeDescriptorSet(bytes)));
+var BINARY_ACCEPT = "application/protobuf, application/x-protobuf, application/octet-stream";
+var fetchDescriptorSet = async (url) => {
+  let response;
+  try {
+    response = await fetch(url, { headers: { Accept: BINARY_ACCEPT } });
+  } catch (error) {
+    throw new Error(
+      "the endpoint must be reachable, and one on another origin must allow cross-origin requests including the Accept header",
+      { cause: error }
+    );
+  }
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+  return parseDescriptorSet(new Uint8Array(await response.arrayBuffer()));
+};
+var readDescriptorSet = async (file) => parseDescriptorSet(new Uint8Array(await file.arrayBuffer()));
+var listServices = (registry) => {
+  const services = [];
+  for (const desc of registry) {
+    if (desc.kind === "service") {
+      services.push(desc);
+    }
+  }
+  return services.sort((a, b) => a.typeName.localeCompare(b.typeName));
+};
+var fieldTemplate = (field) => {
+  switch (field.fieldKind) {
+    case "list":
+      return [];
+    case "map":
+      return {};
+    case "message":
+      return {};
+    case "enum":
+      return field.enum.values[0]?.name ?? 0;
+    case "scalar":
+      switch (field.scalar) {
+        case ScalarType.BOOL:
+          return false;
+        case ScalarType.STRING:
+        case ScalarType.BYTES:
+          return "";
+        case ScalarType.INT64:
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+          return "0";
+        default:
+          return 0;
+      }
+  }
+};
+var createRequestTemplate = (message) => Object.fromEntries(message.fields.map((field) => [field.jsonName, fieldTemplate(field)]));
+var parseRequest = (message, json) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (error) {
+    return { error: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  try {
+    return { message: fromJson(message, parsed) };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+};
+var formatMessage = (schema, message) => toJson(schema, message);
+
+// src/rpc-channel.tsx
+import { useVM } from "@dxfeed/dxlink-console-core";
+import { ChannelWidget } from "@dxfeed/dxlink-console-core";
+import { useConnectionVM } from "@dxfeed/dxlink-console-core";
+import SendIcon from "@mui/icons-material/Send";
+import SwapHorizIcon from "@mui/icons-material/SwapHoriz";
+import Alert from "@mui/material/Alert";
+import Box from "@mui/material/Box";
+import Button from "@mui/material/Button";
+import Chip from "@mui/material/Chip";
+import Paper from "@mui/material/Paper";
+import Stack from "@mui/material/Stack";
+import TextField from "@mui/material/TextField";
+import Typography from "@mui/material/Typography";
+import { useEffect, useState } from "react";
+
+// src/rpc-view-model.ts
+import { DXLinkLogLevel } from "@dxfeed/dxlink-api";
+import { prependError } from "@dxfeed/dxlink-console-core";
+import { createDXLinkDynamicService } from "@dxfeed/dxlink-protobuf-es";
+import { ReplaySubject } from "rxjs";
+import { createStore } from "zustand/vanilla";
+var FLUSH_INTERVAL_MS = 100;
+var MAX_RESPONSES = 200;
+var lastEntryId = 0;
+var entry = (json) => {
+  lastEntryId += 1;
+  return { id: lastEntryId, time: (/* @__PURE__ */ new Date()).toLocaleTimeString(), json };
+};
+var toDXLinkError = (error) => {
+  if (typeof error === "object" && error !== null && "type" in error && "message" in error && typeof error.message === "string") {
+    return error;
+  }
+  return { type: "UNKNOWN", message: error instanceof Error ? error.message : String(error) };
+};
+var RpcViewModel = class {
+  constructor(client, params) {
+    this.store = createStore(() => ({
+      callState: "active",
+      responses: [],
+      requests: [],
+      errors: []
+    }));
+    this.subscription = null;
+    /** Request stream for bidirectional methods; null for the other models. */
+    this.input = null;
+    this.pending = [];
+    this.flushHandle = null;
+    this.start = () => {
+      if (this.subscription !== null) return;
+      this.store.setState({ callState: "active", responses: [], requests: [], errors: [] });
+      let responses;
+      try {
+        const service = createDXLinkDynamicService(this.client, this.service, {
+          // A descriptor chosen at runtime may declare methods the wire cannot carry; the
+          // picker never offers them, and the rest of the service stays callable.
+          skipUnsupportedMethods: true,
+          // A debug console wants the protocol traffic in the browser log.
+          logLevel: DXLinkLogLevel.DEBUG
+        });
+        const call = service[this.method.localName];
+        if (call === void 0) {
+          throw new Error(`${this.service.typeName} does not expose ${this.method.name}`);
+        }
+        if (this.isBidirectional) {
+          this.input = new ReplaySubject();
+          responses = call(this.input);
+          this.emit(this.request);
+        } else {
+          responses = call(this.request);
+          this.record("requests", formatMessage(this.method.input, this.request));
+        }
+      } catch (error) {
+        this.fail(error);
+        return;
+      }
+      this.subscription = responses.subscribe({
+        next: (message) => this.handleResponse(message),
+        error: (error) => this.fail(error),
+        complete: () => this.store.setState({ callState: "completed" })
+      });
+    };
+    this.stop = () => {
+      if (this.flushHandle !== null) {
+        clearTimeout(this.flushHandle);
+        this.flushHandle = null;
+      }
+      this.pending = [];
+      this.input?.complete();
+      this.input = null;
+      this.subscription?.unsubscribe();
+      this.subscription = null;
+    };
+    /**
+     * Send another request on a bidirectional call. Rejected messages are reported as errors
+     * on this channel rather than thrown, so a typo in the editor cannot take the card down.
+     */
+    this.send = (message) => {
+      if (!this.isBidirectional || this.input === null) return;
+      this.emit(message);
+    };
+    this.clearErrors = () => {
+      this.store.setState({ errors: [] });
+    };
+    this.close = () => {
+      this.stop();
+    };
+    this.dispose = () => {
+      this.stop();
+    };
+    this.emit = (message) => {
+      try {
+        this.input?.next(message);
+        this.record("requests", formatMessage(this.method.input, message));
+      } catch (error) {
+        this.fail(error);
+      }
+    };
+    this.fail = (error) => {
+      this.store.setState((state) => ({
+        callState: "failed",
+        errors: prependError(state.errors, toDXLinkError(error))
+      }));
+    };
+    this.handleResponse = (message) => {
+      let json;
+      try {
+        json = formatMessage(this.method.output, message);
+      } catch (error) {
+        this.fail(error);
+        return;
+      }
+      this.pending = [entry(json), ...this.pending];
+      if (this.flushHandle === null) {
+        this.flushHandle = setTimeout(this.flush, FLUSH_INTERVAL_MS);
+      }
+    };
+    this.flush = () => {
+      this.flushHandle = null;
+      const pending = this.pending;
+      if (pending.length === 0) return;
+      this.pending = [];
+      this.store.setState((state) => ({
+        responses: [...pending, ...state.responses].slice(0, MAX_RESPONSES)
+      }));
+    };
+    this.record = (key, json) => {
+      this.store.setState((state) => ({
+        [key]: [entry(json), ...state[key]].slice(0, MAX_RESPONSES)
+      }));
+    };
+    this.client = client;
+    this.service = params.service;
+    this.method = params.method;
+    this.request = params.request;
+  }
+  get isBidirectional() {
+    return this.method.methodKind === "bidi_streaming";
+  }
+};
+
+// src/rpc-channel.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var RpcStatusChip = ({ state, responses }) => {
+  if (state === "failed") {
+    return /* @__PURE__ */ jsx(Chip, { size: "small", color: "error", variant: "outlined", label: "failed" });
+  }
+  if (state === "completed") {
+    return /* @__PURE__ */ jsx(Chip, { size: "small", variant: "outlined", label: "completed" });
+  }
+  return responses === 0 ? /* @__PURE__ */ jsx(Chip, { size: "small", color: "warning", variant: "outlined", label: "waiting" }) : /* @__PURE__ */ jsx(Chip, { size: "small", color: "success", variant: "outlined", label: "streaming" });
+};
+var MessageEntry = ({ entry: entry2 }) => /* @__PURE__ */ jsxs(Paper, { variant: "outlined", sx: { p: 1.5 }, children: [
+  /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "text.secondary", children: entry2.time }),
+  /* @__PURE__ */ jsx(
+    Box,
+    {
+      component: "pre",
+      sx: { m: 0, mt: 0.5, fontSize: 13, whiteSpace: "pre-wrap", wordBreak: "break-word" },
+      children: JSON.stringify(entry2.json, null, 2)
+    }
+  )
+] });
+var MessageList = ({
+  title,
+  entries,
+  empty
+}) => /* @__PURE__ */ jsxs(Stack, { spacing: 1, children: [
+  /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, sx: { alignItems: "baseline" }, children: [
+    /* @__PURE__ */ jsx(Typography, { variant: "subtitle2", children: title }),
+    /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "text.secondary", children: entries.length })
+  ] }),
+  entries.length === 0 ? /* @__PURE__ */ jsx(Typography, { variant: "body2", color: "text.secondary", children: empty }) : entries.map((entry2) => /* @__PURE__ */ jsx(MessageEntry, { entry: entry2 }, entry2.id))
+] });
+var SendRequest = ({
+  vm,
+  config,
+  active
+}) => {
+  const [json, setJson] = useState(
+    () => JSON.stringify(createRequestTemplate(config.method.input), null, 2)
+  );
+  const parsed = parseRequest(config.method.input, json);
+  return /* @__PURE__ */ jsxs(Stack, { spacing: 1, children: [
+    /* @__PURE__ */ jsx(Typography, { variant: "subtitle2", children: "Send another request" }),
+    /* @__PURE__ */ jsx(
+      TextField,
+      {
+        value: json,
+        onChange: (e) => setJson(e.target.value),
+        multiline: true,
+        minRows: 4,
+        fullWidth: true,
+        size: "small",
+        slotProps: { input: { sx: { fontFamily: "monospace", fontSize: 13 } } }
+      }
+    ),
+    "error" in parsed && /* @__PURE__ */ jsx(Alert, { severity: "error", children: parsed.error }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "contained",
+        startIcon: /* @__PURE__ */ jsx(SendIcon, {}),
+        disabled: !active || "error" in parsed,
+        onClick: () => {
+          if ("message" in parsed) vm.send(parsed.message);
+        },
+        children: "Send"
+      }
+    ) })
+  ] });
+};
+var RpcChannel = ({ title, config }) => {
+  const connectionVM = useConnectionVM();
+  const [vm] = useState(() => {
+    const client = connectionVM.getClient();
+    if (client === null) {
+      throw new Error("RPC channel opened without an active connection");
+    }
+    return new RpcViewModel(client, {
+      service: config.service,
+      method: config.method,
+      request: config.request
+    });
+  });
+  useEffect(() => {
+    vm.start();
+    return () => vm.stop();
+  }, [vm]);
+  const callState = useVM(vm, (s) => s.callState);
+  const responses = useVM(vm, (s) => s.responses);
+  const requests = useVM(vm, (s) => s.requests);
+  const errors = useVM(vm, (s) => s.errors);
+  const model = methodModel(config.method);
+  return /* @__PURE__ */ jsx(
+    ChannelWidget,
+    {
+      icon: /* @__PURE__ */ jsx(SwapHorizIcon, {}),
+      title,
+      subtitle: `${config.service.typeName} \xB7 ${config.method.name}`,
+      onClose: vm.close,
+      status: /* @__PURE__ */ jsx(RpcStatusChip, { state: callState, responses: responses.length }),
+      parameters: { service: config.service.typeName, methodName: config.method.name },
+      errors,
+      onClearErrors: vm.clearErrors,
+      children: /* @__PURE__ */ jsxs(Stack, { spacing: 2, children: [
+        /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 0.5, useFlexGap: true, sx: { flexWrap: "wrap" }, children: [
+          /* @__PURE__ */ jsx(Chip, { size: "small", variant: "outlined", label: model.label }),
+          /* @__PURE__ */ jsx(Chip, { size: "small", variant: "outlined", label: `in: ${config.method.input.typeName}` }),
+          /* @__PURE__ */ jsx(Chip, { size: "small", variant: "outlined", label: `out: ${config.method.output.typeName}` })
+        ] }),
+        vm.isBidirectional && /* @__PURE__ */ jsx(SendRequest, { vm, config, active: callState === "active" }),
+        /* @__PURE__ */ jsx(MessageList, { title: "Sent", entries: requests, empty: "Nothing sent yet." }),
+        /* @__PURE__ */ jsx(
+          MessageList,
+          {
+            title: "Received",
+            entries: responses,
+            empty: callState === "completed" ? "The server closed the channel without a response." : "Waiting for the first response\u2026"
+          }
+        )
+      ] })
+    }
+  );
+};
+
+// src/rpc-channel-request.tsx
+import { ScalarType as ScalarType2 } from "@bufbuild/protobuf";
+import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
+import UploadFileIcon from "@mui/icons-material/UploadFile";
+import Accordion from "@mui/material/Accordion";
+import AccordionDetails from "@mui/material/AccordionDetails";
+import AccordionSummary from "@mui/material/AccordionSummary";
+import Alert2 from "@mui/material/Alert";
+import Box2 from "@mui/material/Box";
+import Button2 from "@mui/material/Button";
+import Chip2 from "@mui/material/Chip";
+import FormControlLabel from "@mui/material/FormControlLabel";
+import MenuItem from "@mui/material/MenuItem";
+import Stack2 from "@mui/material/Stack";
+import Switch from "@mui/material/Switch";
+import TextField2 from "@mui/material/TextField";
+import Typography2 from "@mui/material/Typography";
+import { useMemo, useRef, useState as useState2 } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var stringify = (json) => JSON.stringify(json, null, 2);
+var isEditableField = (field) => (field.fieldKind === "scalar" || field.fieldKind === "enum") && field.oneof === void 0;
+var STRING_SCALARS = /* @__PURE__ */ new Set([
+  ScalarType2.STRING,
+  ScalarType2.BYTES,
+  ScalarType2.INT64,
+  ScalarType2.UINT64,
+  ScalarType2.FIXED64,
+  ScalarType2.SFIXED64,
+  ScalarType2.SINT64
+]);
+var scalarHelp = (scalar) => {
+  if (scalar === ScalarType2.BYTES) return "bytes \u2014 base64";
+  if (STRING_SCALARS.has(scalar) && scalar !== ScalarType2.STRING) return "64-bit \u2014 sent as a string";
+  return void 0;
+};
+var RequestFields = ({
+  message,
+  json,
+  onChange
+}) => {
+  const parsed = useMemo(() => {
+    try {
+      const value = JSON.parse(json);
+      return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+    } catch {
+      return null;
+    }
+  }, [json]);
+  const fields = message.fields.filter(isEditableField);
+  if (fields.length === 0) {
+    return null;
+  }
+  if (parsed === null) {
+    return /* @__PURE__ */ jsx2(Typography2, { variant: "body2", color: "text.secondary", children: "Fields are editable again once the request below is a JSON object." });
+  }
+  const set = (field, fieldValue) => onChange(stringify({ ...parsed, [field.jsonName]: fieldValue }));
+  return /* @__PURE__ */ jsx2(Box2, { sx: { display: "grid", gap: 2, gridTemplateColumns: { xs: "1fr", sm: "1fr 1fr" } }, children: fields.map((field) => {
+    const current = parsed[field.jsonName];
+    if (field.fieldKind === "enum") {
+      return /* @__PURE__ */ jsx2(
+        TextField2,
+        {
+          select: true,
+          label: field.name,
+          value: typeof current === "string" ? current : "",
+          onChange: (e) => set(field, e.target.value),
+          size: "small",
+          helperText: field.enum.typeName,
+          children: field.enum.values.map((enumValue) => /* @__PURE__ */ jsx2(MenuItem, { value: enumValue.name, children: enumValue.name }, enumValue.number))
+        },
+        field.number
+      );
+    }
+    if (field.fieldKind !== "scalar") {
+      return null;
+    }
+    if (field.scalar === ScalarType2.BOOL) {
+      return /* @__PURE__ */ jsx2(
+        FormControlLabel,
+        {
+          control: /* @__PURE__ */ jsx2(
+            Switch,
+            {
+              checked: current === true,
+              onChange: (e) => set(field, e.target.checked),
+              size: "small"
+            }
+          ),
+          label: field.name
+        },
+        field.number
+      );
+    }
+    if (STRING_SCALARS.has(field.scalar)) {
+      return /* @__PURE__ */ jsx2(
+        TextField2,
+        {
+          label: field.name,
+          value: typeof current === "string" ? current : "",
+          onChange: (e) => set(field, e.target.value),
+          size: "small",
+          helperText: scalarHelp(field.scalar)
+        },
+        field.number
+      );
+    }
+    return /* @__PURE__ */ jsx2(
+      TextField2,
+      {
+        label: field.name,
+        type: "number",
+        value: typeof current === "number" ? String(current) : "",
+        onChange: (e) => set(field, e.target.value === "" ? 0 : Number(e.target.value)),
+        size: "small"
+      },
+      field.number
+    );
+  }) });
+};
+var RpcChannelRequest = ({ value, onChange, urlLocked }) => {
+  const [loading, setLoading] = useState2(false);
+  const [loadError, setLoadError] = useState2(null);
+  const fileInput = useRef(null);
+  const services = useMemo(
+    () => value.registry === null ? [] : listServices(value.registry),
+    [value.registry]
+  );
+  const service = services.find((s) => s.typeName === value.serviceName);
+  const method = service?.method[value.methodName];
+  const parsedRequest = useMemo(
+    () => method === void 0 ? null : parseRequest(method.input, value.json),
+    [method, value.json]
+  );
+  const selectMethod = (next, patch = {}) => onChange({
+    ...value,
+    ...patch,
+    methodName: next?.localName ?? "",
+    json: next === void 0 ? "{}" : stringify(createRequestTemplate(next.input))
+  });
+  const selectService = (next) => selectMethod(next?.methods.find(isMethodSupported), { serviceName: next?.typeName ?? "" });
+  const load = async (source, loader) => {
+    setLoading(true);
+    setLoadError(null);
+    try {
+      await loader();
+    } catch (error) {
+      setLoadError(
+        `Could not load definitions from ${source}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } finally {
+      setLoading(false);
+    }
+  };
+  const applyRegistry = (registry, source) => {
+    const firstService = listServices(registry)[0];
+    const firstMethod = firstService?.methods.find(isMethodSupported);
+    onChange({
+      ...value,
+      registry,
+      source,
+      serviceName: firstService?.typeName ?? "",
+      methodName: firstMethod?.localName ?? "",
+      json: firstMethod === void 0 ? "{}" : stringify(createRequestTemplate(firstMethod.input))
+    });
+  };
+  const loadUrl = () => load(value.url, async () => {
+    applyRegistry(await fetchDescriptorSet(value.url), value.url);
+  });
+  const loadFile = (file) => load(file.name, async () => {
+    applyRegistry(await readDescriptorSet(file), file.name);
+  });
+  return /* @__PURE__ */ jsxs2(Stack2, { spacing: 2.5, sx: { pt: 1 }, children: [
+    /* @__PURE__ */ jsxs2(Stack2, { spacing: 1.5, children: [
+      /* @__PURE__ */ jsx2(Typography2, { variant: "subtitle2", children: "Service definitions" }),
+      /* @__PURE__ */ jsxs2(Stack2, { direction: "row", spacing: 1, sx: { alignItems: "flex-start" }, children: [
+        /* @__PURE__ */ jsx2(
+          TextField2,
+          {
+            label: "Descriptor set URL",
+            value: value.url,
+            onChange: (e) => onChange({ ...value, url: e.target.value }),
+            disabled: urlLocked,
+            size: "small",
+            fullWidth: true,
+            helperText: urlLocked ? "Fixed by this deployment." : "An endpoint serving a FileDescriptorSet, binary or protobuf-JSON."
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          Button2,
+          {
+            variant: "outlined",
+            onClick: () => void loadUrl(),
+            disabled: loading || value.url.trim() === "",
+            sx: { mt: 0.25 },
+            children: "Load"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx2(
+          Button2,
+          {
+            size: "small",
+            startIcon: /* @__PURE__ */ jsx2(UploadFileIcon, {}),
+            onClick: () => fileInput.current?.click(),
+            disabled: loading,
+            children: "Load from file"
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            ref: fileInput,
+            type: "file",
+            hidden: true,
+            accept: ".binpb,.bin,.pb,.json",
+            onChange: (e) => {
+              const file = e.target.files?.[0];
+              e.target.value = "";
+              if (file !== void 0) void loadFile(file);
+            }
+          }
+        )
+      ] }),
+      loadError !== null && /* @__PURE__ */ jsx2(Alert2, { severity: "error", children: loadError }),
+      value.registry !== null && loadError === null && /* @__PURE__ */ jsxs2(Typography2, { variant: "caption", color: "text.secondary", children: [
+        services.length,
+        " service",
+        services.length === 1 ? "" : "s",
+        " from ",
+        value.source
+      ] })
+    ] }),
+    value.registry !== null && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2(
+        TextField2,
+        {
+          select: true,
+          label: "Service",
+          value: service?.typeName ?? "",
+          onChange: (e) => selectService(services.find((s) => s.typeName === e.target.value)),
+          size: "small",
+          fullWidth: true,
+          disabled: services.length === 0,
+          helperText: services.length === 0 ? "The descriptor set declares no services." : " ",
+          children: services.map((option) => /* @__PURE__ */ jsx2(MenuItem, { value: option.typeName, children: option.typeName }, option.typeName))
+        }
+      ),
+      service !== void 0 && /* @__PURE__ */ jsx2(
+        TextField2,
+        {
+          select: true,
+          label: "Method",
+          value: method?.localName ?? "",
+          onChange: (e) => selectMethod(service.methods.find((m) => m.localName === e.target.value)),
+          size: "small",
+          fullWidth: true,
+          helperText: method === void 0 ? " " : methodModel(method).description,
+          children: service.methods.map((option) => /* @__PURE__ */ jsx2(
+            MenuItem,
+            {
+              value: option.localName,
+              disabled: !isMethodSupported(option),
+              children: /* @__PURE__ */ jsxs2(Stack2, { direction: "row", spacing: 1, sx: { alignItems: "center" }, children: [
+                /* @__PURE__ */ jsx2("span", { children: option.name }),
+                /* @__PURE__ */ jsx2(Chip2, { size: "small", variant: "outlined", label: methodModel(option).label })
+              ] })
+            },
+            option.name
+          ))
+        }
+      ),
+      method !== void 0 && /* @__PURE__ */ jsxs2(Stack2, { spacing: 1.5, children: [
+        /* @__PURE__ */ jsxs2(Typography2, { variant: "subtitle2", children: [
+          "Request \xB7 ",
+          method.input.typeName
+        ] }),
+        /* @__PURE__ */ jsx2(
+          RequestFields,
+          {
+            message: method.input,
+            json: value.json,
+            onChange: (json) => onChange({ ...value, json })
+          }
+        ),
+        /* @__PURE__ */ jsxs2(
+          Accordion,
+          {
+            disableGutters: true,
+            variant: "outlined",
+            defaultExpanded: true,
+            sx: { "&::before": { display: "none" } },
+            children: [
+              /* @__PURE__ */ jsx2(AccordionSummary, { expandIcon: /* @__PURE__ */ jsx2(ExpandMoreIcon, {}), children: /* @__PURE__ */ jsx2(Typography2, { sx: { fontWeight: 600 }, children: "Request JSON" }) }),
+              /* @__PURE__ */ jsx2(AccordionDetails, { children: /* @__PURE__ */ jsx2(
+                TextField2,
+                {
+                  value: value.json,
+                  onChange: (e) => onChange({ ...value, json: e.target.value }),
+                  multiline: true,
+                  minRows: 6,
+                  fullWidth: true,
+                  size: "small",
+                  slotProps: { input: { sx: { fontFamily: "monospace", fontSize: 13 } } },
+                  helperText: "Canonical protobuf-JSON \u2014 exactly what is sent on the channel."
+                }
+              ) })
+            ]
+          }
+        ),
+        parsedRequest !== null && "error" in parsedRequest && /* @__PURE__ */ jsx2(Alert2, { severity: "error", children: parsedRequest.error })
+      ] })
+    ] })
+  ] });
+};
+var canOpenRpcChannel = (value) => {
+  if (value.registry === null) return false;
+  const service = value.registry.getService(value.serviceName);
+  const method = service?.method[value.methodName];
+  if (method === void 0 || !isMethodSupported(method)) return false;
+  return !("error" in parseRequest(method.input, value.json));
+};
+
+// src/plugin.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var rpcChannelPlugin = ({
+  descriptorSetUrl = "",
+  locked = false
+} = {}) => defineChannelPlugin({
+  kind: "rpc",
+  label: "RPC",
+  icon: /* @__PURE__ */ jsx3(SwapHorizIcon2, {}),
+  dialogTitle: "New RPC channel",
+  // A service picker, a method picker and a JSON editor; the other three forms are a
+  // handful of fields.
+  dialogMaxWidth: "md",
+  createRequest: () => ({
+    url: descriptorSetUrl,
+    registry: null,
+    source: null,
+    serviceName: "",
+    methodName: "",
+    json: "{}"
+  }),
+  RequestForm: ({ value, onChange }) => /* @__PURE__ */ jsx3(RpcChannelRequest, { value, onChange, urlLocked: locked }),
+  canOpen: canOpenRpcChannel,
+  buildConfig: (request) => {
+    const service = request.registry?.getService(request.serviceName);
+    const method = service?.method[request.methodName];
+    if (service === void 0 || method === void 0) {
+      return null;
+    }
+    const parsed = parseRequest(method.input, request.json);
+    return "error" in parsed ? null : { service, method, request: parsed.message };
+  },
+  Channel: RpcChannel
+});
+export {
+  rpcChannelPlugin
+};
+//# sourceMappingURL=index.mjs.map