@vxrn/vite-native-client 1.25.4 → 1.25.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vxrn/vite-native-client",
-  "version": "1.25.4",
+  "version": "1.25.5",
   "sideEffects": [
     "*"
   ],

package/dist/cjs/client.cjs

@@ -1,429 +0,0 @@
-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(
-// 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: true
-}) : target, mod2));
-var import_getDevServer = __toESM(require("react-native/Libraries/Core/Devtools/getDevServer"));
-const importMetaUrl = {
-  hostname: "127.0.0.1",
-  protocol: "http",
-  port: 5173
-};
-const serverHost = __SERVER_HOST__;
-const socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws");
-const hmrPort = __HMR_PORT__ || 5173;
-let rnDevServerHost;
-try {
-  const {
-    url: devServerUrl
-  } = (0, import_getDevServer.default)();
-  const [, host] = devServerUrl.match(/:\/\/([^/]+)/) || [];
-  if (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}`;
-const socketHost = `${hmrHost}${__HMR_BASE__}`;
-const directSocketHost = __HMR_DIRECT_TARGET__;
-const base = __BASE__ || "/";
-const messageBuffer = [];
-let socket;
-try {
-  let fallback;
-  if (!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: true
-      });
-    };
-  }
-  socket = setupWebSocket(socketProtocol, socketHost, fallback);
-} catch (error) {
-  console.error(`[vite] failed to connect to websocket (${error}). `);
-}
-function setupWebSocket(protocol, hostAndPath, onCloseWithoutOpen) {
-  let endpoint = `${protocol}://${hostAndPath}`;
-  if (typeof globalThis.__VITE_WS_TOKEN__ === "string") {
-    endpoint += `?token=${globalThis.__VITE_WS_TOKEN__}`;
-  }
-  const socket2 = new WebSocket(endpoint, "vite-hmr");
-  let isOpened = false;
-  socket2.addEventListener("open", () => {
-    isOpened = true;
-    notifyListeners("vite:ws:connect", {
-      webSocket: socket2
-    });
-  }, {
-    once: true
-  });
-  socket2.addEventListener("message", ({
-    data
-  }) => {
-    if (process.env.DEBUG) {
-      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) return;
-    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");
-    });
-  });
-  return 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 = true;
-const debounceReload = time => {
-  let timer;
-  return () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-    timer = setTimeout(() => {
-      globalThis.__vxrnReloadApp();
-    }, time);
-  };
-};
-const pageReload = debounceReload(50);
-async function handleMessage(payload) {
-  switch (payload.type) {
-    case "connected":
-      console.info(`[vite] connected.`);
-      sendMessageBuffer();
-      setInterval(() => {
-        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(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")) {
-        const pagePath = decodeURI(location.pathname);
-        const 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(path2 => {
-        const fn = pruneMap.get(path2);
-        if (fn) {
-          fn(dataMap.get(path2));
-        }
-      });
-      break;
-    case "error":
-      {
-        notifyListeners("vite:error", payload);
-        const err = payload.err;
-        if (enableOverlay) {
-          createErrorOverlay(err);
-        } else {
-          console.error(`[vite] Internal Server Error
-${err.message}
-${err.stack}`);
-        }
-        break;
-      }
-    default:
-      {
-        const check = payload;
-        return check;
-      }
-  }
-}
-function notifyListeners(event, data) {
-  const cbs = customListenersMap.get(event);
-  if (cbs) {
-    cbs.forEach(cb => cb(data));
-  }
-}
-const enableOverlay = __HMR_ENABLE_OVERLAY__;
-function createErrorOverlay(err) {
-  if (!enableOverlay) return;
-  clearErrorOverlay();
-  console.error("create error", err);
-}
-function clearErrorOverlay() {}
-function hasErrorOverlay() {
-  return false;
-}
-let pending = false;
-let queued = [];
-async function queueUpdate(p) {
-  queued.push(p);
-  if (!pending) {
-    pending = true;
-    await Promise.resolve();
-    pending = false;
-    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";
-  const ping = async () => {
-    try {
-      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"
-        }
-      });
-      return true;
-    } catch {}
-    return false;
-  };
-  if (await ping()) {
-    return;
-  }
-  await wait(ms);
-  while (true) {
-    if (await ping()) {
-      break;
-    }
-    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", "");
-  const acceptedPath = acceptedPathIn.replace("/@id", "");
-  const mod = hotModulesMap.get(path);
-  if (!mod) {
-    console.info(` \u2776 hmr - No module found`);
-    console.info(`    looked for ${path} in:`);
-    hotModulesMap.forEach((value, key) => {
-      console.info(`   - ${key}`);
-    });
-    return;
-  }
-  let fetchedModule;
-  const isSelfUpdate = path === acceptedPath;
-  const qualifiedCallbacks = mod.callbacks.filter(({
-    deps
-  }) => deps.includes(acceptedPath));
-  if (isSelfUpdate || qualifiedCallbacks.length > 0) {
-    const disposer = disposeMap.get(acceptedPath);
-    if (disposer) await disposer(dataMap.get(acceptedPath));
-    const [acceptedPathWithoutQuery, query] = acceptedPath.split(`?`);
-    try {
-      const filePath = acceptedPathWithoutQuery;
-      const finalQuery = `file?file=${encodeURIComponent(filePath)}&${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`;
-      const 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());
-      const 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}`;
-    if (process.env.DEBUG) {
-      console.info(`[vite] hot updated: ${loggedPath}`);
-    }
-  };
-}
-function sendMessageBuffer() {
-  if (socket.readyState === 1) {
-    messageBuffer.forEach(msg => socket.send(msg));
-    messageBuffer.length = 0;
-  }
-}
-const hotModulesMap = /* @__PURE__ */new Map();
-const disposeMap = /* @__PURE__ */new Map();
-const pruneMap = /* @__PURE__ */new Map();
-const dataMap = /* @__PURE__ */new Map();
-const customListenersMap = /* @__PURE__ */new Map();
-const ctxToListenersMap = /* @__PURE__ */new Map();
-globalThis["createHotContext"] = function createHotContext(ownerPath) {
-  if (!dataMap.has(ownerPath)) {
-    dataMap.set(ownerPath, {});
-  }
-  const mod2 = hotModulesMap.get(ownerPath);
-  if (mod2) {
-    mod2.callbacks = [];
-  }
-  const staleListeners = ctxToListenersMap.get(ownerPath);
-  if (staleListeners) {
-    for (const [event, staleFns] of staleListeners) {
-      const listeners = customListenersMap.get(event);
-      if (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
-    });
-    hotModulesMap.set(ownerPath, mod3);
-  }
-  const hot = {
-    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();
-    }
-  };
-  return hot;
-};