one/dist/esm/router/useViteRoutes.native.js

One is a new React Framework that makes Vite serve both native and web.

var lastVersion = 0,
  context;
function useViteRoutes(routes, routerRoot, options, version) {
  return version && version > lastVersion && (context = null, lastVersion = version), context || loadRoutes(routes, routerRoot, options), context;
}
var preloadedModules = {};
function registerPreloadedRoute(key, module) {
  preloadedModules[key] = module;
}
function getPreloadedModule(key) {
  return preloadedModules[key];
}
function getPreloadedModuleKeys() {
  return Object.keys(preloadedModules);
}
function matchDynamicRoute(routePattern, actualPath) {
  var routeSegments = routePattern.split("/"),
    pathSegments = actualPath.split("/"),
    hasCatchAll = routeSegments.some(function (s) {
      return s.startsWith("[...");
    });
  if (hasCatchAll) {
    for (var catchAllIdx = routeSegments.findIndex(function (s) {
        return s.startsWith("[...");
      }), i = 0; i < catchAllIdx; i++) if (routeSegments[i] && !routeSegments[i].startsWith("[") && routeSegments[i] !== pathSegments[i]) return !1;
    return pathSegments.length >= catchAllIdx;
  }
  if (routeSegments.length !== pathSegments.length) return !1;
  for (var i1 = 0; i1 < routeSegments.length; i1++) {
    var routeSeg = routeSegments[i1],
      pathSeg = pathSegments[i1];
    if (!(routeSeg.startsWith("[") && routeSeg.endsWith("]")) && routeSeg !== pathSeg) return !1;
  }
  return !0;
}
async function preloadRouteModules(href) {
  var globbed = globalThis.__importMetaGlobbed;
  if (globbed) {
    var normalizedHref = href === "/" ? "" : href.replace(/^\//, "").replace(/\/$/, ""),
      promises = [],
      _iteratorNormalCompletion = !0,
      _didIteratorError = !1,
      _iteratorError = void 0;
    try {
      for (var _loop = function () {
          var key = _step.value,
            routePath = key.replace(/^\/[^/]+\//, "");
          routePath = routePath.replace(/\([^)]+\)\//g, ""), routePath = routePath.replace(/\/_layout\.tsx$/, "").replace(/\/index(\+[a-z]+)?\.tsx$/, "").replace(/(\+[a-z]+)?\.tsx$/, ""), routePath = routePath.replace(/^\//, "");
          var isStaticMatch = routePath === normalizedHref ||
            // exact match
            routePath.startsWith(normalizedHref + "/") ||
            // child route
            normalizedHref.startsWith(routePath + "/") ||
            // parent layout
            routePath === "" ||
            // root layout
            normalizedHref !== "" && routePath === normalizedHref.split("/")[0],
            isDynamicMatch = routePath.includes("[") && matchDynamicRoute(routePath, normalizedHref);
          (isStaticMatch || isDynamicMatch) && typeof globbed[key] == "function" && promises.push(globbed[key]().then(function (mod) {
            preloadedModules[key] = mod;
          }).catch(function () {}));
        }, _iterator = Object.keys(globbed)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) _loop();
    } catch (err) {
      _didIteratorError = !0, _iteratorError = err;
    } finally {
      try {
        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
      } finally {
        if (_didIteratorError) throw _iteratorError;
      }
    }
    await Promise.all(promises);
  }
}
function loadRoutes(paths, routerRoot, options) {
  return context || (globalThis.__importMetaGlobbed = paths, context = globbedRoutesToRouteContext(paths, routerRoot, options), context);
}
function globbedRoutesToRouteContext(paths, routerRoot, options) {
  var routesSync = {},
    promises = {},
    loadedRoutes = {},
    clears = {};
  Object.keys(paths).forEach(function (path) {
    var _options_routeModes;
    if (!paths[path]) {
      console.error(`Error: Missing route at path ${path}`);
      return;
    }
    var loadRouteFunction = paths[path],
      pathWithoutRelative = path.replace(`/${routerRoot}/`, "./"),
      originalPath = pathWithoutRelative.slice(1).replace(/\.[jt]sx?$/, "");
    (options == null || (_options_routeModes = options.routeModes) === null || _options_routeModes === void 0 ? void 0 : _options_routeModes[originalPath]) === "spa" ? (console.info(`Spa mode: ${originalPath}`), loadedRoutes[pathWithoutRelative] = function () {
      return null;
    }) : routesSync[pathWithoutRelative] = loadRouteFunction;
  });
  var moduleKeys = Object.keys(routesSync);
  function resolve(id) {
    if (clearTimeout(clears[id]), loadedRoutes[id]) return loadedRoutes[id];
    var preloadKey = id.replace("./", `/${routerRoot}/`),
      preloaded = getPreloadedModule(preloadKey);
    if (preloaded) return loadedRoutes[id] = preloaded, preloaded;
    if (typeof routesSync[id] != "function") return routesSync[id];
    throw promises[id] || (promises[id] = routesSync[id]().then(function (val) {
      return loadedRoutes[id] = val, delete promises[id], clears[id] = setTimeout(function () {
        delete loadedRoutes[id];
      }, 500), val;
    }).catch(function (err) {
      console.error("Error loading route", id, err, new Error().stack), loadedRoutes[id] = {
        default: function () {
          return null;
        }
      }, delete promises[id];
    }), process.env.NODE_ENV === "development" && (promises[id].stack = new Error().stack)), promises[id];
  }
  return resolve.keys = function () {
    return moduleKeys;
  }, resolve.id = "", resolve.resolve = function (id) {
    return id;
  }, resolve;
}
export { getPreloadedModule, getPreloadedModuleKeys, globbedRoutesToRouteContext, loadRoutes, preloadRouteModules, registerPreloadedRoute, useViteRoutes };
//# sourceMappingURL=useViteRoutes.native.js.map