@teardown/cli 1.2.15 → 1.2.22

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-debugger.server.d.ts

@@ -0,0 +1,63 @@
+import type { IncomingMessage } from "node:http";
+import type { FastifyInstance } from "fastify";
+import type WebSocket from "ws";
+import { WebSocketServer } from "../web-socket-server";
+/**
+ * Class for creating a WebSocket server and providing a bridge between
+ * debugger UI (Remote JS debugger) and the running React Native application.
+ *
+ * React Native application (aka client) will send and receive messages from the debugger UI
+ * which runs inside a browser.
+ *
+ * @category Development server
+ */
+export declare class WebSocketDebuggerServer extends WebSocketServer {
+    /**
+     * A WebSocket connection with the debugger UI.
+     */
+    private debuggerSocket;
+    /**
+     * A WebSocket connection with the client (React Native app).
+     */
+    private clientSocket;
+    /**
+     * Create new instance of WebSocketDebuggerServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify: FastifyInstance);
+    /**
+     * Check if debugger UI is connected to the WebSocketDebuggerServer.
+     */
+    isDebuggerConnected(): boolean;
+    /**
+     * Send a message to a given WebSocket connection.
+     *
+     * @param socket WebSocket connection to send the message to.
+     * @param message Message to send.
+     */
+    send(socket: WebSocket | undefined, message: string): void;
+    /**
+     * Process new WebSocket connection. The upgrade request should contain `role` query param
+     * for determining the type of the connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     * @param request Upgrade request for the connection.
+     */
+    onConnection(socket: WebSocket, request: IncomingMessage): void;
+    /**
+     * Process new WebSocket connection from Debugger UI (Remote JS Debugger).
+     * If there's already open connection, the new one gets closed automatically.
+     *
+     * @param socket Incoming debugger WebSocket connection.
+     */
+    onDebuggerConnection(socket: WebSocket): void;
+    /**
+     * Process new WebSocket connection from React Native app (client)
+     * and close any previous connection.
+     *
+     * @param socket Incoming client WebSocket connection.
+     */
+    onClientConnection(socket: WebSocket): void;
+}

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-debugger.server.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketDebuggerServer = void 0;
+const web_socket_server_1 = require("../web-socket-server");
+/**
+ * Class for creating a WebSocket server and providing a bridge between
+ * debugger UI (Remote JS debugger) and the running React Native application.
+ *
+ * React Native application (aka client) will send and receive messages from the debugger UI
+ * which runs inside a browser.
+ *
+ * @category Development server
+ */
+class WebSocketDebuggerServer extends web_socket_server_1.WebSocketServer {
+    /**
+     * A WebSocket connection with the debugger UI.
+     */
+    debuggerSocket;
+    /**
+     * A WebSocket connection with the client (React Native app).
+     */
+    clientSocket;
+    /**
+     * Create new instance of WebSocketDebuggerServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify) {
+        super(fastify, "/debugger-proxy");
+    }
+    /**
+     * Check if debugger UI is connected to the WebSocketDebuggerServer.
+     */
+    isDebuggerConnected() {
+        return Boolean(this.debuggerSocket);
+    }
+    /**
+     * Send a message to a given WebSocket connection.
+     *
+     * @param socket WebSocket connection to send the message to.
+     * @param message Message to send.
+     */
+    send(socket, message) {
+        try {
+            socket?.send(message);
+        }
+        catch (error) {
+            this.fastify.log.warn({ msg: "Failed to send data to socket", error });
+        }
+    }
+    /**
+     * Process new WebSocket connection. The upgrade request should contain `role` query param
+     * for determining the type of the connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     * @param request Upgrade request for the connection.
+     */
+    onConnection(socket, request) {
+        console.log("WebSocketDebuggerServer onConnection");
+        const { url = "" } = request;
+        if (url.indexOf("role=debugger") >= 0) {
+            this.fastify.log.info({ msg: "Remote debugger connected" });
+            this.onDebuggerConnection(socket);
+        }
+        else if (url.indexOf("role=client") >= 0) {
+            this.fastify.log.info({ msg: "React Native app connected to debugger" });
+            this.onClientConnection(socket);
+        }
+        else {
+            socket.close(1011, "Missing role param");
+        }
+    }
+    /**
+     * Process new WebSocket connection from Debugger UI (Remote JS Debugger).
+     * If there's already open connection, the new one gets closed automatically.
+     *
+     * @param socket Incoming debugger WebSocket connection.
+     */
+    onDebuggerConnection(socket) {
+        if (this.debuggerSocket) {
+            socket.close(1011, "Another debugger is already connected");
+            return;
+        }
+        this.debuggerSocket = socket;
+        const onClose = () => {
+            this.fastify.log.info({ msg: "Remote debugger disconnected" });
+            this.debuggerSocket = undefined;
+            if (this.clientSocket) {
+                this.clientSocket.removeAllListeners();
+                this.clientSocket.close(1011, "Debugger was disconnected");
+            }
+        };
+        this.debuggerSocket.addEventListener("error", onClose);
+        this.debuggerSocket.addEventListener("close", onClose);
+        this.debuggerSocket.addEventListener("message", ({ data }) => {
+            this.send(this.clientSocket, data.toString());
+        });
+    }
+    /**
+     * Process new WebSocket connection from React Native app (client)
+     * and close any previous connection.
+     *
+     * @param socket Incoming client WebSocket connection.
+     */
+    onClientConnection(socket) {
+        console.log("WebSocketDebuggerServer onClientConnection");
+        if (this.clientSocket) {
+            this.clientSocket.removeAllListeners();
+            this.clientSocket.close(1011, "Another client is connected");
+            this.clientSocket = undefined;
+        }
+        const onClose = () => {
+            this.fastify.log.info({
+                msg: "React Native app disconnected from debugger",
+            });
+            this.clientSocket = undefined;
+            this.send(this.debuggerSocket, JSON.stringify({ method: "$disconnected" }));
+        };
+        this.clientSocket = socket;
+        this.clientSocket.addEventListener("error", onClose);
+        this.clientSocket.addEventListener("close", onClose);
+        this.clientSocket.addEventListener("message", ({ data }) => {
+            this.send(this.debuggerSocket, data.toString());
+        });
+    }
+}
+exports.WebSocketDebuggerServer = WebSocketDebuggerServer;

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-dev-client.server.d.ts

@@ -0,0 +1,32 @@
+import type { FastifyInstance } from "fastify";
+import type WebSocket from "ws";
+import { WebSocketServer } from "../web-socket-server";
+/**
+ * Class for creating a WebSocket server for communication with React Native clients.
+ * All client logs - logs from React Native application - are processed here.
+ *
+ * @category Development server
+ */
+export declare class WebSocketDevClientServer extends WebSocketServer {
+    private clients;
+    private nextClientId;
+    /**
+     * Create new instance of WebSocketDevClientServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify: FastifyInstance);
+    /**
+     * Process client message.
+     *
+     * @param message Stringified client message.
+     */
+    processMessage(message: string): void;
+    /**
+     * Process new WebSocket connection from client application.
+     *
+     * @param socket Incoming client's WebSocket connection.
+     */
+    onConnection(socket: WebSocket): void;
+}

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-dev-client.server.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketDevClientServer = void 0;
+const web_socket_server_1 = require("../web-socket-server");
+/**
+ * Class for creating a WebSocket server for communication with React Native clients.
+ * All client logs - logs from React Native application - are processed here.
+ *
+ * @category Development server
+ */
+class WebSocketDevClientServer extends web_socket_server_1.WebSocketServer {
+    clients = new Map();
+    nextClientId = 0;
+    /**
+     * Create new instance of WebSocketDevClientServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify) {
+        super(fastify, "/__client");
+    }
+    /**
+     * Process client message.
+     *
+     * @param message Stringified client message.
+     */
+    processMessage(message) {
+        console.log("WebSocketDevClientServer processMessage", message);
+        const { type, ...body } = JSON.parse(message);
+        switch (type) {
+            case "client-log":
+                if (body.level === "error") {
+                    this.fastify.log.error({ issuer: "Console", msg: body.data });
+                }
+                else if (body.level === "warn") {
+                    this.fastify.log.warn({ issuer: "Console", msg: body.data });
+                }
+                else if (body.level === "info" || body.level === "log") {
+                    this.fastify.log.info({ issuer: "Console", msg: body.data });
+                }
+                else {
+                    // body.level === 'debug' || body.level === 'trace'
+                    this.fastify.log.debug({ issuer: "Console", msg: body.data });
+                }
+                break;
+            default:
+                this.fastify.log.warn({ msg: "Unknown client message", message });
+        }
+    }
+    /**
+     * Process new WebSocket connection from client application.
+     *
+     * @param socket Incoming client's WebSocket connection.
+     */
+    onConnection(socket) {
+        const clientId = `client#${this.nextClientId++}`;
+        console.log("WebSocketDevClientServer onConnection", clientId);
+        this.clients.set(clientId, socket);
+        this.fastify.log.debug({ msg: "React Native client connected", clientId });
+        const onClose = () => {
+            this.fastify.log.debug({
+                msg: "React Native client disconnected",
+                clientId,
+            });
+            this.clients.delete(clientId);
+        };
+        socket.addEventListener("error", onClose);
+        socket.addEventListener("close", onClose);
+        socket.addEventListener("message", (event) => {
+            this.processMessage(event.data.toString());
+        });
+    }
+}
+exports.WebSocketDevClientServer = WebSocketDevClientServer;

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-events.server.d.ts

@@ -0,0 +1,75 @@
+import type { FastifyInstance } from "fastify";
+import type WebSocket from "ws";
+import { WebSocketServer } from "../web-socket-server";
+import type { WebSocketMessageServer } from "./web-socket-message.server";
+/**
+ * {@link WebSocketEventsServer} configuration options.
+ */
+export interface WebSocketEventsServerConfig {
+    /** Instance of a {@link WebSocketMessageServer} which can be used for broadcasting. */
+    webSocketMessageServer: WebSocketMessageServer;
+}
+/**
+ * Represents a command that connected clients can send to the {@link WebSocketEventsServer}.
+ */
+export interface Command {
+    version: number;
+    type: "command";
+    command: string;
+    params?: any;
+}
+/**
+ * Represents an event message.
+ */
+export interface EventMessage {
+    error?: Error | string;
+    type?: string;
+    data?: any;
+}
+/**
+ * Class for creating a WebSocket server to process events and reports.
+ *
+ * Based on: https://github.com/react-native-community/cli/blob/v4.14.0/packages/cli-server-api/src/websocket/eventsSocketServer.ts
+ *
+ * @category Development server
+ */
+export declare class WebSocketEventsServer extends WebSocketServer {
+    private config;
+    static readonly PROTOCOL_VERSION = 2;
+    private clients;
+    private nextClientId;
+    /**
+     * Create new instance of WebSocketHMRServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     * @param config Configuration object.
+     */
+    constructor(fastify: FastifyInstance, config: WebSocketEventsServerConfig);
+    /**
+     * Parse received command message from connected client.
+     *
+     * @param data Stringified command message to parse.
+     * @returns Parsed command or `undefined` if parsing failed.
+     */
+    parseMessage(data: string): Command | undefined;
+    /**
+     * Stringify `message` into a format that can be transported as a `string`.
+     *
+     * @param message Message to serialize.
+     * @returns String representation of a `message` or `undefined` if serialization failed.
+     */
+    serializeMessage(message: EventMessage): string | undefined;
+    /**
+     * Broadcast event to all connected clients.
+     *
+     * @param event Event message to broadcast.
+     */
+    broadcastEvent(event: EventMessage): void;
+    /**
+     * Process new client's WebSocket connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     */
+    onConnection(socket: WebSocket): void;
+}

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-events.server.js

@@ -0,0 +1,190 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketEventsServer = void 0;
+const prettyFormat = __importStar(require("pretty-format"));
+const web_socket_server_1 = require("../web-socket-server");
+/**
+ * Class for creating a WebSocket server to process events and reports.
+ *
+ * Based on: https://github.com/react-native-community/cli/blob/v4.14.0/packages/cli-server-api/src/websocket/eventsSocketServer.ts
+ *
+ * @category Development server
+ */
+class WebSocketEventsServer extends web_socket_server_1.WebSocketServer {
+    config;
+    static PROTOCOL_VERSION = 2;
+    clients = new Map();
+    nextClientId = 0;
+    /**
+     * Create new instance of WebSocketHMRServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     * @param config Configuration object.
+     */
+    constructor(fastify, config) {
+        super(fastify, "/events", {
+            verifyClient: (({ origin }) => {
+                return /^(https?:\/\/localhost|file:\/\/)/.test(origin);
+            }),
+        });
+        this.config = config;
+    }
+    /**
+     * Parse received command message from connected client.
+     *
+     * @param data Stringified command message to parse.
+     * @returns Parsed command or `undefined` if parsing failed.
+     */
+    parseMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.version === WebSocketEventsServer.PROTOCOL_VERSION) {
+                return message;
+            }
+            this.fastify.log.error({
+                msg: "Received message had wrong protocol version",
+                message,
+            });
+        }
+        catch {
+            this.fastify.log.error({
+                msg: "Failed to parse the message as JSON",
+                data,
+            });
+        }
+        return undefined;
+    }
+    /**
+     * Stringify `message` into a format that can be transported as a `string`.
+     *
+     * @param message Message to serialize.
+     * @returns String representation of a `message` or `undefined` if serialization failed.
+     */
+    serializeMessage(message) {
+        let toSerialize = message;
+        if (message.error && message.error instanceof Error) {
+            toSerialize = {
+                ...message,
+                error: prettyFormat.default(message.error, {
+                    escapeString: true,
+                    highlight: true,
+                    maxDepth: 3,
+                    min: true,
+                }),
+            };
+        }
+        else if (message && message.type === "client_log") {
+            toSerialize = {
+                ...message,
+                data: message.data.map((item) => typeof item === "string"
+                    ? item
+                    : prettyFormat.default(item, {
+                        escapeString: true,
+                        highlight: true,
+                        maxDepth: 3,
+                        min: true,
+                        plugins: [prettyFormat.plugins.ReactElement],
+                    })),
+            };
+        }
+        try {
+            return JSON.stringify(toSerialize);
+        }
+        catch (error) {
+            this.fastify.log.error({ msg: "Failed to serialize", error });
+            return undefined;
+        }
+    }
+    /**
+     * Broadcast event to all connected clients.
+     *
+     * @param event Event message to broadcast.
+     */
+    broadcastEvent(event) {
+        if (!this.clients.size) {
+            return;
+        }
+        const serialized = this.serializeMessage(event);
+        if (!serialized) {
+            return;
+        }
+        for (const [clientId, socket] of this.clients.entries()) {
+            try {
+                socket.send(serialized);
+            }
+            catch (error) {
+                this.fastify.log.error({
+                    msg: "Failed to send broadcast to client",
+                    clientId,
+                    error,
+                    _skipBroadcast: true,
+                });
+            }
+        }
+    }
+    /**
+     * Process new client's WebSocket connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     */
+    onConnection(socket) {
+        const clientId = `client#${this.nextClientId++}`;
+        this.clients.set(clientId, socket);
+        this.fastify.log.debug({ msg: "Events client connected", clientId });
+        const onClose = () => {
+            this.fastify.log.debug({ msg: "Events client disconnected", clientId });
+            socket.removeAllListeners();
+            this.clients.delete(clientId);
+        };
+        socket.addEventListener("error", onClose);
+        socket.addEventListener("close", onClose);
+        socket.addEventListener("message", (event) => {
+            const message = this.parseMessage(event.data.toString());
+            if (!message) {
+                return;
+            }
+            if (message.type === "command") {
+                try {
+                    this.config.webSocketMessageServer.broadcast(message.command, message.params);
+                }
+                catch (error) {
+                    this.fastify.log.error({
+                        msg: "Failed to forward message to clients",
+                        error,
+                    });
+                }
+            }
+            else {
+                this.fastify.log.error({
+                    msg: "Unknown message type",
+                    message,
+                });
+            }
+        });
+    }
+}
+exports.WebSocketEventsServer = WebSocketEventsServer;

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-hmr.server.d.ts

@@ -0,0 +1,44 @@
+import type { IncomingMessage } from "node:http";
+import type { FastifyInstance } from "fastify";
+import type WebSocket from "ws";
+import { WebSocketServer } from "../web-socket-server";
+import type { ConfigT } from "metro-config";
+import type MetroServer from "metro/src/Server";
+/**
+ * Class for creating a WebSocket server for Hot Module Replacement.
+ *
+ * @category Development server
+ */
+export declare class WebSocketHMRServer extends WebSocketServer {
+    private options;
+    private clients;
+    private nextClientId;
+    private hmrServer;
+    /**
+     * Create new instance of WebSocketHMRServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     * @param delegate HMR delegate instance.
+     */
+    constructor(fastify: FastifyInstance, options: {
+        metroConfig: ConfigT;
+        metroServer: MetroServer;
+        onClientConnected: (platform: string, clientId: string) => void;
+    });
+    /**
+     * Send action to all connected HMR clients.
+     *
+     * @param event Event to send to the clients.
+     * @param platform Platform of clients to send the event to.
+     * @param clientIds Ids of clients who should receive the event.
+     */
+    send(event: any, platform: string, clientIds?: string[]): void;
+    /**
+     * Process new WebSocket connection from HMR client.
+     *
+     * @param socket Incoming HMR client's WebSocket connection.
+     */
+    onConnection(socket: WebSocket, request: IncomingMessage): Promise<void>;
+    registerHMRClient(socket: WebSocket, requestUrl: string): Promise<void>;
+}