@vxrn/vite-native-client 1.27.1 → 2.0.0-beta.45.1

package/dist/cjs/client.native.cjs

@@ -0,0 +1,452 @@
+"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 __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 = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", {
+	value: mod2,
+	enumerable: true
+}) : target, mod2));
+var import_getDevServer = __toESM(require("react-native/Libraries/Core/Devtools/getDevServer"));
+var importMetaUrl = {
+	hostname: "127.0.0.1",
+	protocol: "http",
+	port: 5173
+};
+var serverHost = __SERVER_HOST__;
+var socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws");
+var hmrPort = __HMR_PORT__ || 5173;
+var rnDevServerHost;
+try {
+	var { url: devServerUrl } = (0, import_getDevServer.default)();
+	var [, host] = devServerUrl.match(/:\/\/([^/]+)/) || [];
+	if (host) rnDevServerHost = host;
+} catch (e) {
+	console.warn(`[vite-native-client] failed to get react-native dev server url: ${e}`);
+}
+var hmrHost = rnDevServerHost || `${__HMR_HOSTNAME__ || importMetaUrl.hostname}:${hmrPort || importMetaUrl.port}`;
+var socketHost = `${hmrHost}${__HMR_BASE__}`;
+var directSocketHost = __HMR_DIRECT_TARGET__;
+var base = __BASE__ || "/";
+var messageBuffer = [];
+var socket;
+try {
+	var fallback;
+	if (!hmrPort) {
+		fallback = function() {
+			socket = setupWebSocket(socketProtocol, directSocketHost, function() {
+				console.error(`[vite] failed to connect to websocket.
+your current setup:
+  (browser) ${JSON.stringify(importMetaUrl)} <--[HTTP]--> ${serverHost} (server)
+  (browser) ${socketHost} <--[WebSocket (failing)]--> ${directSocketHost} (server)
+Check out your Vite / network configuration and https://vitejs.dev/config/server-options.html#server-hmr .`);
+			});
+			socket.addEventListener("open", function() {
+				console.info("[vite] Direct websocket connection fallback. Check out https://vitejs.dev/config/server-options.html#server-hmr to remove the previous connection error.");
+			}, { once: true });
+		};
+	}
+	socket = setupWebSocket(socketProtocol, socketHost, fallback);
+} catch (error) {
+	console.error(`[vite] failed to connect to websocket (${error}). `);
+}
+function setupWebSocket(protocol, hostAndPath, onCloseWithoutOpen) {
+	var endpoint = `${protocol}://${hostAndPath}`;
+	if (typeof globalThis.__VITE_WS_TOKEN__ === "string") {
+		endpoint += `?token=${globalThis.__VITE_WS_TOKEN__}`;
+	}
+	var socket1 = new WebSocket(endpoint, "vite-hmr");
+	var isOpened = false;
+	socket1.addEventListener("open", function() {
+		isOpened = true;
+		notifyListeners("vite:ws:connect", { webSocket: socket1 });
+	}, { once: true });
+	socket1.addEventListener("message", function(param2) {
+		var { data } = param2;
+		if (process.env.DEBUG) {
+			console.info(" ❶ hmr ", data);
+		}
+		handleMessage(JSON.parse(data));
+	});
+	socket1.addEventListener("error", function(err) {
+		console.info("err" + err["message"] + err["stack"]);
+	});
+	socket1.addEventListener("close", function(param2) {
+		var { wasClean } = param2;
+		if (wasClean) return;
+		if (!isOpened && onCloseWithoutOpen) {
+			onCloseWithoutOpen();
+			return;
+		}
+		notifyListeners("vite:ws:disconnect", { webSocket: socket1 });
+		console.info(`[vite] server connection lost. polling for restart...`);
+		waitForSuccessfulPing(protocol, hostAndPath).then(function() {
+			console.info("should reload");
+		});
+	});
+	return socket1;
+}
+function warnFailedFetch(err, path2) {
+	try {
+		console.error(`${err.message}
+${err.stack}`);
+	} catch (unused) {
+		console.error(`${err}`);
+	}
+	console.error(`[hmr] Failed to reload ${path2}. This could be due to syntax errors or importing non-existent modules. (see errors above)`);
+}
+var isFirstUpdate = true;
+var debounceReload = function(time) {
+	var timer;
+	return function() {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		timer = setTimeout(function() {
+			globalThis.__vxrnReloadApp();
+		}, time);
+	};
+};
+var pageReload = debounceReload(50);
+async function handleMessage(payload) {
+	switch (payload.type) {
+		case "connected":
+			console.info(`[vite] connected.`);
+			sendMessageBuffer();
+			setInterval(function() {
+				if (socket.readyState === socket.OPEN) {
+					socket.send("{\"type\":\"ping\"}");
+				}
+			}, __HMR_TIMEOUT__);
+			break;
+		case "update":
+			notifyListeners("vite:beforeUpdate", payload);
+			if (isFirstUpdate && hasErrorOverlay()) {
+				globalThis.__vxrnReloadApp();
+				return;
+			}
+			clearErrorOverlay();
+			isFirstUpdate = false;
+			await Promise.all(payload.updates.map(function(update) {
+				if (update.type === "js-update") {
+					return queueUpdate(fetchUpdate(update));
+				}
+			}));
+			notifyListeners("vite:afterUpdate", payload);
+			break;
+		case "custom": {
+			notifyListeners(payload.event, payload.data);
+			break;
+		}
+		case "full-reload":
+			notifyListeners("vite:beforeFullReload", payload);
+			if (payload.path && payload.path.endsWith(".html")) {
+				var pagePath = decodeURI(location.pathname);
+				var payloadPath = base + payload.path.slice(1);
+				if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) {
+					pageReload();
+				}
+				return;
+			}
+			pageReload();
+			break;
+		case "prune":
+			notifyListeners("vite:beforePrune", payload);
+			payload.paths.forEach(function(path2) {
+				var fn = pruneMap.get(path2);
+				if (fn) {
+					fn(dataMap.get(path2));
+				}
+			});
+			break;
+		case "error": {
+			notifyListeners("vite:error", payload);
+			var err = payload.err;
+			if (enableOverlay) {
+				createErrorOverlay(err);
+			} else {
+				console.error(`[vite] Internal Server Error
+${err.message}
+${err.stack}`);
+			}
+			break;
+		}
+		default: {
+			var check = payload;
+			return check;
+		}
+	}
+}
+function notifyListeners(event, data) {
+	var cbs = customListenersMap.get(event);
+	if (cbs) {
+		cbs.forEach(function(cb) {
+			return cb(data);
+		});
+	}
+}
+var enableOverlay = __HMR_ENABLE_OVERLAY__;
+function createErrorOverlay(err) {
+	if (!enableOverlay) return;
+	clearErrorOverlay();
+	console.error("create error", err);
+}
+function clearErrorOverlay() {}
+function hasErrorOverlay() {
+	return false;
+}
+var pending = false;
+var queued = [];
+async function queueUpdate(p) {
+	queued.push(p);
+	if (!pending) {
+		pending = true;
+		await Promise.resolve();
+		pending = false;
+		var loading = [...queued];
+		queued = [];
+		(await Promise.all(loading)).forEach(function(fn) {
+			return fn && fn();
+		});
+	}
+}
+async function waitForSuccessfulPing(socketProtocol1, hostAndPath) {
+	var ms = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1e3;
+	var pingHostProtocol = socketProtocol1 === "wss" ? "https" : "http";
+	var ping = async function() {
+		try {
+			await fetch(`${pingHostProtocol}://${hostAndPath}`, {
+				mode: "no-cors",
+				headers: { Accept: "text/x-vite-ping" }
+			});
+			return true;
+		} catch (unused) {}
+		return false;
+	};
+	if (await ping()) {
+		return;
+	}
+	await wait(ms);
+	while (true) {
+		if (await ping()) {
+			break;
+		}
+		await wait(ms);
+	}
+}
+function wait(ms) {
+	return new Promise(function(resolve) {
+		return setTimeout(resolve, ms);
+	});
+}
+async function fetchUpdate(param) {
+	var { path: pathIn, acceptedPath: acceptedPathIn, timestamp, explicitImportRequired } = param;
+	var path = pathIn.replace("/@id", "");
+	var acceptedPath = acceptedPathIn.replace("/@id", "");
+	var mod = hotModulesMap.get(path);
+	if (!mod) {
+		console.info(` \u2776 hmr - No module found`);
+		console.info(`    looked for ${path} in:`);
+		hotModulesMap.forEach(function(value, key) {
+			console.info(`   - ${key}`);
+		});
+		return;
+	}
+	var fetchedModule;
+	var isSelfUpdate = path === acceptedPath;
+	var qualifiedCallbacks = mod.callbacks.filter(function(param2) {
+		var { deps } = param2;
+		return deps.includes(acceptedPath);
+	});
+	if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+		var disposer = disposeMap.get(acceptedPath);
+		if (disposer) await disposer(dataMap.get(acceptedPath));
+		var [acceptedPathWithoutQuery, query] = acceptedPath.split(`?`);
+		try {
+			var filePath = acceptedPathWithoutQuery;
+			var finalQuery = `file?file=${encodeURIComponent(filePath)}&${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`;
+			var scriptUrl = `http://${rnDevServerHost ? rnDevServerHost + "/" : serverHost.replace("5173", "8081")}` + finalQuery;
+			console.info(` \u2776 hmr fetching update: ${scriptUrl}`);
+			var source = await fetch(scriptUrl).then(function(res) {
+				return res.text();
+			});
+			var evaluatedModule = eval(source);
+			fetchedModule = evaluatedModule;
+		} catch (e) {
+			warnFailedFetch(e, acceptedPath);
+		}
+	} else {
+		console.info(` \u2776 hmr can't accept - isSelfUpdate ${isSelfUpdate} - callbacks: ${JSON.stringify(mod.callbacks)} - acceptedPath: ${acceptedPath}`);
+	}
+	return function() {
+		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+		try {
+			for (var _iterator = qualifiedCallbacks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+				var { deps, fn } = _step.value;
+				fn(deps.map(function(dep) {
+					return dep === acceptedPath ? fetchedModule : void 0;
+				}));
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+		var loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+		if (process.env.DEBUG) {
+			console.info(`[vite] hot updated: ${loggedPath}`);
+		}
+	};
+}
+function sendMessageBuffer() {
+	if (socket.readyState === 1) {
+		messageBuffer.forEach(function(msg) {
+			return socket.send(msg);
+		});
+		messageBuffer.length = 0;
+	}
+}
+var hotModulesMap = /* @__PURE__ */ new Map();
+var disposeMap = /* @__PURE__ */ new Map();
+var pruneMap = /* @__PURE__ */ new Map();
+var dataMap = /* @__PURE__ */ new Map();
+var customListenersMap = /* @__PURE__ */ new Map();
+var ctxToListenersMap = /* @__PURE__ */ new Map();
+globalThis["createHotContext"] = function createHotContext(ownerPath) {
+	if (!dataMap.has(ownerPath)) {
+		dataMap.set(ownerPath, {});
+	}
+	var mod2 = hotModulesMap.get(ownerPath);
+	if (mod2) {
+		mod2.callbacks = [];
+	}
+	var staleListeners = ctxToListenersMap.get(ownerPath);
+	if (staleListeners) {
+		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+		try {
+			var _loop = function() {
+				var [event, staleFns] = _step.value;
+				var listeners = customListenersMap.get(event);
+				if (listeners) {
+					customListenersMap.set(event, listeners.filter(function(l) {
+						return !staleFns.includes(l);
+					}));
+				}
+			};
+			for (var _iterator = staleListeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+	}
+	var newListeners = /* @__PURE__ */ new Map();
+	ctxToListenersMap.set(ownerPath, newListeners);
+	function acceptDeps(deps) {
+		var callback = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {};
+		var mod3 = hotModulesMap.get(ownerPath) || {
+			id: ownerPath,
+			callbacks: []
+		};
+		mod3.callbacks.push({
+			deps,
+			fn: callback
+		});
+		hotModulesMap.set(ownerPath, mod3);
+	}
+	var hot = {
+		get data() {
+			return dataMap.get(ownerPath);
+		},
+		accept(deps, callback) {
+			if (typeof deps === "function" || !deps) {
+				acceptDeps([ownerPath], function(param2) {
+					var [mod3] = param2;
+					return deps === null || deps === void 0 ? void 0 : deps(mod3);
+				});
+			} else if (typeof deps === "string") {
+				acceptDeps([deps], function(param2) {
+					var [mod3] = param2;
+					return callback === null || callback === void 0 ? void 0 : callback(mod3);
+				});
+			} else if (Array.isArray(deps)) {
+				acceptDeps(deps, callback);
+			} else {
+				throw new Error(`invalid hot.accept() usage.`);
+			}
+		},
+		acceptExports(_, callback) {
+			acceptDeps([ownerPath], function(param2) {
+				var [mod3] = param2;
+				return callback === null || callback === void 0 ? void 0 : callback(mod3);
+			});
+		},
+		dispose(cb) {
+			disposeMap.set(ownerPath, cb);
+		},
+		prune(cb) {
+			pruneMap.set(ownerPath, cb);
+		},
+		decline() {},
+		invalidate(message) {
+			notifyListeners("vite:invalidate", {
+				path: ownerPath,
+				message
+			});
+			this.send("vite:invalidate", {
+				path: ownerPath,
+				message
+			});
+			console.info(`[vite] invalidate ${ownerPath}${message ? `: ${message}` : ""}`);
+		},
+		on(event, cb) {
+			var addToMap = function(map) {
+				var existing = map.get(event) || [];
+				existing.push(cb);
+				map.set(event, existing);
+			};
+			addToMap(customListenersMap);
+			addToMap(newListeners);
+		},
+		send(event, data) {
+			messageBuffer.push(JSON.stringify({
+				type: "custom",
+				event,
+				data
+			}));
+			sendMessageBuffer();
+		}
+	};
+	return hot;
+};