@vxrn/vite-plugin-metro 2.0.0-beta.33.1 → 2.0.0-beta.46.1

package/dist/cjs/plugins/metroPlugin.native.cjs

@@ -0,0 +1,242 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var metroPlugin_exports = {};
+__export(metroPlugin_exports, { metroPlugin: () => metroPlugin });
+module.exports = __toCommonJS(metroPlugin_exports);
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_launch_editor = __toESM(require("launch-editor"), 1);
+var import_debug = require("@vxrn/debug");
+var import_utils = require("@vxrn/utils");
+var import_metroCacheManager = require("../utils/metroCacheManager.native.js");
+var import_projectImport = require("../utils/projectImport.native.js");
+var import_getMetroConfigFromViteConfig = require("../metro-config/getMetroConfigFromViteConfig.native.js");
+var import_patchMetroServerWithViteConfigAndMetroPluginOptions = require("../metro-config/patchMetroServerWithViteConfigAndMetroPluginOptions.native.js");
+var { debug } = (0, import_debug.createDebugger)("vite-plugin-metro");
+function metroPlugin() {
+	var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+	globalThis["__viteMetroPluginOptions__"] = options;
+	return {
+		name: "metro",
+		configureServer(server) {
+			var projectRoot = (0, import_path.resolve)(server.config.root);
+			var shouldLetViteServe = function(url) {
+				if (!url) return false;
+				var pathname = "";
+				try {
+					pathname = new URL(url, "http://localhost").pathname;
+				} catch (unused) {
+					var _url_split_;
+					pathname = (_url_split_ = url.split("?")[0]) !== null && _url_split_ !== void 0 ? _url_split_ : "";
+				}
+				if (!pathname.startsWith("/assets/")) return false;
+				if (pathname.endsWith("_vxrn_loader.js")) return true;
+				var decodedPathname = pathname;
+				try {
+					decodedPathname = decodeURIComponent(pathname);
+				} catch (unused) {}
+				var filePath = (0, import_path.resolve)(projectRoot, decodedPathname.slice(1));
+				var relativePath = (0, import_path.relative)(projectRoot, filePath);
+				var isInsideRoot = relativePath !== "" && !relativePath.startsWith("..") && !(0, import_path.isAbsolute)(relativePath);
+				return isInsideRoot && (0, import_fs.existsSync)(filePath);
+			};
+			var metroReady = false;
+			var middleware;
+			var metroServer;
+			var hmrServer;
+			var websocketEndpoints;
+			var rnDevtoolsMiddleware;
+			var metroPromise;
+			var metroPromiseResolvers;
+			metroPromise = new Promise(function(resolve2, reject) {
+				metroPromiseResolvers = {
+					resolve: resolve2,
+					reject
+				};
+			});
+			var startMetro = async function() {
+				var metroStartTime = Date.now();
+				try {
+					var _server_httpServer;
+					(0, import_metroCacheManager.checkAndClearMetroCacheFromVite)(server, server.config.logger);
+					var { default: Metro } = await (0, import_projectImport.projectImport)(projectRoot, "metro");
+					var { default: MetroHmrServer } = await (0, import_projectImport.projectImport)(projectRoot, "metro/private/HmrServer");
+					var { default: createWebsocketServer } = await (0, import_projectImport.projectImport)(projectRoot, "metro/private/lib/createWebsocketServer");
+					var { createDevMiddleware } = await (0, import_projectImport.projectImport)(projectRoot, "@react-native/dev-middleware");
+					var config = await (0, import_getMetroConfigFromViteConfig.getMetroConfigFromViteConfig)(server.config, options);
+					var metroResult = await Metro.createConnectMiddleware(config, { watch: true });
+					middleware = metroResult.middleware;
+					metroServer = metroResult.metroServer;
+					(0, import_patchMetroServerWithViteConfigAndMetroPluginOptions.patchMetroServerWithViteConfigAndMetroPluginOptions)(metroServer, server.config, options);
+					hmrServer = new MetroHmrServer(metroServer.getBundler(), metroServer.getCreateModuleId(), config);
+					var reactNativeDevToolsUrl = `http://${typeof server.config.server.host === "boolean" ? "localhost" : server.config.server.host}:${server.config.server.port}`;
+					var devMiddleware = createDevMiddleware({
+						serverBaseUrl: reactNativeDevToolsUrl,
+						logger: console,
+						unstable_experiments: { enableStandaloneFuseboxShell: process.env.NODE_ENV !== "test" }
+					});
+					rnDevtoolsMiddleware = devMiddleware.middleware;
+					websocketEndpoints = {
+						"/hot": createWebsocketServer({ websocketServer: hmrServer }),
+						"/message": (0, import_utils.createMessageSocket)(),
+						...devMiddleware.websocketEndpoints
+					};
+					(_server_httpServer = server.httpServer) === null || _server_httpServer === void 0 ? void 0 : _server_httpServer.on("upgrade", function(request, socket, head) {
+						var pathname = new URL(request.url, `http://${request.headers.host}`).pathname;
+						var endpoint = websocketEndpoints[pathname];
+						if (endpoint) {
+							endpoint.handleUpgrade(request, socket, head, function(ws) {
+								endpoint.emit("connection", ws, request);
+							});
+						}
+					});
+					server.middlewares.use(rnDevtoolsMiddleware);
+					metroReady = true;
+					var metroElapsed = Date.now() - metroStartTime;
+					debug === null || debug === void 0 ? void 0 : debug(`Metro bundler ready (${metroElapsed}ms)`);
+					metroPromiseResolvers.resolve();
+				} catch (err) {
+					debug === null || debug === void 0 ? void 0 : debug(`Error during Metro initialization: ${err}`);
+					metroPromiseResolvers.reject(err);
+					throw err;
+				}
+			};
+			var isLazyStartup = options.startup === "lazy";
+			var metroStarting = false;
+			var ensureMetroStarted = function() {
+				if (metroStarting || metroReady) return;
+				metroStarting = true;
+				debug === null || debug === void 0 ? void 0 : debug("Starting Metro on-demand (lazy startup)");
+				startMetro().catch(function(err) {
+					debug === null || debug === void 0 ? void 0 : debug(`Failed to start Metro: ${err}`);
+				});
+			};
+			if (!isLazyStartup) {
+				if (server.httpServer) {
+					if (server.httpServer.listening) {
+						startMetro().catch(function(err) {
+							debug === null || debug === void 0 ? void 0 : debug(`Failed to start Metro: ${err}`);
+						});
+					} else {
+						server.httpServer.on("listening", function() {
+							startMetro().catch(function(err) {
+								debug === null || debug === void 0 ? void 0 : debug(`Failed to start Metro: ${err}`);
+							});
+						});
+					}
+				} else {
+					var waitForServer = function() {
+						if (server.httpServer) {
+							if (server.httpServer.listening) {
+								startMetro().catch(function(err) {
+									debug === null || debug === void 0 ? void 0 : debug(`Failed to start Metro: ${err}`);
+								});
+							} else {
+								server.httpServer.on("listening", function() {
+									startMetro().catch(function(err) {
+										debug === null || debug === void 0 ? void 0 : debug(`Failed to start Metro: ${err}`);
+									});
+								});
+							}
+						} else {
+							setTimeout(waitForServer, 10);
+						}
+					};
+					waitForServer();
+				}
+			} else {
+				debug === null || debug === void 0 ? void 0 : debug("Metro lazy startup enabled - will start on first native request");
+			}
+			server.middlewares.use(async function(req, res, next) {
+				var _req_headers_useragent, _req_headers_useragent1, _req_url;
+				var isNativeRequest = ((_req_headers_useragent = req.headers["user-agent"]) === null || _req_headers_useragent === void 0 ? void 0 : _req_headers_useragent.includes("CFNetwork/")) || ((_req_headers_useragent1 = req.headers["user-agent"]) === null || _req_headers_useragent1 === void 0 ? void 0 : _req_headers_useragent1.includes("okhttp/"));
+				if (isLazyStartup && !metroReady) {
+					var _req_url1;
+					if (((_req_url1 = req.url) === null || _req_url1 === void 0 ? void 0 : _req_url1.includes(".bundle")) || req.url === "/status" && isNativeRequest) {
+						ensureMetroStarted();
+					}
+				}
+				if (req.url === "/status" && isNativeRequest) {
+					res.statusCode = 200;
+					res.end("packager-status:running");
+					return;
+				}
+				if (((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes(".bundle")) && !metroReady) {
+					await metroPromise;
+				}
+				if (middleware) {
+					if (shouldLetViteServe(req.url)) {
+						return next();
+					}
+					try {
+						var _req_url2;
+						if ((_req_url2 = req.url) === null || _req_url2 === void 0 ? void 0 : _req_url2.includes(".bundle")) {
+							var VITE_METRO_DEBUG_BUNDLE = process.env.VITE_METRO_DEBUG_BUNDLE;
+							if (VITE_METRO_DEBUG_BUNDLE) {
+								if ((0, import_fs.existsSync)(VITE_METRO_DEBUG_BUNDLE)) {
+									debug === null || debug === void 0 ? void 0 : debug(`serving debug bundle from ${VITE_METRO_DEBUG_BUNDLE}`);
+									var content = await (0, import_promises.readFile)(VITE_METRO_DEBUG_BUNDLE, "utf-8");
+									res.setHeader("Content-Type", "application/javascript");
+									res.end(content);
+									return;
+								}
+							}
+						}
+						if (req.url === "/open-stack-frame" && req.method === "POST") {
+							var body = "";
+							req.on("data", function(chunk) {
+								body += chunk.toString();
+							});
+							req.on("end", function() {
+								try {
+									var frame = JSON.parse(body);
+									(0, import_launch_editor.default)(frame.file);
+									res.statusCode = 200;
+									res.end("Stack frame opened in editor");
+								} catch (e) {
+									debug === null || debug === void 0 ? void 0 : debug(`Failed to parse stack frame: ${e}`);
+									res.statusCode = 400;
+									return res.end("Invalid stack frame JSON");
+								}
+							});
+							return;
+						}
+						await middleware(req, res, next);
+					} catch (error) {
+						debug === null || debug === void 0 ? void 0 : debug(`Metro middleware error: ${error}`);
+						next();
+					}
+				} else {
+					next();
+				}
+			});
+		}
+	};
+}