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

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

package/src/devtools/index.ts

@@ -1,53 +0,0 @@
-import { useState, useEffect } from 'react';
-
-import { DevToolsPluginClient } from './DevToolsPluginClient';
-import { getDevToolsPluginClientAsync } from './DevToolsPluginClientFactory';
-import type { DevToolsPluginClientOptions } from './devtools.types';
-
-export { getDevToolsPluginClientAsync, DevToolsPluginClient };
-export type { DevToolsPluginClientOptions };
-// Export the EventSubscription type if people need to use explicit type from `addMessageListener`
-export type { EventSubscription } from './DevToolsPluginClient';
-export { setEnableLogging } from './logger';
-
-/**
- * A React hook to get the DevToolsPluginClient instance.
- */
-export function useDevToolsPluginClient(
-  pluginName: string,
-  options?: DevToolsPluginClientOptions
-): DevToolsPluginClient | null {
-  const [client, setClient] = useState<DevToolsPluginClient | null>(null);
-  const [error, setError] = useState<Error | null>(null);
-
-  useEffect(() => {
-    async function setup() {
-      try {
-        const client = await getDevToolsPluginClientAsync(pluginName, options);
-        setClient(client);
-      } catch (e: any) {
-        setError(new Error('Failed to setup client from useDevToolsPluginClient: ' + e.toString()));
-      }
-    }
-
-    async function teardown() {
-      try {
-        await client?.closeAsync();
-      } catch (e: any) {
-        setError(
-          new Error('Failed to teardown client from useDevToolsPluginClient: ' + e.toString())
-        );
-      }
-    }
-
-    setup();
-    return () => {
-      teardown();
-    };
-  }, [pluginName]);
-
-  if (error != null) {
-    throw error;
-  }
-  return client;
-}

package/src/devtools/logger.ts

@@ -1,29 +0,0 @@
-let enableLogging = false;
-
-export function log(...params: Parameters<typeof console.log>) {
-  if (enableLogging) {
-    console.log(...params);
-  }
-}
-
-export function debug(...params: Parameters<typeof console.debug>) {
-  if (enableLogging) {
-    console.debug(...params);
-  }
-}
-
-export function info(...params: Parameters<typeof console.info>) {
-  if (enableLogging) {
-    console.info(...params);
-  }
-}
-
-export function warn(...params: Parameters<typeof console.info>) {
-  if (enableLogging) {
-    console.warn(...params);
-  }
-}
-
-export function setEnableLogging(enabled: boolean) {
-  enableLogging = enabled;
-}