@vxrn/vite-native-client 1.1.320 → 1.1.321

package/dist/cjs/client.js

@@ -0,0 +1,312 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: !0 }) : target,
+  mod2
+));
+var import_getDevServer = __toESM(require("react-native/Libraries/Core/Devtools/getDevServer"));
+const importMetaUrl = {
+  hostname: "127.0.0.1",
+  protocol: "http",
+  port: 5173
+}, serverHost = __SERVER_HOST__, socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws"), hmrPort = __HMR_PORT__ || 5173;
+let rnDevServerHost;
+try {
+  const { url: devServerUrl } = (0, import_getDevServer.default)(), [, host] = devServerUrl.match(/:\/\/([^\/]+)/) || [];
+  host && (rnDevServerHost = host);
+} catch (e) {
+  console.warn(`[vite-native-client] failed to get react-native dev server url: ${e}`);
+}
+const hmrHost = rnDevServerHost || `${__HMR_HOSTNAME__ || importMetaUrl.hostname}:${hmrPort || importMetaUrl.port}`, socketHost = `${hmrHost}${__HMR_BASE__}`, directSocketHost = __HMR_DIRECT_TARGET__, base = __BASE__ || "/", messageBuffer = [];
+let socket;
+try {
+  let fallback;
+  hmrPort || (fallback = () => {
+    socket = setupWebSocket(socketProtocol, directSocketHost, () => {
+      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",
+      () => {
+        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: !0 }
+    );
+  }), socket = setupWebSocket(socketProtocol, socketHost, fallback);
+} catch (error) {
+  console.error(`[vite] failed to connect to websocket (${error}). `);
+}
+function setupWebSocket(protocol, hostAndPath, onCloseWithoutOpen) {
+  const endpoint = `${protocol}://${hostAndPath}`, socket2 = new WebSocket(endpoint, "vite-hmr");
+  let isOpened = !1;
+  return socket2.addEventListener(
+    "open",
+    () => {
+      isOpened = !0, notifyListeners("vite:ws:connect", { webSocket: socket2 });
+    },
+    { once: !0 }
+  ), socket2.addEventListener("message", ({ data }) => {
+    console.info(" \u2776 hmr ", data), handleMessage(JSON.parse(data));
+  }), socket2.addEventListener("error", (err) => {
+    console.info("err" + err.message + err.stack);
+  }), socket2.addEventListener("close", ({ wasClean }) => {
+    if (!wasClean) {
+      if (!isOpened && onCloseWithoutOpen) {
+        onCloseWithoutOpen();
+        return;
+      }
+      notifyListeners("vite:ws:disconnect", { webSocket: socket2 }), console.info("[vite] server connection lost. polling for restart..."), waitForSuccessfulPing(protocol, hostAndPath).then(() => {
+        console.info("should reload");
+      });
+    }
+  }), socket2;
+}
+function warnFailedFetch(err, path2) {
+  try {
+    console.error(`${err.message}
+${err.stack}`);
+  } catch {
+    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)`
+  );
+}
+let isFirstUpdate = !0;
+const debounceReload = (time) => {
+  let timer;
+  return () => {
+    timer && (clearTimeout(timer), timer = null), timer = setTimeout(() => {
+      globalThis.__vxrnReloadApp();
+    }, time);
+  };
+}, pageReload = debounceReload(50);
+async function handleMessage(payload) {
+  switch (payload.type) {
+    case "connected":
+      console.info("[vite] connected."), sendMessageBuffer(), setInterval(() => {
+        socket.readyState === socket.OPEN && socket.send('{"type":"ping"}');
+      }, __HMR_TIMEOUT__);
+      break;
+    case "update":
+      if (notifyListeners("vite:beforeUpdate", payload), isFirstUpdate && hasErrorOverlay()) {
+        globalThis.__vxrnReloadApp();
+        return;
+      }
+      isFirstUpdate = !1, await Promise.all(
+        payload.updates.map((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":
+      if (notifyListeners("vite:beforeFullReload", payload), payload.path && payload.path.endsWith(".html")) {
+        const pagePath = decodeURI(location.pathname), payloadPath = base + payload.path.slice(1);
+        (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((path2) => {
+        const fn = pruneMap.get(path2);
+        fn && fn(dataMap.get(path2));
+      });
+      break;
+    case "error": {
+      notifyListeners("vite:error", payload);
+      const err = payload.err;
+      enableOverlay ? createErrorOverlay(err) : console.error(`[vite] Internal Server Error
+${err.message}
+${err.stack}`);
+      break;
+    }
+    default:
+      return payload;
+  }
+}
+function notifyListeners(event, data) {
+  const cbs = customListenersMap.get(event);
+  cbs && cbs.forEach((cb) => cb(data));
+}
+const enableOverlay = __HMR_ENABLE_OVERLAY__;
+function createErrorOverlay(err) {
+  enableOverlay && console.error("create error", err);
+}
+function clearErrorOverlay() {
+}
+function hasErrorOverlay() {
+  return !1;
+}
+let pending = !1, queued = [];
+async function queueUpdate(p) {
+  if (queued.push(p), !pending) {
+    pending = !0, await Promise.resolve(), pending = !1;
+    const loading = [...queued];
+    queued = [], (await Promise.all(loading)).forEach((fn) => fn && fn());
+  }
+}
+async function waitForSuccessfulPing(socketProtocol2, hostAndPath, ms = 1e3) {
+  const pingHostProtocol = socketProtocol2 === "wss" ? "https" : "http", ping = async () => {
+    try {
+      return await fetch(`${pingHostProtocol}://${hostAndPath}`, {
+        mode: "no-cors",
+        headers: {
+          // Custom headers won't be included in a request with no-cors so (ab)use one of the
+          // safelisted headers to identify the ping request
+          Accept: "text/x-vite-ping"
+        }
+      }), !0;
+    } catch {
+    }
+    return !1;
+  };
+  if (!await ping())
+    for (await wait(ms); !await ping(); )
+      await wait(ms);
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchUpdate({
+  path: pathIn,
+  acceptedPath: acceptedPathIn,
+  timestamp,
+  explicitImportRequired
+}) {
+  const path = pathIn.replace("/@id", ""), acceptedPath = acceptedPathIn.replace("/@id", ""), mod = hotModulesMap.get(path);
+  if (!mod) {
+    console.info(" \u2776 hmr - No module found");
+    return;
+  }
+  let fetchedModule;
+  const isSelfUpdate = path === acceptedPath, qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
+  if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+    const disposer = disposeMap.get(acceptedPath);
+    disposer && await disposer(dataMap.get(acceptedPath));
+    const [acceptedPathWithoutQuery, query] = acceptedPath.split("?");
+    try {
+      const filePath = acceptedPathWithoutQuery, finalQuery = `file?file=${encodeURIComponent(filePath)}&${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`, scriptUrl = (
+        // re-route to our cjs endpoint
+        `http://${rnDevServerHost ? rnDevServerHost + "/" : serverHost.replace("5173", "8081")}` + finalQuery
+      );
+      console.info(` \u2776 hmr fetching update: ${scriptUrl}`);
+      const source = await fetch(scriptUrl).then((res) => res.text()), 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 () => {
+    for (const { deps, fn } of qualifiedCallbacks)
+      fn(deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0));
+    const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+    process.env.DEBUG && console.info(`[vite] hot updated: ${loggedPath}`);
+  };
+}
+function sendMessageBuffer() {
+  socket.readyState === 1 && (messageBuffer.forEach((msg) => socket.send(msg)), messageBuffer.length = 0);
+}
+const hotModulesMap = /* @__PURE__ */ new Map(), disposeMap = /* @__PURE__ */ new Map(), pruneMap = /* @__PURE__ */ new Map(), dataMap = /* @__PURE__ */ new Map(), customListenersMap = /* @__PURE__ */ new Map(), ctxToListenersMap = /* @__PURE__ */ new Map();
+globalThis.createHotContext = function createHotContext(ownerPath) {
+  dataMap.has(ownerPath) || dataMap.set(ownerPath, {});
+  const mod2 = hotModulesMap.get(ownerPath);
+  mod2 && (mod2.callbacks = []);
+  const staleListeners = ctxToListenersMap.get(ownerPath);
+  if (staleListeners)
+    for (const [event, staleFns] of staleListeners) {
+      const listeners = customListenersMap.get(event);
+      listeners && customListenersMap.set(
+        event,
+        listeners.filter((l) => !staleFns.includes(l))
+      );
+    }
+  const newListeners = /* @__PURE__ */ new Map();
+  ctxToListenersMap.set(ownerPath, newListeners);
+  function acceptDeps(deps, callback = () => {
+  }) {
+    const mod3 = hotModulesMap.get(ownerPath) || {
+      id: ownerPath,
+      callbacks: []
+    };
+    mod3.callbacks.push({
+      deps,
+      fn: callback
+    }), console.info(` \u2776 hmr - setting ${ownerPath}`), hotModulesMap.set(ownerPath, mod3);
+  }
+  return {
+    get data() {
+      return dataMap.get(ownerPath);
+    },
+    accept(deps, callback) {
+      if (typeof deps == "function" || !deps)
+        acceptDeps([ownerPath], ([mod3]) => deps?.(mod3));
+      else if (typeof deps == "string")
+        acceptDeps([deps], ([mod3]) => callback?.(mod3));
+      else if (Array.isArray(deps))
+        acceptDeps(deps, callback);
+      else
+        throw new Error("invalid hot.accept() usage.");
+    },
+    // export names (first arg) are irrelevant on the client side, they're
+    // extracted in the server for propagation
+    acceptExports(_, callback) {
+      acceptDeps([ownerPath], ([mod3]) => callback?.(mod3));
+    },
+    dispose(cb) {
+      disposeMap.set(ownerPath, cb);
+    },
+    prune(cb) {
+      pruneMap.set(ownerPath, cb);
+    },
+    // Kept for backward compatibility (#11036)
+    // @ts-expect-error untyped
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    decline() {
+    },
+    // tell the server to re-perform hmr propagation from this module as root
+    invalidate(message) {
+      notifyListeners("vite:invalidate", { path: ownerPath, message }), this.send("vite:invalidate", { path: ownerPath, message }), console.info(`[vite] invalidate ${ownerPath}${message ? `: ${message}` : ""}`);
+    },
+    // custom events
+    on(event, cb) {
+      const addToMap = (map) => {
+        const 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();
+    }
+  };
+};
+//# sourceMappingURL=client.js.map

package/dist/cjs/customEvent.js

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var customEvent_exports = {};
+module.exports = __toCommonJS(customEvent_exports);
+//# sourceMappingURL=customEvent.js.map

package/dist/cjs/hmrPayload.js

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var hmrPayload_exports = {};
+module.exports = __toCommonJS(hmrPayload_exports);
+//# sourceMappingURL=hmrPayload.js.map

package/dist/cjs/hot.js

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var hot_exports = {};
+module.exports = __toCommonJS(hot_exports);
+//# sourceMappingURL=hot.js.map

package/dist/cjs/index.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+}, __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./client"), module.exports);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vxrn/vite-native-client",
-  "version": "1.1.320",
+  "version": "1.1.321",
   "types": "./types/index.d.ts",
   "main": "dist/cjs",
   "module": "dist/esm",
@@ -28,7 +28,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^1.8.3",
-    "@tamagui/build": "^1.115.0",
+    "@tamagui/build": "^1.116.4",
     "react-native": "0.74.5"
   },
   "peerDependencies": {