@react-native/dev-middleware 0.74.0 → 0.74.2

package/dist/inspector-proxy/Device.js.flow

@@ -9,47 +9,16 @@
  * @oncall react_native
  */
 
-import type {
-  DebuggerRequest,
-  GetScriptSourceRequest,
-  MessageFromDevice,
-  MessageToDevice,
-  Page,
-  SetBreakpointByUrlRequest,
-} from "./types";
-
-import DeviceEventReporter from "./DeviceEventReporter";
-import WS from "ws";
 import type { EventReporter } from "../types/EventReporter";
+import type { Page } from "./types";
 
-type DebuggerInfo = {
-  // Debugger web socket connection
-  socket: WS,
-  // If we replaced address (like '10.0.2.2') to localhost we need to store original
-  // address because Chrome uses URL or urlRegex params (instead of scriptId) to set breakpoints.
-  originalSourceURLAddress?: string,
-  prependedFilePrefix: boolean,
-  pageId: string,
-  userAgent: string | null,
-};
+import WS from "ws";
 
 /**
  * Device class represents single device connection to Inspector Proxy. Each device
  * can have multiple inspectable pages.
  */
 declare export default class Device {
-  _id: string;
-  _name: string;
-  _app: string;
-  _deviceSocket: WS;
-  _pages: Array<Page>;
-  _debuggerConnection: ?DebuggerInfo;
-  _lastConnectedReactNativePage: ?Page;
-  _isReloading: boolean;
-  _lastGetPagesMessage: string;
-  _scriptIdToSourcePathMapping: Map<string, string>;
-  _projectRoot: string;
-  _deviceEventReporter: ?DeviceEventReporter;
   constructor(
     id: string,
     name: string,
@@ -60,7 +29,7 @@ declare export default class Device {
   ): void;
   getName(): string;
   getApp(): string;
-  getPagesList(): Array<Page>;
+  getPagesList(): $ReadOnlyArray<Page>;
   handleDebuggerConnection(
     socket: WS,
     pageId: string,
@@ -69,29 +38,4 @@ declare export default class Device {
     }>
   ): void;
   handleDuplicateDeviceConnection(newDevice: Device): void;
-  _handleMessageFromDevice(message: MessageFromDevice): void;
-  _sendMessageToDevice(message: MessageToDevice): void;
-  _setPagesPolling(): void;
-  _newReactNativePage(page: Page): void;
-  _processMessageFromDevice(
-    payload: { method: string, params: { sourceMapURL: string, url: string } },
-    debuggerInfo: DebuggerInfo
-  ): void;
-  _interceptMessageFromDebugger(
-    req: DebuggerRequest,
-    debuggerInfo: DebuggerInfo,
-    socket: WS
-  ): boolean;
-  _processDebuggerSetBreakpointByUrl(
-    req: SetBreakpointByUrlRequest,
-    debuggerInfo: DebuggerInfo
-  ): void;
-  _processDebuggerGetScriptSource(
-    req: GetScriptSourceRequest,
-    socket: WS
-  ): void;
-  _mapToDevicePageId(pageId: string): string;
-  _tryParseHTTPURL(url: string): ?URL;
-  _fetchText(url: URL): Promise<string>;
-  _sendErrorToDebugger(message: string): void;
 }

package/dist/inspector-proxy/DeviceEventReporter.d.ts

@@ -9,13 +9,7 @@
  */
 
 import type { EventReporter } from "../types/EventReporter";
-import TTLCache from "@isaacs/ttlcache";
-type PendingCommand = {
-  method: string;
-  requestOrigin: "proxy" | "debugger";
-  requestTime: number;
-  metadata: RequestMetadata;
-};
+import type { CDPResponse } from "./cdp-types/messages";
 type DeviceMetadata = Readonly<{
   appId: string;
   deviceId: string;
@@ -26,9 +20,6 @@ type RequestMetadata = Readonly<{
   frontendUserAgent: string | null;
 }>;
 declare class DeviceEventReporter {
-  _eventReporter: EventReporter;
-  _pendingCommands: TTLCache<number, PendingCommand>;
-  _metadata: DeviceMetadata;
   constructor(eventReporter: EventReporter, metadata: DeviceMetadata);
   logRequest(
     req: Readonly<{ id: number; method: string }>,
@@ -36,7 +27,7 @@ declare class DeviceEventReporter {
     metadata: RequestMetadata
   ): void;
   logResponse(
-    res: Readonly<{ id: number; error?: { message: string; data?: unknown } }>,
+    res: CDPResponse<>,
     origin: "device" | "proxy",
     metadata: Readonly<{
       pageId: string | null;
@@ -48,7 +39,6 @@ declare class DeviceEventReporter {
     metadata: Readonly<{ pageId: string; frontendUserAgent: string | null }>
   ): void;
   logDisconnection(disconnectedEntity: "device" | "debugger"): void;
-  _logExpiredCommand(pendingCommand: PendingCommand): void;
 }
 declare const $$EXPORT_DEFAULT_DECLARATION$$: typeof DeviceEventReporter;
 export default $$EXPORT_DEFAULT_DECLARATION$$;

package/dist/inspector-proxy/DeviceEventReporter.js

@@ -19,22 +19,24 @@ function _interopRequireDefault(obj) {
  */
 
 class DeviceEventReporter {
-  _pendingCommands = new _ttlcache.default({
+  #eventReporter;
+  #pendingCommands = new _ttlcache.default({
     ttl: 10000,
     dispose: (command, id, reason) => {
       if (reason === "delete" || reason === "set") {
         // TODO: Report clobbering ('set') using a dedicated error code
         return;
       }
-      this._logExpiredCommand(command);
+      this.#logExpiredCommand(command);
     },
   });
+  #metadata;
   constructor(eventReporter, metadata) {
-    this._eventReporter = eventReporter;
-    this._metadata = metadata;
+    this.#eventReporter = eventReporter;
+    this.#metadata = metadata;
   }
   logRequest(req, origin, metadata) {
-    this._pendingCommands.set(req.id, {
+    this.#pendingCommands.set(req.id, {
       method: req.method,
       requestOrigin: origin,
       requestTime: Date.now(),
@@ -42,9 +44,9 @@ class DeviceEventReporter {
     });
   }
   logResponse(res, origin, metadata) {
-    const pendingCommand = this._pendingCommands.get(res.id);
+    const pendingCommand = this.#pendingCommands.get(res.id);
     if (!pendingCommand) {
-      this._eventReporter.logEvent({
+      this.#eventReporter.logEvent({
         type: "debugger_command",
         protocol: "CDP",
         requestOrigin: null,
@@ -53,22 +55,22 @@ class DeviceEventReporter {
         errorCode: "UNMATCHED_REQUEST_ID",
         responseOrigin: "proxy",
         timeSinceStart: null,
-        appId: this._metadata.appId,
-        deviceId: this._metadata.deviceId,
-        deviceName: this._metadata.deviceName,
+        appId: this.#metadata.appId,
+        deviceId: this.#metadata.deviceId,
+        deviceName: this.#metadata.deviceName,
         pageId: metadata.pageId,
         frontendUserAgent: metadata.frontendUserAgent,
       });
       return;
     }
     const timeSinceStart = Date.now() - pendingCommand.requestTime;
-    this._pendingCommands.delete(res.id);
+    this.#pendingCommands.delete(res.id);
     if (res.error) {
       let { message } = res.error;
       if ("data" in res.error) {
         message += ` (${String(res.error.data)})`;
       }
-      this._eventReporter.logEvent({
+      this.#eventReporter.logEvent({
         type: "debugger_command",
         requestOrigin: pendingCommand.requestOrigin,
         method: pendingCommand.method,
@@ -78,15 +80,15 @@ class DeviceEventReporter {
         errorDetails: message,
         responseOrigin: origin,
         timeSinceStart,
-        appId: this._metadata.appId,
-        deviceId: this._metadata.deviceId,
-        deviceName: this._metadata.deviceName,
+        appId: this.#metadata.appId,
+        deviceId: this.#metadata.deviceId,
+        deviceName: this.#metadata.deviceName,
         pageId: pendingCommand.metadata.pageId,
         frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
       });
       return;
     }
-    this._eventReporter.logEvent({
+    this.#eventReporter.logEvent({
       type: "debugger_command",
       protocol: "CDP",
       requestOrigin: pendingCommand.requestOrigin,
@@ -94,26 +96,26 @@ class DeviceEventReporter {
       status: "success",
       responseOrigin: origin,
       timeSinceStart,
-      appId: this._metadata.appId,
-      deviceId: this._metadata.deviceId,
-      deviceName: this._metadata.deviceName,
+      appId: this.#metadata.appId,
+      deviceId: this.#metadata.deviceId,
+      deviceName: this.#metadata.deviceName,
       pageId: pendingCommand.metadata.pageId,
       frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
     });
   }
   logConnection(connectedEntity, metadata) {
-    this._eventReporter.logEvent({
+    this.#eventReporter.logEvent({
       type: "connect_debugger_frontend",
       status: "success",
-      appId: this._metadata.appId,
-      deviceName: this._metadata.deviceName,
-      deviceId: this._metadata.deviceId,
+      appId: this.#metadata.appId,
+      deviceName: this.#metadata.deviceName,
+      deviceId: this.#metadata.deviceId,
       pageId: metadata.pageId,
       frontendUserAgent: metadata.frontendUserAgent,
     });
   }
   logDisconnection(disconnectedEntity) {
-    const eventReporter = this._eventReporter;
+    const eventReporter = this.#eventReporter;
     if (!eventReporter) {
       return;
     }
@@ -121,8 +123,8 @@ class DeviceEventReporter {
       disconnectedEntity === "device"
         ? "DEVICE_DISCONNECTED"
         : "DEBUGGER_DISCONNECTED";
-    for (const pendingCommand of this._pendingCommands.values()) {
-      this._eventReporter.logEvent({
+    for (const pendingCommand of this.#pendingCommands.values()) {
+      this.#eventReporter.logEvent({
         type: "debugger_command",
         protocol: "CDP",
         requestOrigin: pendingCommand.requestOrigin,
@@ -131,17 +133,17 @@ class DeviceEventReporter {
         errorCode,
         responseOrigin: "proxy",
         timeSinceStart: Date.now() - pendingCommand.requestTime,
-        appId: this._metadata.appId,
-        deviceId: this._metadata.deviceId,
-        deviceName: this._metadata.deviceName,
+        appId: this.#metadata.appId,
+        deviceId: this.#metadata.deviceId,
+        deviceName: this.#metadata.deviceName,
         pageId: pendingCommand.metadata.pageId,
         frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
       });
     }
-    this._pendingCommands.clear();
+    this.#pendingCommands.clear();
   }
-  _logExpiredCommand(pendingCommand) {
-    this._eventReporter.logEvent({
+  #logExpiredCommand(pendingCommand) {
+    this.#eventReporter.logEvent({
       type: "debugger_command",
       protocol: "CDP",
       requestOrigin: pendingCommand.requestOrigin,
@@ -150,9 +152,9 @@ class DeviceEventReporter {
       errorCode: "TIMED_OUT",
       responseOrigin: "proxy",
       timeSinceStart: Date.now() - pendingCommand.requestTime,
-      appId: this._metadata.appId,
-      deviceId: this._metadata.deviceId,
-      deviceName: this._metadata.deviceName,
+      appId: this.#metadata.appId,
+      deviceId: this.#metadata.deviceId,
+      deviceName: this.#metadata.deviceName,
       pageId: pendingCommand.metadata.pageId,
       frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
     });

package/dist/inspector-proxy/DeviceEventReporter.js.flow

@@ -9,14 +9,7 @@
  */
 
 import type { EventReporter } from "../types/EventReporter";
-import TTLCache from "@isaacs/ttlcache";
-
-type PendingCommand = {
-  method: string,
-  requestOrigin: "proxy" | "debugger",
-  requestTime: number,
-  metadata: RequestMetadata,
-};
+import type { CDPResponse } from "./cdp-types/messages";
 
 type DeviceMetadata = $ReadOnly<{
   appId: string,
@@ -30,9 +23,6 @@ type RequestMetadata = $ReadOnly<{
 }>;
 
 declare class DeviceEventReporter {
-  _eventReporter: EventReporter;
-  _pendingCommands: TTLCache<number, PendingCommand>;
-  _metadata: DeviceMetadata;
   constructor(eventReporter: EventReporter, metadata: DeviceMetadata): void;
   logRequest(
     req: $ReadOnly<{ id: number, method: string, ... }>,
@@ -40,11 +30,7 @@ declare class DeviceEventReporter {
     metadata: RequestMetadata
   ): void;
   logResponse(
-    res: $ReadOnly<{
-      id: number,
-      error?: { message: string, data?: mixed },
-      ...
-    }>,
+    res: CDPResponse<>,
     origin: "device" | "proxy",
     metadata: $ReadOnly<{
       pageId: string | null,
@@ -59,7 +45,6 @@ declare class DeviceEventReporter {
     }>
   ): void;
   logDisconnection(disconnectedEntity: "device" | "debugger"): void;
-  _logExpiredCommand(pendingCommand: PendingCommand): void;
 }
 
 declare export default typeof DeviceEventReporter;

package/dist/inspector-proxy/InspectorProxy.d.ts

@@ -9,17 +9,11 @@
  * @oncall react_native
  */
 
-import type {
-  JsonPagesListResponse,
-  JsonVersionResponse,
-  Page,
-  PageDescription,
-} from "./types";
 import type { EventReporter } from "../types/EventReporter";
 import type { Experiments } from "../types/Experiments";
+import type { PageDescription } from "./types";
 import type { IncomingMessage, ServerResponse } from "http";
 import WS from "ws";
-import Device from "./Device";
 export interface InspectorProxyQueries {
   getPageDescriptions(): Array<PageDescription>;
 }
@@ -27,12 +21,6 @@ export interface InspectorProxyQueries {
  * Main Inspector Proxy class that connects JavaScript VM inside Android/iOS apps and JS debugger.
  */
 declare class InspectorProxy implements InspectorProxyQueries {
-  _projectRoot: string;
-  _serverBaseUrl: string;
-  _devices: Map<string, Device>;
-  _deviceCounter: number;
-  _eventReporter: null | undefined | EventReporter;
-  _experiments: Experiments;
   constructor(
     projectRoot: string,
     serverBaseUrl: string,
@@ -46,16 +34,5 @@ declare class InspectorProxy implements InspectorProxyQueries {
     next: ($$PARAM_0$$: null | undefined | Error) => unknown
   ): void;
   createWebSocketListeners(): { [path: string]: WS.Server };
-  _buildPageDescription(
-    deviceId: string,
-    device: Device,
-    page: Page
-  ): PageDescription;
-  _sendJsonResponse(
-    response: ServerResponse,
-    object: JsonPagesListResponse | JsonVersionResponse
-  ): void;
-  _createDeviceConnectionWSServer(): ws$WebSocketServer;
-  _createDebuggerConnectionWSServer(): ws$WebSocketServer;
 }
 export default InspectorProxy;

package/dist/inspector-proxy/InspectorProxy.js

@@ -4,9 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true,
 });
 exports.default = void 0;
+var _Device = _interopRequireDefault(require("./Device"));
+var _nullthrows = _interopRequireDefault(require("nullthrows"));
 var _url = _interopRequireDefault(require("url"));
 var _ws = _interopRequireDefault(require("ws"));
-var _Device = _interopRequireDefault(require("./Device"));
 function _interopRequireDefault(obj) {
   return obj && obj.__esModule ? obj : { default: obj };
 }
@@ -33,28 +34,33 @@ const INTERNAL_ERROR_CODE = 1011;
  */
 class InspectorProxy {
   // Root of the project used for relative to absolute source path conversion.
+  #projectRoot;
 
   /** The base URL to the dev server from the developer machine. */
+  #serverBaseUrl;
 
   // Maps device ID to Device instance.
+  #devices;
 
   // Internal counter for device IDs -- just gets incremented for each new device.
-  _deviceCounter = 0;
+  #deviceCounter = 0;
+  #eventReporter;
+  #experiments;
   constructor(projectRoot, serverBaseUrl, eventReporter, experiments) {
-    this._projectRoot = projectRoot;
-    this._serverBaseUrl = serverBaseUrl;
-    this._devices = new Map();
-    this._eventReporter = eventReporter;
-    this._experiments = experiments;
+    this.#projectRoot = projectRoot;
+    this.#serverBaseUrl = serverBaseUrl;
+    this.#devices = new Map();
+    this.#eventReporter = eventReporter;
+    this.#experiments = experiments;
   }
   getPageDescriptions() {
     // Build list of pages from all devices.
     let result = [];
-    Array.from(this._devices.entries()).forEach(([deviceId, device]) => {
+    Array.from(this.#devices.entries()).forEach(([deviceId, device]) => {
       result = result.concat(
         device
           .getPagesList()
-          .map((page) => this._buildPageDescription(deviceId, device, page))
+          .map((page) => this.#buildPageDescription(deviceId, device, page))
       );
     });
     return result;
@@ -65,13 +71,14 @@ class InspectorProxy {
   // 2. /json and /json/list returns list of page descriptions (list of inspectable apps).
   // This list is combined from all the connected devices.
   processRequest(request, response, next) {
+    const pathname = _url.default.parse(request.url).pathname;
     if (
-      request.url === PAGES_LIST_JSON_URL ||
-      request.url === PAGES_LIST_JSON_URL_2
+      pathname === PAGES_LIST_JSON_URL ||
+      pathname === PAGES_LIST_JSON_URL_2
     ) {
-      this._sendJsonResponse(response, this.getPageDescriptions());
-    } else if (request.url === PAGES_LIST_JSON_VERSION_URL) {
-      this._sendJsonResponse(response, {
+      this.#sendJsonResponse(response, this.getPageDescriptions());
+    } else if (pathname === PAGES_LIST_JSON_VERSION_URL) {
+      this.#sendJsonResponse(response, {
         Browser: "Mobile JavaScript",
         "Protocol-Version": "1.1",
       });
@@ -81,15 +88,15 @@ class InspectorProxy {
   }
   createWebSocketListeners() {
     return {
-      [WS_DEVICE_URL]: this._createDeviceConnectionWSServer(),
-      [WS_DEBUGGER_URL]: this._createDebuggerConnectionWSServer(),
+      [WS_DEVICE_URL]: this.#createDeviceConnectionWSServer(),
+      [WS_DEBUGGER_URL]: this.#createDebuggerConnectionWSServer(),
     };
   }
 
   // Converts page information received from device into PageDescription object
   // that is sent to debugger.
-  _buildPageDescription(deviceId, device, page) {
-    const { host, protocol } = new URL(this._serverBaseUrl);
+  #buildPageDescription(deviceId, device, page) {
+    const { host, protocol } = new URL(this.#serverBaseUrl);
     const webSocketScheme = protocol === "https:" ? "wss" : "ws";
     const webSocketUrlWithoutProtocol = `${host}${WS_DEBUGGER_URL}?device=${deviceId}&page=${page.id}`;
     // For now, `/json/list` returns the legacy built-in `devtools://` URL, to
@@ -108,17 +115,21 @@ class InspectorProxy {
       webSocketDebuggerUrl: `${webSocketScheme}://${webSocketUrlWithoutProtocol}`,
       vm: page.vm,
       deviceName: device.getName(),
+      reactNative: {
+        logicalDeviceId: deviceId,
+        capabilities: (0, _nullthrows.default)(page.capabilities),
+      },
     };
   }
 
   // Sends object as response to HTTP request.
   // Just serializes object using JSON and sets required headers.
-  _sendJsonResponse(response, object) {
+  #sendJsonResponse(response, object) {
     const data = JSON.stringify(object, null, 2);
     response.writeHead(200, {
       "Content-Type": "application/json; charset=UTF-8",
       "Cache-Control": "no-cache",
-      "Content-Length": data.length.toString(),
+      "Content-Length": Buffer.byteLength(data).toString(),
       Connection: "close",
     });
     response.end(data);
@@ -129,7 +140,7 @@ class InspectorProxy {
   // HTTP GET params.
   // For each new websocket connection we parse device and app names and create
   // new instance of Device class.
-  _createDeviceConnectionWSServer() {
+  #createDeviceConnectionWSServer() {
     const wss = new _ws.default.Server({
       noServer: true,
       perMessageDeflate: true,
@@ -140,29 +151,29 @@ class InspectorProxy {
     // $FlowFixMe[value-as-type]
     wss.on("connection", async (socket, req) => {
       try {
-        const fallbackDeviceId = String(this._deviceCounter++);
+        const fallbackDeviceId = String(this.#deviceCounter++);
         const query = _url.default.parse(req.url || "", true).query || {};
         const deviceId = query.device || fallbackDeviceId;
         const deviceName = query.name || "Unknown";
         const appName = query.app || "Unknown";
-        const oldDevice = this._devices.get(deviceId);
+        const oldDevice = this.#devices.get(deviceId);
         const newDevice = new _Device.default(
           deviceId,
           deviceName,
           appName,
           socket,
-          this._projectRoot,
-          this._eventReporter
+          this.#projectRoot,
+          this.#eventReporter
         );
         if (oldDevice) {
           oldDevice.handleDuplicateDeviceConnection(newDevice);
         }
-        this._devices.set(deviceId, newDevice);
+        this.#devices.set(deviceId, newDevice);
         debug(
           `Got new connection: name=${deviceName}, app=${appName}, device=${deviceId}`
         );
         socket.on("close", () => {
-          this._devices.delete(deviceId);
+          this.#devices.delete(deviceId);
           debug(`Device ${deviceName} disconnected.`);
         });
       } catch (e) {
@@ -178,7 +189,7 @@ class InspectorProxy {
   // in /json response.
   // When debugger connects we try to parse device and page IDs from the query and pass
   // websocket object to corresponding Device instance.
-  _createDebuggerConnectionWSServer() {
+  #createDebuggerConnectionWSServer() {
     const wss = new _ws.default.Server({
       noServer: true,
       perMessageDeflate: false,
@@ -195,7 +206,7 @@ class InspectorProxy {
         if (deviceId == null || pageId == null) {
           throw new Error("Incorrect URL - must provide device and page IDs");
         }
-        const device = this._devices.get(deviceId);
+        const device = this.#devices.get(deviceId);
         if (device == null) {
           throw new Error("Unknown device with ID " + deviceId);
         }
@@ -205,7 +216,7 @@ class InspectorProxy {
       } catch (e) {
         console.error(e);
         socket.close(INTERNAL_ERROR_CODE, e?.toString() ?? "Unknown error");
-        this._eventReporter?.logEvent({
+        this.#eventReporter?.logEvent({
           type: "connect_debugger_frontend",
           status: "error",
           error: e,

package/dist/inspector-proxy/InspectorProxy.js.flow

@@ -9,18 +9,12 @@
  * @oncall react_native
  */
 
-import type {
-  JsonPagesListResponse,
-  JsonVersionResponse,
-  Page,
-  PageDescription,
-} from "./types";
 import type { EventReporter } from "../types/EventReporter";
 import type { Experiments } from "../types/Experiments";
+import type { PageDescription } from "./types";
 import type { IncomingMessage, ServerResponse } from "http";
 
 import WS from "ws";
-import Device from "./Device";
 
 export interface InspectorProxyQueries {
   getPageDescriptions(): Array<PageDescription>;
@@ -30,12 +24,6 @@ export interface InspectorProxyQueries {
  * Main Inspector Proxy class that connects JavaScript VM inside Android/iOS apps and JS debugger.
  */
 declare export default class InspectorProxy implements InspectorProxyQueries {
-  _projectRoot: string;
-  _serverBaseUrl: string;
-  _devices: Map<string, Device>;
-  _deviceCounter: number;
-  _eventReporter: ?EventReporter;
-  _experiments: Experiments;
   constructor(
     projectRoot: string,
     serverBaseUrl: string,
@@ -51,15 +39,4 @@ declare export default class InspectorProxy implements InspectorProxyQueries {
   createWebSocketListeners(): {
     [path: string]: WS.Server,
   };
-  _buildPageDescription(
-    deviceId: string,
-    device: Device,
-    page: Page
-  ): PageDescription;
-  _sendJsonResponse(
-    response: ServerResponse,
-    object: JsonPagesListResponse | JsonVersionResponse
-  ): void;
-  _createDeviceConnectionWSServer(): ws$WebSocketServer;
-  _createDebuggerConnectionWSServer(): ws$WebSocketServer;
 }

package/dist/inspector-proxy/cdp-types/messages.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type { Commands, Events } from "./protocol";
+export type CDPEvent<TEvent extends keyof Events = "unknown"> = Readonly<{
+  method: TEvent;
+  params: Events[TEvent];
+}>;
+export type CDPRequest<TCommand extends keyof Commands = "unknown"> = Readonly<{
+  method: TCommand;
+  params: Commands[TCommand]["paramsType"];
+  id: number;
+}>;
+export type CDPResponse<TCommand extends keyof Commands = "unknown"> =
+  | Readonly<{ result: Commands[TCommand]["resultType"]; id: number }>
+  | Readonly<{ error: CDPRequestError; id: number }>;
+export type CDPRequestError = Readonly<{
+  code: number;
+  message: string;
+  data?: unknown;
+}>;
+export type CDPClientMessage =
+  | CDPRequest<"Debugger.getScriptSource">
+  | CDPRequest<"Debugger.scriptParsed">
+  | CDPRequest<"Debugger.setBreakpointByUrl">
+  | CDPRequest<>;
+export type CDPServerMessage =
+  | CDPEvent<"Debugger.scriptParsed">
+  | CDPEvent<>
+  | CDPResponse<"Debugger.getScriptSource">
+  | CDPResponse<>;

package/dist/inspector-proxy/cdp-types/messages.js

@@ -0,0 +1 @@
+"use strict";