expo 54.0.0-canary-20250729-d8899ae → 54.0.0-preview.0

package/build/devtools/logger.d.ts

@@ -1,6 +0,0 @@
-export declare function log(...params: Parameters<typeof console.log>): void;
-export declare function debug(...params: Parameters<typeof console.debug>): void;
-export declare function info(...params: Parameters<typeof console.info>): void;
-export declare function warn(...params: Parameters<typeof console.info>): void;
-export declare function setEnableLogging(enabled: boolean): void;
-//# sourceMappingURL=logger.d.ts.map

package/build/devtools/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/devtools/logger.ts"],"names":[],"mappings":"AAEA,wBAAgB,GAAG,CAAC,GAAG,MAAM,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,GAAG,CAAC,QAI5D;AAED,wBAAgB,KAAK,CAAC,GAAG,MAAM,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,KAAK,CAAC,QAIhE;AAED,wBAAgB,IAAI,CAAC,GAAG,MAAM,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,IAAI,CAAC,QAI9D;AAED,wBAAgB,IAAI,CAAC,GAAG,MAAM,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,IAAI,CAAC,QAI9D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAEhD"}

package/src/devtools/DevToolsPluginClient.ts

@@ -1,240 +0,0 @@
-import { MessageFramePacker } from './MessageFramePacker';
-import { WebSocketBackingStore } from './WebSocketBackingStore';
-import { WebSocketWithReconnect } from './WebSocketWithReconnect';
-import type {
-  ConnectionInfo,
-  DevToolsPluginClientOptions,
-  HandshakeMessageParams,
-} from './devtools.types';
-import * as logger from './logger';
-import { blobToArrayBufferAsync } from '../utils/blobUtils';
-
-interface MessageFramePackerMessageKey {
-  pluginName: string;
-  method: string;
-}
-
-export interface EventSubscription {
-  remove(): void;
-}
-
-/**
- * This client is for the Expo DevTools Plugins to communicate between the app and the DevTools webpage hosted in a browser.
- * All the code should be both compatible with browsers and React Native.
- */
-export abstract class DevToolsPluginClient {
-  private listeners: Record<string, undefined | Set<(params: any) => void>>;
-
-  private static defaultWSStore: WebSocketBackingStore = new WebSocketBackingStore();
-  private readonly wsStore: WebSocketBackingStore = DevToolsPluginClient.defaultWSStore;
-
-  protected isClosed = false;
-  protected retries = 0;
-  private readonly messageFramePacker: MessageFramePacker<MessageFramePackerMessageKey> =
-    new MessageFramePacker();
-
-  public constructor(
-    public readonly connectionInfo: ConnectionInfo,
-    private readonly options?: DevToolsPluginClientOptions
-  ) {
-    this.wsStore = connectionInfo.wsStore || DevToolsPluginClient.defaultWSStore;
-    this.listeners = Object.create(null);
-  }
-
-  /**
-   * Initialize the connection.
-   * @hidden
-   */
-  public async initAsync(): Promise<void> {
-    if (this.wsStore.ws == null) {
-      this.wsStore.ws = await this.connectAsync();
-    }
-    this.wsStore.refCount += 1;
-    this.wsStore.ws.addEventListener('message', this.handleMessage);
-  }
-
-  /**
-   * Close the connection.
-   */
-  public async closeAsync(): Promise<void> {
-    this.isClosed = true;
-    this.wsStore.ws?.removeEventListener('message', this.handleMessage);
-    this.wsStore.refCount -= 1;
-    if (this.wsStore.refCount < 1) {
-      this.wsStore.ws?.close();
-      this.wsStore.ws = null;
-    }
-    this.listeners = Object.create(null);
-  }
-
-  /**
-   * Send a message to the other end of DevTools.
-   * @param method A method name.
-   * @param params any extra payload.
-   */
-  public sendMessage(method: string, params: any) {
-    if (this.wsStore.ws?.readyState === WebSocket.CLOSED) {
-      logger.warn('Unable to send message in a disconnected state.');
-      return;
-    }
-    const messageKey: MessageFramePackerMessageKey = {
-      pluginName: this.connectionInfo.pluginName,
-      method,
-    };
-    const packedData = this.messageFramePacker.pack({ messageKey, payload: params });
-    if (!(packedData instanceof Promise)) {
-      this.wsStore.ws?.send(packedData);
-      return;
-    }
-    packedData.then((data) => {
-      this.wsStore.ws?.send(data);
-    });
-  }
-
-  /**
-   * Subscribe to a message from the other end of DevTools.
-   * @param method Subscribe to a message with a method name.
-   * @param listener Listener to be called when a message is received.
-   */
-  public addMessageListener(method: string, listener: (params: any) => void): EventSubscription {
-    const listenersForMethod = this.listeners[method] || (this.listeners[method] = new Set());
-    listenersForMethod.add(listener);
-    return {
-      remove: () => {
-        this.listeners[method]?.delete(listener);
-      },
-    };
-  }
-
-  /**
-   * Subscribe to a message from the other end of DevTools just once.
-   * @param method Subscribe to a message with a method name.
-   * @param listener Listener to be called when a message is received.
-   */
-  public addMessageListenerOnce(method: string, listener: (params: any) => void): void {
-    const wrappedListenerOnce = (params: any): void => {
-      listener(params);
-      this.listeners[method]?.delete(wrappedListenerOnce);
-    };
-    this.addMessageListener(method, wrappedListenerOnce);
-  }
-
-  /**
-   * Internal handshake message sender.
-   * @hidden
-   */
-  protected sendHandshakeMessage(params: HandshakeMessageParams) {
-    if (this.wsStore.ws?.readyState === WebSocket.CLOSED) {
-      logger.warn('Unable to send message in a disconnected state.');
-      return;
-    }
-    this.wsStore.ws?.send(JSON.stringify({ ...params, __isHandshakeMessages: true }));
-  }
-
-  /**
-   * Internal handshake message listener.
-   * @hidden
-   */
-  protected addHandskakeMessageListener(
-    listener: (params: HandshakeMessageParams) => void
-  ): EventSubscription {
-    const messageListener = (event: MessageEvent) => {
-      if (typeof event.data !== 'string') {
-        // binary data is not coming from the handshake messages.
-        return;
-      }
-
-      const data = JSON.parse(event.data);
-      if (!data.__isHandshakeMessages) {
-        return;
-      }
-      delete data.__isHandshakeMessages;
-      const params = data as HandshakeMessageParams;
-      if (params.pluginName && params.pluginName !== this.connectionInfo.pluginName) {
-        return;
-      }
-      listener(params);
-    };
-
-    this.wsStore.ws?.addEventListener('message', messageListener);
-    return {
-      remove: () => {
-        this.wsStore.ws?.removeEventListener('message', messageListener);
-      },
-    };
-  }
-
-  /**
-   * Returns whether the client is connected to the server.
-   */
-  public isConnected(): boolean {
-    return this.wsStore.ws?.readyState === WebSocket.OPEN;
-  }
-
-  /**
-   * The method to create the WebSocket connection.
-   */
-  protected connectAsync(): Promise<WebSocket> {
-    return new Promise((resolve, reject) => {
-      const endpoint = 'expo-dev-plugins/broadcast';
-      const ws = new WebSocketWithReconnect(`ws://${this.connectionInfo.devServer}/${endpoint}`, {
-        binaryType: this.options?.websocketBinaryType,
-        onError: (e: unknown) => {
-          if (e instanceof Error) {
-            console.warn(`Error happened from the WebSocket connection: ${e.message}\n${e.stack}`);
-          } else {
-            console.warn(`Error happened from the WebSocket connection: ${JSON.stringify(e)}`);
-          }
-        },
-      });
-      ws.addEventListener('open', () => {
-        resolve(ws);
-      });
-      ws.addEventListener('error', (e) => {
-        reject(e);
-      });
-      ws.addEventListener('close', (e: WebSocketCloseEvent) => {
-        logger.info('WebSocket closed', e.code, e.reason);
-      });
-    });
-  }
-
-  protected handleMessage = async (event: WebSocketMessageEvent) => {
-    let data: ArrayBuffer | string;
-    if (typeof event.data === 'string') {
-      data = event.data;
-    } else if (event.data instanceof ArrayBuffer) {
-      data = event.data;
-    } else if (ArrayBuffer.isView(event.data)) {
-      data = event.data.buffer as ArrayBuffer;
-    } else if (event.data instanceof Blob) {
-      data = await blobToArrayBufferAsync(event.data);
-    } else {
-      logger.warn('Unsupported received data type in handleMessageImpl');
-      return;
-    }
-    const { messageKey, payload, ...rest } = this.messageFramePacker.unpack(data);
-    // @ts-expect-error: `__isHandshakeMessages` is a private field that is not part of the MessageFramePacker type.
-    if (rest?.__isHandshakeMessages === true) {
-      return;
-    }
-    if (messageKey.pluginName && messageKey.pluginName !== this.connectionInfo.pluginName) {
-      return;
-    }
-
-    const listenersForMethod = this.listeners[messageKey.method];
-    if (listenersForMethod) {
-      for (const listener of listenersForMethod) {
-        listener(payload);
-      }
-    }
-  };
-
-  /**
-   * Get the WebSocket backing store. Exposed for testing.
-   * @hidden
-   */
-  public getWebSocketBackingStore(): WebSocketBackingStore {
-    return this.wsStore;
-  }
-}

package/src/devtools/DevToolsPluginClientFactory.ts

@@ -1,73 +0,0 @@
-import type { DevToolsPluginClient } from './DevToolsPluginClient';
-import { DevToolsPluginClientImplApp } from './DevToolsPluginClientImplApp';
-import { DevToolsPluginClientImplBrowser } from './DevToolsPluginClientImplBrowser';
-import type { ConnectionInfo, DevToolsPluginClientOptions } from './devtools.types';
-import { getConnectionInfo } from './getConnectionInfo';
-
-const instanceMap: Record<string, DevToolsPluginClient | Promise<DevToolsPluginClient>> = {};
-
-/**
- * Factory of DevToolsPluginClient based on sender types.
- * @hidden
- */
-export async function createDevToolsPluginClient(
-  connectionInfo: ConnectionInfo,
-  options?: DevToolsPluginClientOptions
-): Promise<DevToolsPluginClient> {
-  let client: DevToolsPluginClient;
-  if (connectionInfo.sender === 'app') {
-    client = new DevToolsPluginClientImplApp(connectionInfo, options);
-  } else {
-    client = new DevToolsPluginClientImplBrowser(connectionInfo, options);
-  }
-  await client.initAsync();
-  return client;
-}
-
-/**
- * Public API to get the DevToolsPluginClient instance.
- */
-export async function getDevToolsPluginClientAsync(
-  pluginName: string,
-  options?: DevToolsPluginClientOptions
-): Promise<DevToolsPluginClient> {
-  const connectionInfo = getConnectionInfo();
-
-  let instance: DevToolsPluginClient | Promise<DevToolsPluginClient> | null =
-    instanceMap[pluginName];
-  if (instance != null) {
-    if (instance instanceof Promise) {
-      return instance;
-    }
-    if (
-      instance.isConnected() === false ||
-      instance.connectionInfo.devServer !== connectionInfo.devServer
-    ) {
-      await instance.closeAsync();
-      delete instanceMap[pluginName];
-      instance = null;
-    }
-  }
-  if (instance == null) {
-    const instancePromise = createDevToolsPluginClient({ ...connectionInfo, pluginName }, options);
-    instanceMap[pluginName] = instancePromise;
-    instance = await instancePromise;
-    instanceMap[pluginName] = instance;
-  }
-  return instance;
-}
-
-/**
- * Internal testing API to cleanup all DevToolsPluginClient instances.
- */
-export function cleanupDevToolsPluginInstances() {
-  for (const pluginName of Object.keys(instanceMap)) {
-    const instance = instanceMap[pluginName];
-    delete instanceMap[pluginName];
-    if (instance instanceof Promise) {
-      instance.then((instance) => instance.closeAsync());
-    } else {
-      instance.closeAsync();
-    }
-  }
-}

package/src/devtools/DevToolsPluginClientImplApp.ts

@@ -1,56 +0,0 @@
-import { DevToolsPluginClient } from './DevToolsPluginClient';
-import * as logger from './logger';
-
-/**
- * The DevToolsPluginClient for the app -> browser communication.
- */
-export class DevToolsPluginClientImplApp extends DevToolsPluginClient {
-  // Map of pluginName -> browserClientId
-  private browserClientMap: Record<string, string> = {};
-
-  /**
-   * Initialize the connection.
-   * @hidden
-   */
-  override async initAsync(): Promise<void> {
-    await super.initAsync();
-    this.addHandshakeHandler();
-  }
-
-  private addHandshakeHandler() {
-    this.addHandskakeMessageListener((params) => {
-      if (params.method === 'handshake') {
-        const { pluginName, protocolVersion } = params;
-
-        // [0] Check protocol version
-        if (protocolVersion !== this.connectionInfo.protocolVersion) {
-          // Use console.warn than logger because we want to show the warning even logging is disabled.
-          console.warn(
-            `Received an incompatible devtools plugin handshake message - pluginName[${pluginName}]`
-          );
-          this.terminateBrowserClient(pluginName, params.browserClientId);
-          return;
-        }
-
-        // [1] Terminate duplicated browser clients for the same plugin
-        const previousBrowserClientId = this.browserClientMap[pluginName];
-        if (previousBrowserClientId != null && previousBrowserClientId !== params.browserClientId) {
-          logger.info(
-            `Terminate the previous browser client connection - previousBrowserClientId[${previousBrowserClientId}]`
-          );
-          this.terminateBrowserClient(pluginName, previousBrowserClientId);
-        }
-        this.browserClientMap[pluginName] = params.browserClientId;
-      }
-    });
-  }
-
-  private terminateBrowserClient(pluginName: string, browserClientId: string) {
-    this.sendHandshakeMessage({
-      protocolVersion: this.connectionInfo.protocolVersion,
-      method: 'terminateBrowserClient',
-      browserClientId,
-      pluginName,
-    });
-  }
-}

package/src/devtools/DevToolsPluginClientImplBrowser.ts

@@ -1,38 +0,0 @@
-import { DevToolsPluginClient } from './DevToolsPluginClient';
-import * as logger from './logger';
-
-/**
- * The DevToolsPluginClient for the browser -> app communication.
- */
-export class DevToolsPluginClientImplBrowser extends DevToolsPluginClient {
-  private browserClientId: string = Date.now().toString();
-
-  /**
-   * Initialize the connection.
-   * @hidden
-   */
-  override async initAsync(): Promise<void> {
-    await super.initAsync();
-    this.startHandshake();
-  }
-
-  private startHandshake() {
-    this.addHandskakeMessageListener((params) => {
-      if (
-        params.method === 'terminateBrowserClient' &&
-        this.browserClientId === params.browserClientId
-      ) {
-        logger.info(
-          'Received terminateBrowserClient messages and terminate the current connection'
-        );
-        this.closeAsync();
-      }
-    });
-    this.sendHandshakeMessage({
-      protocolVersion: this.connectionInfo.protocolVersion,
-      pluginName: this.connectionInfo.pluginName,
-      method: 'handshake',
-      browserClientId: this.browserClientId,
-    });
-  }
-}

package/src/devtools/MessageFramePacker.ts

@@ -1,235 +0,0 @@
-/**
- * A message frame packer that serializes a messageKey and a payload into either a JSON string
- * (fast path) or a binary format (for complex payloads).
- *
- * Fast Path (JSON.stringify/JSON.parse):
- * - For simple payloads (e.g., strings, numbers, null, undefined, or plain objects), the packer
- *   uses `JSON.stringify` for serialization and `JSON.parse` for deserialization, ensuring
- *   optimal performance.
- *
- * Binary Format:
- * - For more complex payloads (e.g., Uint8Array, ArrayBuffer, Blob), the packer uses a binary
- *   format with the following structure:
- *
- *   +------------------+-------------------+----------------------------+--------------------------+
- *   | 4 bytes (Uint32) | Variable length   | 1 byte (Uint8)             | Variable length          |
- *   | MessageKeyLength | MessageKey (JSON) | PayloadTypeIndicator (enum)| Payload (binary data)    |
- *   +------------------+-------------------+----------------------------+--------------------------+
- *
- *   1. MessageKeyLength (4 bytes):
- *      - A 4-byte unsigned integer indicating the length of the MessageKey JSON string.
- *
- *   2. MessageKey (Variable length):
- *      - The JSON string representing the message key, encoded as UTF-8.
- *
- *   3. PayloadTypeIndicator (1 byte):
- *      - A single byte enum value representing the type of the payload (e.g., Uint8Array, String,
- *        Object, ArrayBuffer, Blob).
- *
- *   4. Payload (Variable length):
- *      - The actual payload data, which can vary in type and length depending on the PayloadType.
- */
-
-import { blobToArrayBufferAsync } from '../utils/blobUtils';
-
-type MessageKeyTypeBase = string | object;
-type PayloadType = Uint8Array | string | number | null | undefined | object | ArrayBuffer | Blob;
-
-enum PayloadTypeIndicator {
-  Uint8Array = 1,
-  String = 2,
-  Number = 3,
-  Null = 4,
-  Undefined = 5,
-  Object = 6,
-  ArrayBuffer = 7,
-  Blob = 8,
-}
-
-interface MessageFrame<T extends MessageKeyTypeBase> {
-  messageKey: T;
-  payload?: PayloadType;
-}
-
-export class MessageFramePacker<T extends MessageKeyTypeBase> {
-  private textEncoder = new TextEncoder();
-  private textDecoder = new TextDecoder();
-
-  public pack({ messageKey, payload }: MessageFrame<T>): string | Uint8Array | Promise<Uint8Array> {
-    // Fast path to pack as string given `JSON.stringify` is fast.
-    if (this.isFastPathPayload(payload)) {
-      return JSON.stringify({ messageKey, payload });
-    }
-
-    // Slowest path for Blob returns a promise.
-    if (payload instanceof Blob) {
-      return new Promise(async (resolve, reject) => {
-        try {
-          const arrayBuffer = await blobToArrayBufferAsync(payload);
-          resolve(
-            this.packImpl(
-              { messageKey, payload: new Uint8Array(arrayBuffer) },
-              PayloadTypeIndicator.Blob
-            )
-          );
-        } catch (error) {
-          reject(error);
-        }
-      });
-    }
-
-    // Slow path for other types returns a Uint8Array.
-    return this.packImpl({ messageKey, payload }, undefined);
-  }
-
-  public unpack(packedData: string | ArrayBuffer): MessageFrame<T> {
-    // Fast path to unpack as string given `JSON.parse` is fast.
-    if (typeof packedData === 'string') {
-      return JSON.parse(packedData);
-    }
-
-    // [0] messageKeyLength (4 bytes)
-    const messageKeyLengthView = new DataView(packedData, 0, 4);
-    const messageKeyLength = messageKeyLengthView.getUint32(0, false);
-
-    // [1] messageKey (variable length)
-    const messageKeyBytes = packedData.slice(4, 4 + messageKeyLength);
-    const messageKeyString = this.textDecoder.decode(messageKeyBytes);
-    const messageKey = JSON.parse(messageKeyString);
-
-    // [2] payloadTypeIndicator (1 byte)
-    const payloadTypeView = new DataView(packedData, 4 + messageKeyLength, 1);
-    const payloadType = payloadTypeView.getUint8(0);
-
-    // [3] payload (variable length)
-    const payloadBinary = packedData.slice(4 + messageKeyLength + 1);
-    const payload = this.deserializePayload(payloadBinary, payloadType);
-
-    return { messageKey, payload };
-  }
-
-  private isFastPathPayload(payload: PayloadType): boolean {
-    if (payload == null) {
-      return true;
-    }
-    const payloadType = typeof payload;
-    if (payloadType === 'string' || payloadType === 'number') {
-      return true;
-    }
-    if (payloadType === 'object' && payload.constructor === Object) {
-      return true;
-    }
-    return false;
-  }
-
-  private payloadToUint8Array(payload: PayloadType): Uint8Array {
-    if (payload instanceof Uint8Array) {
-      return payload;
-    } else if (typeof payload === 'string') {
-      return this.textEncoder.encode(payload);
-    } else if (typeof payload === 'number') {
-      const buffer = new ArrayBuffer(8);
-      const view = new DataView(buffer);
-      view.setFloat64(0, payload, false);
-      return new Uint8Array(buffer);
-    } else if (payload === null) {
-      return new Uint8Array(0);
-    } else if (payload === undefined) {
-      return new Uint8Array(0);
-    } else if (payload instanceof ArrayBuffer) {
-      return new Uint8Array(payload);
-    } else if (payload instanceof Blob) {
-      throw new Error('Blob is not supported in this callsite.');
-    } else {
-      return this.textEncoder.encode(JSON.stringify(payload));
-    }
-  }
-
-  private packImpl(
-    { messageKey, payload }: MessageFrame<T>,
-    payloadType: PayloadTypeIndicator | undefined
-  ): Promise<Uint8Array> | Uint8Array {
-    const messageKeyString = JSON.stringify(messageKey);
-    const messageKeyBytes = this.textEncoder.encode(messageKeyString);
-    const messageKeyLength = messageKeyBytes.length;
-    const payloadBinary = this.payloadToUint8Array(payload);
-
-    const totalLength = 4 + messageKeyLength + 1 + payloadBinary.byteLength;
-    const buffer = new ArrayBuffer(totalLength);
-    const packedArray = new Uint8Array(buffer);
-
-    // [0] messageKeyLength (4 bytes)
-    const messageKeyLengthView = new DataView(buffer, 0, 4);
-    messageKeyLengthView.setUint32(0, messageKeyLength, false);
-
-    // [1] messageKey (variable length)
-    packedArray.set(messageKeyBytes, 4);
-
-    // [2] payloadTypeIndicator (1 byte)
-    const payloadTypeView = new DataView(buffer, 4 + messageKeyLength, 1);
-    payloadTypeView.setUint8(0, payloadType ?? MessageFramePacker.getPayloadTypeIndicator(payload));
-
-    // [3] payload (variable length)
-    packedArray.set(payloadBinary, 4 + messageKeyLength + 1);
-
-    return packedArray;
-  }
-
-  private deserializePayload(
-    payloadBinary: ArrayBuffer,
-    payloadTypeIndicator: PayloadTypeIndicator
-  ): PayloadType {
-    switch (payloadTypeIndicator) {
-      case PayloadTypeIndicator.Uint8Array: {
-        return new Uint8Array(payloadBinary);
-      }
-      case PayloadTypeIndicator.String: {
-        return this.textDecoder.decode(payloadBinary);
-      }
-      case PayloadTypeIndicator.Number: {
-        const view = new DataView(payloadBinary);
-        return view.getFloat64(0, false);
-      }
-      case PayloadTypeIndicator.Null: {
-        return null;
-      }
-      case PayloadTypeIndicator.Undefined: {
-        return undefined;
-      }
-      case PayloadTypeIndicator.Object: {
-        const jsonString = this.textDecoder.decode(payloadBinary);
-        return JSON.parse(jsonString);
-      }
-      case PayloadTypeIndicator.ArrayBuffer: {
-        return payloadBinary;
-      }
-      case PayloadTypeIndicator.Blob: {
-        return new Blob([payloadBinary]);
-      }
-      default:
-        throw new Error('Unsupported payload type');
-    }
-  }
-
-  private static getPayloadTypeIndicator(payload: PayloadType): PayloadTypeIndicator {
-    if (payload instanceof Uint8Array) {
-      return PayloadTypeIndicator.Uint8Array;
-    } else if (typeof payload === 'string') {
-      return PayloadTypeIndicator.String;
-    } else if (typeof payload === 'number') {
-      return PayloadTypeIndicator.Number;
-    } else if (payload === null) {
-      return PayloadTypeIndicator.Null;
-    } else if (payload === undefined) {
-      return PayloadTypeIndicator.Undefined;
-    } else if (payload instanceof ArrayBuffer) {
-      return PayloadTypeIndicator.ArrayBuffer;
-    } else if (payload instanceof Blob) {
-      return PayloadTypeIndicator.Blob;
-    } else if (typeof payload === 'object') {
-      return PayloadTypeIndicator.Object;
-    } else {
-      throw new Error('Unsupported payload type');
-    }
-  }
-}

package/src/devtools/ProtocolVersion.ts

@@ -1,6 +0,0 @@
-/**
- * A transport protocol version between the app and the webui.
- * It shows a warning in handshaking stage if the version is different between the app and the webui.
- * The value should be increased when the protocol is changed.
- */
-export const PROTOCOL_VERSION = 1;

package/src/devtools/WebSocketBackingStore.ts

@@ -1,10 +0,0 @@
-/**
- * The backing store for the WebSocket connection and reference count.
- * This is used for connection multiplexing.
- */
-export class WebSocketBackingStore {
-  constructor(
-    public ws: WebSocket | null = null,
-    public refCount: number = 0
-  ) {}
-}