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

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

"use strict";

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
  value: true
}), mod);
var useViteRoutes_exports = {};
__export(useViteRoutes_exports, {
  getPreloadedModule: () => getPreloadedModule,
  getPreloadedModuleKeys: () => getPreloadedModuleKeys,
  globbedRoutesToRouteContext: () => globbedRoutesToRouteContext,
  loadRoutes: () => loadRoutes,
  preloadRouteModules: () => preloadRouteModules,
  registerPreloadedRoute: () => registerPreloadedRoute,
  useViteRoutes: () => useViteRoutes
});
module.exports = __toCommonJS(useViteRoutes_exports);
var import_hmrImport = require("./hmrImport.native.js");
var lastVersion = 0;
var context;
function useViteRoutes(routes, routerRoot, options, version) {
  if (version && version > lastVersion) {
    context = null;
    lastVersion = version;
    var _iteratorNormalCompletion = true,
      _didIteratorError = false,
      _iteratorError = void 0;
    try {
      for (var _iterator = Object.keys(preloadedModules)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var key = _step.value;
        delete preloadedModules[key];
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  }
  if (!context) {
    loadRoutes(routes, routerRoot, options);
  }
  return context;
}
var preloadedModules = {};
function registerPreloadedRoute(key, module2) {
  preloadedModules[key] = module2;
}
function getPreloadedModule(key) {
  return preloadedModules[key];
}
function getPreloadedModuleKeys() {
  return Object.keys(preloadedModules);
}
function matchDynamicRoute(routePattern, actualPath) {
  var routeSegments = routePattern.split("/");
  var pathSegments = actualPath.split("/");
  var hasCatchAll = routeSegments.some(function (s) {
    return s.startsWith("[...");
  });
  if (hasCatchAll) {
    var catchAllIdx = routeSegments.findIndex(function (s) {
      return s.startsWith("[...");
    });
    for (var i = 0; i < catchAllIdx; i++) {
      if (!routeSegments[i]) continue;
      if (routeSegments[i].startsWith("[")) continue;
      if (routeSegments[i] !== pathSegments[i]) return false;
    }
    return pathSegments.length >= catchAllIdx;
  }
  if (routeSegments.length !== pathSegments.length) return false;
  for (var i1 = 0; i1 < routeSegments.length; i1++) {
    var routeSeg = routeSegments[i1];
    var pathSeg = pathSegments[i1];
    if (routeSeg.startsWith("[") && routeSeg.endsWith("]")) {
      continue;
    }
    if (routeSeg !== pathSeg) return false;
  }
  return true;
}
async function preloadRouteModules(href) {
  var globbed = globalThis["__importMetaGlobbed"];
  if (!globbed) return;
  var normalizedHref = href === "/" ? "" : href.replace(/^\//, "").replace(/\/$/, "");
  var promises = [];
  var _iteratorNormalCompletion = true,
    _didIteratorError = false,
    _iteratorError = void 0;
  try {
    var _loop = function () {
      var key = _step.value;
      var 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];
      var isDynamicMatch = routePath.includes("[") && matchDynamicRoute(routePath, normalizedHref);
      if ((isStaticMatch || isDynamicMatch) && typeof globbed[key] === "function") {
        promises.push(globbed[key]().then(function (mod) {
          preloadedModules[key] = mod;
        }).catch(function () {}));
      }
    };
    for (var _iterator = Object.keys(globbed)[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;
      }
    }
  }
  await Promise.all(promises);
}
function loadRoutes(paths, routerRoot, options) {
  if (context) return context;
  globalThis["__importMetaGlobbed"] = paths;
  context = globbedRoutesToRouteContext(paths, routerRoot, options);
  return context;
}
function globbedRoutesToRouteContext(paths, routerRoot, options) {
  var routesSync = {};
  var routePaths = {};
  var promises = {};
  var loadedRoutes = {};
  var 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];
    var pathWithoutRelative = path.replace(`/${routerRoot}/`, "./");
    var originalPath = pathWithoutRelative.slice(1).replace(/\.[jt]sx?$/, "");
    if ((options === null || options === void 0 ? void 0 : (_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;
      };
    } else {
      routesSync[pathWithoutRelative] = loadRouteFunction;
      routePaths[pathWithoutRelative] = path;
    }
  });
  var moduleKeys = Object.keys(routesSync);
  var hmrVersion = 0;
  if (typeof window !== "undefined") {
    ;
    window.__oneRouteCache = {
      clear: function () {
        hmrVersion++;
        Object.keys(loadedRoutes).forEach(function (key) {
          delete loadedRoutes[key];
        });
        Object.keys(promises).forEach(function (key) {
          delete promises[key];
        });
        Object.keys(preloadedModules).forEach(function (key) {
          delete preloadedModules[key];
        });
      },
      clearFile: function (file) {
        hmrVersion++;
        var normalizedFile = file.replace(/^app\//, "./");
        Object.keys(loadedRoutes).forEach(function (key) {
          if (key === normalizedFile || key.endsWith(normalizedFile.replace("./", "/"))) {
            delete loadedRoutes[key];
          }
        });
        Object.keys(promises).forEach(function (key) {
          if (key === normalizedFile || key.endsWith(normalizedFile.replace("./", "/"))) {
            delete promises[key];
          }
        });
        Object.keys(preloadedModules).forEach(function (key) {
          if (key.includes(file)) {
            delete preloadedModules[key];
          }
        });
      },
      getVersion: function () {
        return hmrVersion;
      }
    };
  }
  function resolve(id) {
    clearTimeout(clears[id]);
    if (loadedRoutes[id]) {
      return loadedRoutes[id];
    }
    var preloadKey = id.replace("./", `/${routerRoot}/`);
    var preloaded = getPreloadedModule(preloadKey);
    if (preloaded) {
      loadedRoutes[id] = preloaded;
      return preloaded;
    }
    if (typeof routesSync[id] !== "function") {
      return routesSync[id];
    }
    if (!promises[id]) {
      var importPromise;
      if (process.env.NODE_ENV === "development" && hmrVersion > 0 && routePaths[id]) {
        importPromise = (0, import_hmrImport.hmrImport)(routePaths[id]).catch(function () {
          return routesSync[id]();
        });
      } else {
        importPromise = routesSync[id]();
      }
      promises[id] = importPromise.then(function (val) {
        loadedRoutes[id] = val;
        delete promises[id];
        if (process.env.NODE_ENV === "development") {
          clears[id] = setTimeout(function () {
            delete loadedRoutes[id];
          }, 500);
        }
        return val;
      }).catch(function (err) {
        console.error(`Error loading route`, id, err, new Error().stack);
        loadedRoutes[id] = {
          default: function () {
            return null;
          }
        };
        delete promises[id];
      });
      if (process.env.NODE_ENV === "development") {
        promises[id].stack = new Error().stack;
      }
    }
    throw promises[id];
  }
  resolve.keys = function () {
    return moduleKeys;
  };
  resolve.id = "";
  resolve.resolve = function (id) {
    return id;
  };
  return resolve;
}
//# sourceMappingURL=useViteRoutes.native.js.map