expo 54.0.0-canary-20250722-599a28f → 54.0.0-preview.0

package/src/devtools/__tests__/DevToolsPluginClient-test.ts

@@ -1,285 +0,0 @@
-/// <reference types="node" />
-
-import { TextDecoder, TextEncoder } from 'node:util';
-
-import MockWebSocket from './MockWebSocket';
-import { DevToolsPluginClient } from '../DevToolsPluginClient';
-import { createDevToolsPluginClient } from '../DevToolsPluginClientFactory';
-import { WebSocketBackingStore } from '../WebSocketBackingStore';
-
-// @ts-expect-error - We don't mock all properties from WebSocket
-globalThis.WebSocket = MockWebSocket;
-
-// @ts-ignore - TextDecoder and TextEncoder are not defined in native jest environments.
-globalThis.TextDecoder ??= TextDecoder;
-globalThis.TextEncoder ??= TextEncoder;
-
-const TEST_PROTOCOL_VERSION = 1;
-
-describe(`DevToolsPluginClient`, () => {
-  let appClient: DevToolsPluginClient;
-  let testCaseCounter = 0;
-  let devServer: string;
-  const pluginName = 'testPlugin';
-
-  beforeEach(async () => {
-    // Connect to different devServer for each test case to avoid jest parallel test issues.
-    testCaseCounter += 1;
-    devServer = `localhost:${8000 + testCaseCounter}`;
-    appClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-  });
-
-  afterEach(async () => {
-    await appClient.closeAsync();
-  });
-
-  it('should connect to the WebSocket server', async () => {
-    expect(appClient.isConnected()).toBe(true);
-  });
-});
-
-describe(`DevToolsPluginClient (browser <> app)`, () => {
-  let testCaseCounter = 0;
-  let devServer: string;
-  const pluginName = 'testPlugin';
-  let appClient: DevToolsPluginClient;
-  let browserClient: DevToolsPluginClient;
-
-  beforeEach(() => {
-    // Connect to different devServer for each test case to avoid jest parallel test issues.
-    testCaseCounter += 1;
-    devServer = `localhost:${8000 + testCaseCounter}`;
-  });
-
-  afterEach(async () => {
-    await appClient?.closeAsync();
-    await browserClient?.closeAsync();
-  });
-
-  it('should send and receive messages', async () => {
-    const method = 'testMethod';
-    const message = { foo: 'bar' };
-
-    appClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-    browserClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'browser',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-
-    const receivedPromise = new Promise((resolve) => {
-      appClient.addMessageListener(method, (params) => {
-        resolve(params);
-      });
-    });
-
-    browserClient.sendMessage(method, message);
-    const received = await receivedPromise;
-    expect(received).toEqual(message);
-  });
-
-  it('should support ping-pong messages', async () => {
-    appClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-    browserClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'browser',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-
-    const appPromise = new Promise((resolve) => {
-      appClient.addMessageListener('ping', (params) => {
-        appClient.sendMessage('pong', { from: 'app' });
-        resolve(params);
-      });
-    });
-    const browserPromise = new Promise((resolve) => {
-      browserClient.addMessageListener('pong', (params) => {
-        resolve(params);
-      });
-    });
-
-    browserClient.sendMessage('ping', { from: 'browser' });
-    const receivedPing = await appPromise;
-    expect(receivedPing).toEqual({ from: 'browser' });
-    const receivedPong = await browserPromise;
-    expect(receivedPong).toEqual({ from: 'app' });
-  });
-
-  it('should not receive messages from differnet plugin', async () => {
-    const method = 'testMethod';
-    const message = { foo: 'bar' };
-
-    appClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-    browserClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'browser',
-      pluginName: 'pluginB',
-      wsStore: new WebSocketBackingStore(),
-    });
-
-    const receivedPromise = new Promise((resolve) => {
-      appClient.addMessageListener(method, (params) => {
-        resolve(params);
-      });
-    });
-
-    browserClient.sendMessage(method, message);
-    expect(receivedPromise).rejects.toThrow();
-  });
-
-  it('should only allow the latest connected client with the same plugin name to receive messages', async () => {
-    const method = 'testMethod';
-
-    appClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-    const receivedMessages: any[] = [];
-    appClient.addMessageListener(method, (params) => {
-      receivedMessages.push(params);
-    });
-
-    browserClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'browser',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-
-    await delayAsync(100);
-    const browserClient2 = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'browser',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-
-    await delayAsync(100);
-    expect(browserClient.isConnected()).toBe(false);
-    expect(browserClient2.isConnected()).toBe(true);
-    browserClient.sendMessage(method, { from: 'browserClient' });
-    browserClient2.sendMessage(method, { from: 'browserClient2' });
-
-    await delayAsync(100);
-    expect(receivedMessages.length).toBe(1);
-    expect(receivedMessages[0]).toEqual({ from: 'browserClient2' });
-    await browserClient2.closeAsync();
-  });
-
-  it('should terminate client from incompatible protocol version', async () => {
-    const spyConsoleInfo = jest.spyOn(console, 'info').mockImplementation(() => {});
-    const spyConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => {});
-    appClient = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-    browserClient = await createDevToolsPluginClient({
-      protocolVersion: -1,
-      devServer,
-      sender: 'browser',
-      pluginName,
-      wsStore: new WebSocketBackingStore(),
-    });
-
-    await delayAsync(100);
-    expect(spyConsoleWarn).toHaveBeenCalledWith(
-      `Received an incompatible devtools plugin handshake message - pluginName[${pluginName}]`
-    );
-    expect(browserClient.isConnected()).toBe(false);
-
-    spyConsoleInfo.mockRestore();
-    spyConsoleWarn.mockRestore();
-  });
-});
-
-describe(`DevToolsPluginClient - multiplexing`, () => {
-  let testCaseCounter = 0;
-  let devServer: string;
-
-  beforeEach(() => {
-    // Connect to different devServer for each test case to avoid jest parallel test issues.
-    testCaseCounter += 1;
-    devServer = `localhost:${8000 + testCaseCounter}`;
-  });
-
-  it('should not close the websocket connection while there are alive clients', async () => {
-    const wsStore = new WebSocketBackingStore();
-    const appClient1 = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName: 'plugin1',
-      wsStore,
-    });
-    const appClient2 = await createDevToolsPluginClient({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      devServer,
-      sender: 'app',
-      pluginName: 'plugin2',
-      wsStore,
-    });
-    expect(appClient1.isConnected()).toBe(true);
-    expect(appClient2.isConnected()).toBe(true);
-    expect(appClient1.getWebSocketBackingStore()).toBe(wsStore);
-    expect(appClient2.getWebSocketBackingStore()).toBe(wsStore);
-    expect(wsStore.refCount).toBe(2);
-    const ws = wsStore.ws;
-    if (!ws) {
-      throw new Error('Null WebSocket');
-    }
-    const mockClose = jest.spyOn(ws, 'close');
-    expect(mockClose).toHaveBeenCalledTimes(0);
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-
-    await appClient1.closeAsync();
-    expect(mockClose).toHaveBeenCalledTimes(0);
-    expect(wsStore.refCount).toBe(1);
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-
-    await appClient2.closeAsync();
-    expect(mockClose).toHaveBeenCalledTimes(1);
-    expect(wsStore.refCount).toBe(0);
-    expect(ws.readyState).toBe(WebSocket.CLOSED);
-  });
-});
-
-async function delayAsync(timeMs: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, timeMs));
-}

package/src/devtools/__tests__/DevToolsPluginClientFactory-test.ts

@@ -1,120 +0,0 @@
-/// <reference types="node" />
-
-import { TextDecoder, TextEncoder } from 'node:util';
-
-import MockWebSocket from './MockWebSocket';
-import {
-  cleanupDevToolsPluginInstances,
-  getDevToolsPluginClientAsync,
-} from '../DevToolsPluginClientFactory';
-import { DevToolsPluginClientImplApp } from '../DevToolsPluginClientImplApp';
-import { DevToolsPluginClientImplBrowser } from '../DevToolsPluginClientImplBrowser';
-import { getConnectionInfo } from '../getConnectionInfo';
-
-jest.mock('../getConnectionInfo');
-
-// @ts-expect-error - We don't mock all properties from WebSocket
-globalThis.WebSocket = MockWebSocket;
-
-// @ts-ignore - TextDecoder and TextEncoder are not defined in native jest environments.
-globalThis.TextDecoder ??= TextDecoder;
-globalThis.TextEncoder ??= TextEncoder;
-
-const TEST_PROTOCOL_VERSION = 1;
-
-describe(getDevToolsPluginClientAsync, () => {
-  const mockGetConnectionInfo = getConnectionInfo as jest.MockedFunction<typeof getConnectionInfo>;
-
-  afterEach(() => {
-    jest.resetAllMocks();
-    cleanupDevToolsPluginInstances();
-  });
-
-  it('should return a DevToolsPluginClientImplApp client when sender is from app', async () => {
-    mockGetConnectionInfo.mockReturnValue({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      sender: 'app',
-      devServer: 'localhost:8081',
-    });
-    const client = await getDevToolsPluginClientAsync('testPlugin');
-    expect(client).toBeInstanceOf(DevToolsPluginClientImplApp);
-  });
-
-  it('should return a DevToolsPluginClientImplApp client when sender is from browser', async () => {
-    mockGetConnectionInfo.mockReturnValue({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      sender: 'browser',
-      devServer: 'localhost:8081',
-    });
-    const client = await getDevToolsPluginClientAsync('testPlugin');
-    expect(client).toBeInstanceOf(DevToolsPluginClientImplBrowser);
-  });
-
-  it('should return the same client from the same plugin name when called multiple times', async () => {
-    mockGetConnectionInfo.mockReturnValue({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      sender: 'app',
-      devServer: 'localhost:8081',
-    });
-    const pluginName = 'testPlugin';
-
-    const client = await getDevToolsPluginClientAsync(pluginName);
-    const client2 = await getDevToolsPluginClientAsync(pluginName);
-    expect(client).toBe(client2);
-  });
-
-  it('should return a new client from the same plugin name from disconnected', async () => {
-    mockGetConnectionInfo.mockReturnValue({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      sender: 'app',
-      devServer: 'localhost:8081',
-    });
-    const pluginName = 'testPlugin';
-    jest.spyOn(DevToolsPluginClientImplApp.prototype, 'isConnected').mockReturnValue(false);
-
-    const client = await getDevToolsPluginClientAsync(pluginName);
-    const client2 = await getDevToolsPluginClientAsync(pluginName);
-    expect(client).not.toBe(client2);
-  });
-
-  it('should return a new client from the same plugin name when devServer changed', async () => {
-    const pluginName = 'testPlugin';
-
-    mockGetConnectionInfo.mockReturnValueOnce({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      sender: 'app',
-      devServer: 'localhost:8081',
-    });
-    const client = await getDevToolsPluginClientAsync(pluginName);
-
-    mockGetConnectionInfo.mockReturnValueOnce({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      sender: 'app',
-      devServer: 'localhost:8082',
-    });
-    const client2 = await getDevToolsPluginClientAsync(pluginName);
-
-    expect(client).not.toBe(client2);
-  });
-
-  it('should have at most one client per plugin name', async () => {
-    mockGetConnectionInfo.mockReturnValue({
-      protocolVersion: TEST_PROTOCOL_VERSION,
-      sender: 'app',
-      devServer: 'localhost:8081',
-    });
-    const pluginName = 'testPlugin';
-    const spy = jest.spyOn(DevToolsPluginClientImplApp.prototype, 'initAsync');
-
-    const [client1, client2, client3, anotherClient] = await Promise.all([
-      getDevToolsPluginClientAsync(pluginName),
-      getDevToolsPluginClientAsync(pluginName),
-      getDevToolsPluginClientAsync(pluginName),
-      getDevToolsPluginClientAsync('anotherPlugin'),
-    ]);
-    expect(client1).toBe(client2);
-    expect(client1).toBe(client3);
-    expect(client1).not.toBe(anotherClient);
-    expect(spy).toHaveBeenCalledTimes(2);
-  });
-});

package/src/devtools/__tests__/MessageFramePack-test.node.ts

@@ -1,157 +0,0 @@
-import { MessageFramePacker } from '../MessageFramePacker';
-
-describe(MessageFramePacker, () => {
-  let packer: MessageFramePacker<string>;
-
-  beforeEach(() => {
-    packer = new MessageFramePacker();
-  });
-
-  it('should pack and unpack a message with a string payload', async () => {
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: 'testPayload',
-    };
-
-    const packedData = packer.pack(messageFrame);
-    if (packedData instanceof Promise || packedData instanceof Uint8Array) {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packer.unpack(packedData);
-    expect(unpackedData).toEqual(messageFrame);
-  });
-
-  it('should pack and unpack a message with a number payload', async () => {
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: 12345,
-    };
-
-    const packedData = packer.pack(messageFrame);
-    if (packedData instanceof Promise || packedData instanceof Uint8Array) {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packer.unpack(packedData);
-    expect(unpackedData).toEqual(messageFrame);
-  });
-
-  it('should pack and unpack a message with a null payload', async () => {
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: null,
-    };
-
-    const packedData = packer.pack(messageFrame);
-    if (packedData instanceof Promise || packedData instanceof Uint8Array) {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packer.unpack(packedData);
-    expect(unpackedData).toEqual(messageFrame);
-  });
-
-  it('should pack and unpack a message with an undefined payload', async () => {
-    const messageFrame = {
-      messageKey: 'testKey',
-    };
-
-    const packedData = packer.pack(messageFrame);
-    if (packedData instanceof Promise || packedData instanceof Uint8Array) {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packer.unpack(packedData);
-    expect(unpackedData).toEqual(messageFrame);
-  });
-
-  it('should pack and unpack a message with an object payload', async () => {
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: { key: 'value' },
-    };
-
-    const packedData = packer.pack(messageFrame);
-    if (packedData instanceof Promise || packedData instanceof Uint8Array) {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packer.unpack(packedData);
-    expect(unpackedData).toEqual(messageFrame);
-  });
-
-  it('should pack and unpack a message with an Uint8Array payload', async () => {
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: new Uint8Array([1, 2, 3, 4]),
-    };
-
-    const packedData = packer.pack(messageFrame);
-    if (packedData instanceof Promise || typeof packedData === 'string') {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packer.unpack(packedData.buffer as ArrayBuffer);
-    expect(unpackedData.messageKey).toEqual(messageFrame.messageKey);
-    expect(unpackedData.payload).toEqual(messageFrame.payload);
-  });
-
-  it('should pack and unpack a message with an ArrayBuffer payload', async () => {
-    const buffer = new ArrayBuffer(4);
-    const view = new Uint8Array(buffer);
-    view.set([1, 2, 3, 4]);
-
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: buffer,
-    };
-
-    const packedData = packer.pack(messageFrame);
-    if (packedData instanceof Promise || typeof packedData === 'string') {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packer.unpack(packedData.buffer as ArrayBuffer);
-    expect(unpackedData.messageKey).toEqual(messageFrame.messageKey);
-    expect(new Uint8Array(unpackedData.payload as ArrayBuffer)).toEqual(view);
-  });
-
-  it('should pack and unpack a message with a Blob payload', async () => {
-    const blob = new Blob(['testBlob'], { type: 'text/plain' });
-
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: blob,
-    };
-
-    const packedDataPromise = packer.pack(messageFrame);
-    if (packedDataPromise instanceof Uint8Array || typeof packedDataPromise === 'string') {
-      throw new Error('Unexpected packed data type');
-    }
-    const packedData = await packedDataPromise;
-    const unpackedData = packer.unpack(packedData.buffer as ArrayBuffer);
-    expect(unpackedData.messageKey).toEqual(messageFrame.messageKey);
-    const unpackedBlob = unpackedData.payload as Blob;
-    expect(await unpackedBlob.text()).toEqual(await blob.text());
-  });
-
-  it('should pack and unpack a message with an object messageKey', async () => {
-    const packerWithObjectKey = new MessageFramePacker<{ key: string }>();
-    const messageFrame = {
-      messageKey: { key: 'value' },
-      payload: 'testPayload',
-    };
-
-    const packedData = packerWithObjectKey.pack(messageFrame);
-    if (packedData instanceof Promise || packedData instanceof Uint8Array) {
-      throw new Error('Unexpected packed data type');
-    }
-    const unpackedData = packerWithObjectKey.unpack(packedData);
-    expect(unpackedData).toEqual(messageFrame);
-  });
-
-  it('should throw an error for an unsupported payload type', async () => {
-    const messageFrame = {
-      messageKey: 'testKey',
-      payload: () => {},
-    };
-
-    expect(() => {
-      packer.pack(messageFrame);
-    }).toThrow('Unsupported payload type');
-  });
-});

package/src/devtools/__tests__/MockWebSocket.ts

@@ -1,100 +0,0 @@
-interface EventSubscription {
-  listener: (payload: any) => void;
-  remove(): void;
-}
-
-class EventEmitter {
-  listeners: Record<string, undefined | Set<(payload: any) => void>> = Object.create(null);
-
-  addListener(event: string, listener: (payload: any) => void) {
-    (this.listeners[event] || (this.listeners[event] = new Set())).add(listener);
-    return {
-      listener,
-      remove: () => this.listeners[event]?.delete(listener),
-    };
-  }
-
-  emit(event: string, payload?: any) {
-    const listeners = this.listeners[event];
-    if (listeners) {
-      for (const listener of listeners) listener(payload);
-    }
-  }
-}
-
-export default class MockWebSocket {
-  static readonly CONNECTING = 0;
-  static readonly OPEN = 1;
-  static readonly CLOSING = 2;
-  static readonly CLOSED = 3;
-
-  public readyState = MockWebSocket.CONNECTING;
-
-  private readonly emitter = new EventEmitter();
-  private subscriptions: EventSubscription[] = [];
-  private broadcastSubscriptions: EventSubscription[] = [];
-
-  // We use the broadcastEmitter to simulate event passing on a WebSocket server.
-  // The map is {address -> EventEmitter}
-  private static broadcastEmitter: Record<string, EventEmitter> = {};
-
-  constructor(private readonly address: string) {
-    MockWebSocket.broadcastEmitter[address] ??= new EventEmitter();
-    setTimeout(() => {
-      this.readyState = MockWebSocket.OPEN;
-      this.emitter.emit('open');
-
-      const subscription = MockWebSocket.broadcastEmitter[this.address].addListener(
-        'broadcast',
-        this.handleBroadcast
-      );
-      this.broadcastSubscriptions.push(subscription);
-    }, 0);
-  }
-
-  addEventListener = jest.fn().mockImplementation((event, listener) => {
-    const subscription = this.emitter.addListener(event, listener);
-    this.subscriptions.push(subscription);
-
-    const broadcastSubscription = MockWebSocket.broadcastEmitter[this.address].addListener(
-      event,
-      listener
-    );
-    this.broadcastSubscriptions.push(broadcastSubscription);
-  });
-  removeEventListener = jest.fn().mockImplementation((event, listener) => {
-    const index = this.subscriptions.findIndex(
-      (subscription) => subscription.listener === listener
-    );
-    if (index >= 0) {
-      this.subscriptions[index].remove();
-      this.subscriptions.splice(index, 1);
-    }
-
-    const broadcastIndex = this.broadcastSubscriptions.findIndex(
-      (subscription) => subscription.listener === listener
-    );
-    if (broadcastIndex >= 0) {
-      this.broadcastSubscriptions[broadcastIndex].remove();
-      this.broadcastSubscriptions.splice(broadcastIndex, 1);
-    }
-  });
-
-  close = jest.fn().mockImplementation(() => {
-    for (const subscription of this.broadcastSubscriptions) {
-      subscription.remove();
-    }
-    this.broadcastSubscriptions = [];
-    this.readyState = MockWebSocket.CLOSED;
-  });
-
-  send = jest.fn().mockImplementation((data) => {
-    MockWebSocket.broadcastEmitter[this.address].emit('broadcast', { sender: this, data });
-  });
-
-  private handleBroadcast = ({ sender, data }: any) => {
-    if (sender !== this) {
-      this.emitter.emit('message', { data });
-    }
-  };
-}