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

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 });
-    }
-  };
-}

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

@@ -1,184 +0,0 @@
-import { WebSocket, WebSocketServer } from 'ws';
-
-import { WebSocketWithReconnect } from '../WebSocketWithReconnect';
-
-// @ts-expect-error - The WebSocket from ws is not compatible with the globalThis.WebSocket
-globalThis.WebSocket = WebSocket;
-
-describe(WebSocketWithReconnect, () => {
-  let ws: WebSocketWithReconnect | null = null;
-  let server: WebSocketServer | null = null;
-
-  afterEach(async () => {
-    ws?.close();
-    await closeServerAsync(server);
-  });
-
-  it('should act as a WebSocket', async () => {
-    server = new WebSocketServer({ port: 8000 });
-    // An echoing server
-    server?.addListener('connection', (socket) => {
-      socket.addEventListener('message', (e) => {
-        socket.send(e.data);
-      });
-    });
-
-    ws = new WebSocketWithReconnect('ws://localhost:8000');
-    let received = '';
-    ws.addEventListener('message', (e) => {
-      received = e.data;
-    });
-    await new Promise((resolve) => {
-      ws?.addEventListener('open', () => {
-        resolve(null);
-      });
-    });
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-
-    ws.send('hello');
-    await delayAsync(50);
-    expect(received).toBe('hello');
-  });
-
-  it('should reconnect when the connection is lost', async () => {
-    server = new WebSocketServer({ port: 8000 });
-
-    const mockOnReconnect = jest.fn();
-    ws = new WebSocketWithReconnect('ws://localhost:8000', {
-      retriesInterval: 10,
-      onReconnect: mockOnReconnect,
-    });
-    await new Promise((resolve) => {
-      ws?.addEventListener('open', () => {
-        resolve(null);
-      });
-    });
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-
-    await closeServerAsync(server);
-    server = new WebSocketServer({ port: 8000 });
-    await delayAsync(100);
-
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-    expect(mockOnReconnect).toHaveBeenCalled();
-  });
-
-  it('should keep sending messages when retrying connection', async () => {
-    server = new WebSocketServer({ port: 8000 });
-    ws = new WebSocketWithReconnect('ws://localhost:8000', {
-      retriesInterval: 10,
-    });
-    await new Promise((resolve) => {
-      ws?.addEventListener('open', () => {
-        resolve(null);
-      });
-    });
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-
-    await closeServerAsync(server);
-
-    expect(ws.readyState).not.toBe(WebSocket.OPEN);
-    ws.send('hello');
-
-    server = new WebSocketServer({ port: 8000 });
-    const receivedPromise = new Promise((resolve) => {
-      server?.addListener('connection', (socket) => {
-        socket.addEventListener('message', (e) => {
-          resolve(e.data);
-        });
-      });
-    });
-
-    await delayAsync(30);
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-    const received = await receivedPromise;
-    expect(received).toBe('hello');
-  });
-
-  it('should throw errors if exceeds max retries', async () => {
-    server = new WebSocketServer({ port: 8000 });
-
-    const mockOnError = jest.fn();
-    ws = new WebSocketWithReconnect('ws://localhost:8000', {
-      retriesInterval: 10,
-      maxRetries: 2,
-      onError: mockOnError,
-    });
-    await closeServerAsync(server);
-    await delayAsync(100);
-    expect(mockOnError).toHaveBeenCalled();
-  });
-
-  it('should show connecting state when reconnecting', async () => {
-    server = new WebSocketServer({ port: 8000 });
-
-    ws = new WebSocketWithReconnect('ws://localhost:8000', {
-      retriesInterval: 1000,
-    });
-    await closeServerAsync(server);
-    await delayAsync(100);
-    expect(ws.readyState).toBe(WebSocket.CONNECTING);
-  });
-
-  it('should not emit close event when reconnecting until exceeds maxRetries', async () => {
-    server = new WebSocketServer({ port: 8000 });
-
-    const mockOnError = jest.fn();
-    ws = new WebSocketWithReconnect('ws://localhost:8000', {
-      retriesInterval: 50,
-      maxRetries: 2,
-      onError: mockOnError,
-    });
-    const mockClose = jest.fn();
-    ws.addEventListener('close', mockClose);
-    await closeServerAsync(server);
-    await delayAsync(50);
-    expect(mockClose).not.toHaveBeenCalled();
-    await delayAsync(100);
-    expect(mockClose).toHaveBeenCalled();
-    expect(ws.readyState).toBe(WebSocket.CLOSED);
-    expect(mockOnError).toHaveBeenCalled();
-  });
-
-  it('should support arraybuffer binaryType option', async () => {
-    server = new WebSocketServer({ port: 8000 });
-    // An echoing server
-    server?.addListener('connection', (socket) => {
-      socket.addEventListener('message', (e) => {
-        socket.send(e.data);
-      });
-    });
-
-    ws = new WebSocketWithReconnect('ws://localhost:8000', { binaryType: 'arraybuffer' });
-    let received: any = null;
-    ws.addEventListener('message', (e) => {
-      received = e.data;
-    });
-    await new Promise((resolve) => {
-      ws?.addEventListener('open', () => {
-        resolve(null);
-      });
-    });
-    expect(ws.readyState).toBe(WebSocket.OPEN);
-
-    ws.send(new Uint8Array([0x01, 0x02, 0x03]));
-    await delayAsync(50);
-    expect(received).toBeInstanceOf(ArrayBuffer);
-    expect(new Uint8Array(received as ArrayBuffer)).toEqual(new Uint8Array([0x01, 0x02, 0x03]));
-  });
-});
-
-async function closeServerAsync(server: WebSocketServer | null) {
-  if (server == null) {
-    return;
-  }
-  server.close();
-  for (const client of server.clients) {
-    client.terminate();
-  }
-  await delayAsync(30);
-}
-
-async function delayAsync(timeMs: number) {
-  return new Promise((resolve) => setTimeout(resolve, timeMs));
-}

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

@@ -1,20 +0,0 @@
-import * as logger from '../logger';
-
-describe('logger', () => {
-  const spyLog = jest.spyOn(console, 'info').mockImplementation(() => {});
-
-  afterEach(() => {
-    logger.setEnableLogging(false);
-  });
-  it('should not log by default', () => {
-    logger.info('test');
-    expect(spyLog).not.toHaveBeenCalled();
-  });
-
-  it('should logger when enabled', () => {
-    logger.setEnableLogging(true);
-    logger.info('test logging');
-    expect(spyLog).toHaveBeenCalled();
-    expect(spyLog.mock.calls[0][0]).toBe('test logging');
-  });
-});

package/src/devtools/devtools.types.ts

@@ -1,50 +0,0 @@
-import type { WebSocketBackingStore } from './WebSocketBackingStore';
-
-/**
- * The connection info for devtools plugins client.
- */
-export interface ConnectionInfo {
-  /** Indicates the sender towards the devtools plugin. */
-  sender:
-    | 'app' // client running in the app environment.
-    | 'browser'; // client running in the browser environment.
-
-  /** Dev server address. */
-  devServer: string;
-
-  /** The plugin name. */
-  pluginName: string;
-
-  /**
-   * The backing store for the WebSocket connection. Exposed for testing.
-   * If not provided, the default singleton instance will be used.
-   * @hidden
-   */
-  wsStore?: WebSocketBackingStore;
-
-  /**
-   * The transport protocol version between the app and the webui.
-   */
-  protocolVersion: number;
-}
-
-/**
- * Options for the devtools plugin client.
- */
-export interface DevToolsPluginClientOptions {
-  /**
-   * The underlying WebSocket [`binaryType`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/binaryType).
-   */
-  websocketBinaryType?: 'arraybuffer' | 'blob';
-}
-
-/**
- * The handshake messages for the devtools plugin client.
- * @hidden
- */
-export interface HandshakeMessageParams {
-  protocolVersion: number;
-  pluginName: string;
-  method: 'handshake' | 'terminateBrowserClient';
-  browserClientId: string;
-}

package/src/devtools/getConnectionInfo.native.ts

@@ -1,18 +0,0 @@
-/**
- * Get the dev server address.
- */
-
-import { PROTOCOL_VERSION } from './ProtocolVersion';
-import type { ConnectionInfo } from './devtools.types';
-
-export function getConnectionInfo(): Omit<ConnectionInfo, 'pluginName'> {
-  const getDevServer = require('react-native/Libraries/Core/Devtools/getDevServer').default;
-  const devServer = getDevServer()
-    .url.replace(/^https?:\/\//, '')
-    .replace(/\/?$/, '') as string;
-  return {
-    protocolVersion: PROTOCOL_VERSION,
-    sender: 'app',
-    devServer,
-  };
-}

package/src/devtools/getConnectionInfo.ts

@@ -1,16 +0,0 @@
-/**
- * Get the dev server address.
- */
-
-import { PROTOCOL_VERSION } from './ProtocolVersion';
-import type { ConnectionInfo } from './devtools.types';
-
-export function getConnectionInfo(): Omit<ConnectionInfo, 'pluginName'> {
-  const devServerQuery = new URLSearchParams(window.location.search).get('devServer');
-  const host = window.location.origin.replace(/^https?:\/\//, '');
-  return {
-    protocolVersion: PROTOCOL_VERSION,
-    sender: 'browser',
-    devServer: devServerQuery || host,
-  };
-}