@teardown/cli 1.2.33 → 1.2.35

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.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.js

@@ -0,0 +1,198 @@
+"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, clientId) {
+        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,
+                clientId,
+            });
+        }
+        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) {
+            console.log("Failed to serialize event");
+            return;
+        }
+        for (const [clientId, socket] of this.clients.entries()) {
+            try {
+                const clientMessage = this.serializeMessage(event, clientId);
+                if (!clientMessage) {
+                    continue;
+                }
+                socket.send(clientMessage);
+            }
+            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.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHMRServer = void 0;
+const node_url_1 = require("node:url");
+const web_socket_server_1 = require("../web-socket-server");
+// @ts-ignore
+const HmrServer_1 = __importDefault(require("metro/src/HmrServer"));
+/**
+ * Class for creating a WebSocket server for Hot Module Replacement.
+ *
+ * @category Development server
+ */
+class WebSocketHMRServer extends web_socket_server_1.WebSocketServer {
+    options;
+    clients = new Map();
+    nextClientId = 0;
+    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, options) {
+        super(fastify, "/hot");
+        this.options = options;
+        this.hmrServer = new HmrServer_1.default(this.options.metroServer.getBundler(), this.options.metroServer.getCreateModuleId(), this.options.metroConfig);
+    }
+    /**
+     * 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, platform, clientIds) {
+        const data = typeof event === "string" ? event : JSON.stringify(event);
+        for (const [key, socket] of this.clients) {
+            if (key.platform !== platform ||
+                !(clientIds ?? [key.clientId]).includes(key.clientId)) {
+                continue;
+            }
+            try {
+                socket.send(data);
+            }
+            catch (error) {
+                this.fastify.log.error({
+                    msg: "Cannot send action to client",
+                    event,
+                    error,
+                    ...key,
+                });
+            }
+        }
+    }
+    /**
+     * Process new WebSocket connection from HMR client.
+     *
+     * @param socket Incoming HMR client's WebSocket connection.
+     */
+    async onConnection(socket, request) {
+        const requestUrl = request.url || "";
+        const { searchParams } = new node_url_1.URL(requestUrl, "http://localhost");
+        const platform = searchParams.get("platform") ?? "unknown";
+        if (!platform) {
+            this.fastify.log.debug({
+                msg: "HMR connection disconnected - missing platform",
+            });
+            socket.close();
+            return;
+        }
+        const clientId = `client#${this.nextClientId++}`;
+        const client = {
+            clientId,
+            platform,
+        };
+        this.clients.set(client, socket);
+        this.fastify.log.debug({ msg: "HMR client connected", ...client });
+        const onClose = () => {
+            this.fastify.log.debug({
+                msg: "HMR client disconnected",
+                ...client,
+            });
+            this.clients.delete(client);
+        };
+        socket.addEventListener("error", onClose);
+        socket.addEventListener("close", onClose);
+        await this.registerHMRClient(socket, requestUrl);
+        this.options.onClientConnected(platform, clientId);
+    }
+    async registerHMRClient(socket, requestUrl) {
+        const sendFn = (...args) => {
+            // @ts-ignore
+            socket.send(...args);
+        };
+        const hmrClient = await this.hmrServer.onClientConnect(requestUrl, sendFn);
+        socket.on("error", (error) => {
+            this.fastify.log.error({
+                msg: "HMR client error",
+                error,
+            });
+            this.hmrServer.onClientError(hmrClient, error);
+        });
+        socket.on("close", () => {
+            this.fastify.log.debug({
+                msg: "HMR client disconnected",
+                ...hmrClient,
+            });
+            this.hmrServer.onClientDisconnect(hmrClient);
+        });
+        socket.on("message", (data) => {
+            this.hmrServer.onClientMessage(hmrClient, data, sendFn);
+        });
+    }
+}
+exports.WebSocketHMRServer = WebSocketHMRServer;