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

package/build/index.js

@@ -0,0 +1,806 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  rpcChannelPlugin: () => rpcChannelPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin.tsx
+var import_dxlink_console_core5 = require("@dxfeed/dxlink-console-core");
+var import_SwapHoriz2 = __toESM(require("@mui/icons-material/SwapHoriz"));
+
+// src/descriptors.ts
+var import_protobuf = require("@bufbuild/protobuf");
+var import_reflect = require("@bufbuild/protobuf/reflect");
+var import_wkt = require("@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 (0, import_protobuf.fromJson)(import_wkt.FileDescriptorSetSchema, JSON.parse(new TextDecoder().decode(bytes)));
+  }
+  return (0, import_protobuf.fromBinary)(import_wkt.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 = (0, import_reflect.protoCamelCase)(field.name);
+      }
+    }
+  }
+  return registry;
+};
+var parseDescriptorSet = (bytes) => deduceMissingJsonNames((0, import_protobuf.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 import_protobuf.ScalarType.BOOL:
+          return false;
+        case import_protobuf.ScalarType.STRING:
+        case import_protobuf.ScalarType.BYTES:
+          return "";
+        case import_protobuf.ScalarType.INT64:
+        case import_protobuf.ScalarType.UINT64:
+        case import_protobuf.ScalarType.FIXED64:
+        case import_protobuf.ScalarType.SFIXED64:
+        case import_protobuf.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: (0, import_protobuf.fromJson)(message, parsed) };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+};
+var formatMessage = (schema, message) => (0, import_protobuf.toJson)(schema, message);
+
+// src/rpc-channel.tsx
+var import_dxlink_console_core2 = require("@dxfeed/dxlink-console-core");
+var import_dxlink_console_core3 = require("@dxfeed/dxlink-console-core");
+var import_dxlink_console_core4 = require("@dxfeed/dxlink-console-core");
+var import_Send = __toESM(require("@mui/icons-material/Send"));
+var import_SwapHoriz = __toESM(require("@mui/icons-material/SwapHoriz"));
+var import_Alert = __toESM(require("@mui/material/Alert"));
+var import_Box = __toESM(require("@mui/material/Box"));
+var import_Button = __toESM(require("@mui/material/Button"));
+var import_Chip = __toESM(require("@mui/material/Chip"));
+var import_Paper = __toESM(require("@mui/material/Paper"));
+var import_Stack = __toESM(require("@mui/material/Stack"));
+var import_TextField = __toESM(require("@mui/material/TextField"));
+var import_Typography = __toESM(require("@mui/material/Typography"));
+var import_react = require("react");
+
+// src/rpc-view-model.ts
+var import_dxlink_api = require("@dxfeed/dxlink-api");
+var import_dxlink_console_core = require("@dxfeed/dxlink-console-core");
+var import_dxlink_protobuf_es = require("@dxfeed/dxlink-protobuf-es");
+var import_rxjs = require("rxjs");
+var import_vanilla = require("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 = (0, import_vanilla.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 = (0, import_dxlink_protobuf_es.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: import_dxlink_api.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 import_rxjs.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: (0, import_dxlink_console_core.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
+var import_jsx_runtime = require("react/jsx-runtime");
+var RpcStatusChip = ({ state, responses }) => {
+  if (state === "failed") {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Chip.default, { size: "small", color: "error", variant: "outlined", label: "failed" });
+  }
+  if (state === "completed") {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Chip.default, { size: "small", variant: "outlined", label: "completed" });
+  }
+  return responses === 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Chip.default, { size: "small", color: "warning", variant: "outlined", label: "waiting" }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Chip.default, { size: "small", color: "success", variant: "outlined", label: "streaming" });
+};
+var MessageEntry = ({ entry: entry2 }) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_Paper.default, { variant: "outlined", sx: { p: 1.5 }, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Typography.default, { variant: "caption", color: "text.secondary", children: entry2.time }),
+  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_Box.default,
+    {
+      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__ */ (0, import_jsx_runtime.jsxs)(import_Stack.default, { spacing: 1, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_Stack.default, { direction: "row", spacing: 1, sx: { alignItems: "baseline" }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Typography.default, { variant: "subtitle2", children: title }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Typography.default, { variant: "caption", color: "text.secondary", children: entries.length })
+  ] }),
+  entries.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Typography.default, { variant: "body2", color: "text.secondary", children: empty }) : entries.map((entry2) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MessageEntry, { entry: entry2 }, entry2.id))
+] });
+var SendRequest = ({
+  vm,
+  config,
+  active
+}) => {
+  const [json, setJson] = (0, import_react.useState)(
+    () => JSON.stringify(createRequestTemplate(config.method.input), null, 2)
+  );
+  const parsed = parseRequest(config.method.input, json);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_Stack.default, { spacing: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Typography.default, { variant: "subtitle2", children: "Send another request" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_TextField.default,
+      {
+        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__ */ (0, import_jsx_runtime.jsx)(import_Alert.default, { severity: "error", children: parsed.error }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Box.default, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_Button.default,
+      {
+        variant: "contained",
+        startIcon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Send.default, {}),
+        disabled: !active || "error" in parsed,
+        onClick: () => {
+          if ("message" in parsed) vm.send(parsed.message);
+        },
+        children: "Send"
+      }
+    ) })
+  ] });
+};
+var RpcChannel = ({ title, config }) => {
+  const connectionVM = (0, import_dxlink_console_core4.useConnectionVM)();
+  const [vm] = (0, import_react.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
+    });
+  });
+  (0, import_react.useEffect)(() => {
+    vm.start();
+    return () => vm.stop();
+  }, [vm]);
+  const callState = (0, import_dxlink_console_core2.useVM)(vm, (s) => s.callState);
+  const responses = (0, import_dxlink_console_core2.useVM)(vm, (s) => s.responses);
+  const requests = (0, import_dxlink_console_core2.useVM)(vm, (s) => s.requests);
+  const errors = (0, import_dxlink_console_core2.useVM)(vm, (s) => s.errors);
+  const model = methodModel(config.method);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_dxlink_console_core3.ChannelWidget,
+    {
+      icon: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_SwapHoriz.default, {}),
+      title,
+      subtitle: `${config.service.typeName} \xB7 ${config.method.name}`,
+      onClose: vm.close,
+      status: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RpcStatusChip, { state: callState, responses: responses.length }),
+      parameters: { service: config.service.typeName, methodName: config.method.name },
+      errors,
+      onClearErrors: vm.clearErrors,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_Stack.default, { spacing: 2, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_Stack.default, { direction: "row", spacing: 0.5, useFlexGap: true, sx: { flexWrap: "wrap" }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Chip.default, { size: "small", variant: "outlined", label: model.label }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Chip.default, { size: "small", variant: "outlined", label: `in: ${config.method.input.typeName}` }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Chip.default, { size: "small", variant: "outlined", label: `out: ${config.method.output.typeName}` })
+        ] }),
+        vm.isBidirectional && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SendRequest, { vm, config, active: callState === "active" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MessageList, { title: "Sent", entries: requests, empty: "Nothing sent yet." }),
+        /* @__PURE__ */ (0, import_jsx_runtime.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
+var import_protobuf2 = require("@bufbuild/protobuf");
+var import_ExpandMore = __toESM(require("@mui/icons-material/ExpandMore"));
+var import_UploadFile = __toESM(require("@mui/icons-material/UploadFile"));
+var import_Accordion = __toESM(require("@mui/material/Accordion"));
+var import_AccordionDetails = __toESM(require("@mui/material/AccordionDetails"));
+var import_AccordionSummary = __toESM(require("@mui/material/AccordionSummary"));
+var import_Alert2 = __toESM(require("@mui/material/Alert"));
+var import_Box2 = __toESM(require("@mui/material/Box"));
+var import_Button2 = __toESM(require("@mui/material/Button"));
+var import_Chip2 = __toESM(require("@mui/material/Chip"));
+var import_FormControlLabel = __toESM(require("@mui/material/FormControlLabel"));
+var import_MenuItem = __toESM(require("@mui/material/MenuItem"));
+var import_Stack2 = __toESM(require("@mui/material/Stack"));
+var import_Switch = __toESM(require("@mui/material/Switch"));
+var import_TextField2 = __toESM(require("@mui/material/TextField"));
+var import_Typography2 = __toESM(require("@mui/material/Typography"));
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("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([
+  import_protobuf2.ScalarType.STRING,
+  import_protobuf2.ScalarType.BYTES,
+  import_protobuf2.ScalarType.INT64,
+  import_protobuf2.ScalarType.UINT64,
+  import_protobuf2.ScalarType.FIXED64,
+  import_protobuf2.ScalarType.SFIXED64,
+  import_protobuf2.ScalarType.SINT64
+]);
+var scalarHelp = (scalar) => {
+  if (scalar === import_protobuf2.ScalarType.BYTES) return "bytes \u2014 base64";
+  if (STRING_SCALARS.has(scalar) && scalar !== import_protobuf2.ScalarType.STRING) return "64-bit \u2014 sent as a string";
+  return void 0;
+};
+var RequestFields = ({
+  message,
+  json,
+  onChange
+}) => {
+  const parsed = (0, import_react2.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__ */ (0, import_jsx_runtime2.jsx)(import_Typography2.default, { 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__ */ (0, import_jsx_runtime2.jsx)(import_Box2.default, { 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__ */ (0, import_jsx_runtime2.jsx)(
+        import_TextField2.default,
+        {
+          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__ */ (0, import_jsx_runtime2.jsx)(import_MenuItem.default, { value: enumValue.name, children: enumValue.name }, enumValue.number))
+        },
+        field.number
+      );
+    }
+    if (field.fieldKind !== "scalar") {
+      return null;
+    }
+    if (field.scalar === import_protobuf2.ScalarType.BOOL) {
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_FormControlLabel.default,
+        {
+          control: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_Switch.default,
+            {
+              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__ */ (0, import_jsx_runtime2.jsx)(
+        import_TextField2.default,
+        {
+          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__ */ (0, import_jsx_runtime2.jsx)(
+      import_TextField2.default,
+      {
+        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] = (0, import_react2.useState)(false);
+  const [loadError, setLoadError] = (0, import_react2.useState)(null);
+  const fileInput = (0, import_react2.useRef)(null);
+  const services = (0, import_react2.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 = (0, import_react2.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__ */ (0, import_jsx_runtime2.jsxs)(import_Stack2.default, { spacing: 2.5, sx: { pt: 1 }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_Stack2.default, { spacing: 1.5, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Typography2.default, { variant: "subtitle2", children: "Service definitions" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_Stack2.default, { direction: "row", spacing: 1, sx: { alignItems: "flex-start" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          import_TextField2.default,
+          {
+            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__ */ (0, import_jsx_runtime2.jsx)(
+          import_Button2.default,
+          {
+            variant: "outlined",
+            onClick: () => void loadUrl(),
+            disabled: loading || value.url.trim() === "",
+            sx: { mt: 0.25 },
+            children: "Load"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_Box2.default, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          import_Button2.default,
+          {
+            size: "small",
+            startIcon: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_UploadFile.default, {}),
+            onClick: () => fileInput.current?.click(),
+            disabled: loading,
+            children: "Load from file"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "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__ */ (0, import_jsx_runtime2.jsx)(import_Alert2.default, { severity: "error", children: loadError }),
+      value.registry !== null && loadError === null && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_Typography2.default, { variant: "caption", color: "text.secondary", children: [
+        services.length,
+        " service",
+        services.length === 1 ? "" : "s",
+        " from ",
+        value.source
+      ] })
+    ] }),
+    value.registry !== null && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_TextField2.default,
+        {
+          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__ */ (0, import_jsx_runtime2.jsx)(import_MenuItem.default, { value: option.typeName, children: option.typeName }, option.typeName))
+        }
+      ),
+      service !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        import_TextField2.default,
+        {
+          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__ */ (0, import_jsx_runtime2.jsx)(
+            import_MenuItem.default,
+            {
+              value: option.localName,
+              disabled: !isMethodSupported(option),
+              children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_Stack2.default, { direction: "row", spacing: 1, sx: { alignItems: "center" }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: option.name }),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Chip2.default, { size: "small", variant: "outlined", label: methodModel(option).label })
+              ] })
+            },
+            option.name
+          ))
+        }
+      ),
+      method !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_Stack2.default, { spacing: 1.5, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_Typography2.default, { variant: "subtitle2", children: [
+          "Request \xB7 ",
+          method.input.typeName
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          RequestFields,
+          {
+            message: method.input,
+            json: value.json,
+            onChange: (json) => onChange({ ...value, json })
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+          import_Accordion.default,
+          {
+            disableGutters: true,
+            variant: "outlined",
+            defaultExpanded: true,
+            sx: { "&::before": { display: "none" } },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_AccordionSummary.default, { expandIcon: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ExpandMore.default, {}), children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_Typography2.default, { sx: { fontWeight: 600 }, children: "Request JSON" }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_AccordionDetails.default, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                import_TextField2.default,
+                {
+                  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__ */ (0, import_jsx_runtime2.jsx)(import_Alert2.default, { 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
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var rpcChannelPlugin = ({
+  descriptorSetUrl = "",
+  locked = false
+} = {}) => (0, import_dxlink_console_core5.defineChannelPlugin)({
+  kind: "rpc",
+  label: "RPC",
+  icon: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_SwapHoriz2.default, {}),
+  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__ */ (0, import_jsx_runtime3.jsx)(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
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rpcChannelPlugin
+});
+//# sourceMappingURL=index.js.map