one/dist/cjs/createDevHandleRequest.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 createDevHandleRequest_exports = {};
__export(createDevHandleRequest_exports, {
  createHandleRequest: () => createHandleRequest
});
module.exports = __toCommonJS(createDevHandleRequest_exports);
var import_constants = require("./constants.native.js");
var import_createHandleRequest = require("./createHandleRequest.native.js");
var import_cleanUrl = require("./utils/cleanUrl.native.js");
var import_getManifest = require("./vite/getManifest.native.js");
var debugRouter = process.env.ONE_DEBUG_ROUTER;
function createHandleRequest(handlers, param) {
  var {
    routerRoot,
    ignoredRouteFiles,
    routePaths
  } = param;
  var manifest = (0, import_getManifest.getManifest)({
    routerRoot,
    ignoredRouteFiles,
    routePaths
  });
  if (!manifest) {
    throw new Error(`No routes manifest`);
  }
  var compiledManifest = (0, import_createHandleRequest.compileManifest)(manifest);
  return {
    manifest,
    handler: async function handleRequest(request) {
      var url = (0, import_createHandleRequest.getURLfromRequestURL)(request);
      var {
        pathname
      } = url;
      if (pathname === "/__vxrnhmr" || pathname.startsWith("/@vite/") || pathname.startsWith("/@fs/") || pathname.startsWith("/@id/") || pathname.startsWith("/node_modules/") || pathname.startsWith("/debugger-frontend") || pathname.startsWith("/inspector")) {
        return null;
      }
      var looksLikeStaticFile = (0, import_createHandleRequest.isStaticAssetRequestPath)(pathname);
      if (handlers.handleAPI) {
        var apiRoute = compiledManifest.apiRoutes.find(function (route2) {
          return route2.compiledRegex.test(pathname);
        });
        if (apiRoute) {
          if (debugRouter) {
            console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${apiRoute.page}`);
          }
          return await (0, import_createHandleRequest.resolveAPIRoute)(handlers, request, url, apiRoute);
        }
      }
      if (!(0, import_createHandleRequest.isPageRequestMethod)(request.method)) {
        return null;
      }
      if (handlers.handleLoader) {
        var isClientRequestingNewRoute = pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED);
        if (isClientRequestingNewRoute) {
          var platformParam = url.searchParams.get("platform");
          var isNativePlatform = platformParam === "ios" || platformParam === "android" || platformParam === "native";
          if (isNativePlatform && handlers.handleStaticFile) {
            var nativeLoaderPath = pathname.replace(/\.js$/, ".native.js");
            var staticResponse = await handlers.handleStaticFile(nativeLoaderPath);
            if (staticResponse) {
              return staticResponse;
            }
          }
          var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname);
          var _iteratorNormalCompletion = true,
            _didIteratorError = false,
            _iteratorError = void 0;
          try {
            for (var _iterator = compiledManifest.pageRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
              var route = _step.value;
              if (route.file === "") {
                continue;
              }
              var finalUrl = new URL(originalUrl, url.origin);
              finalUrl.search = url.search;
              if (!route.compiledRegex.test(finalUrl.pathname)) {
                continue;
              }
              if (route.hasLoader === false) {
                var emptyBody = isNativePlatform ? "exports.loader=function(){return undefined}" : "export function loader() { return undefined }";
                return new Response(emptyBody, {
                  headers: {
                    "Content-Type": "text/javascript"
                  }
                });
              }
              var cleanedRequest = new Request(finalUrl, request);
              return (0, import_createHandleRequest.resolveLoaderRoute)(handlers, cleanedRequest, finalUrl, route);
            }
          } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion && _iterator.return != null) {
                _iterator.return();
              }
            } finally {
              if (_didIteratorError) {
                throw _iteratorError;
              }
            }
          }
          var emptyBody1 = isNativePlatform ? "exports.loader=function(){return{}}" : "export {}";
          return new Response(emptyBody1, {
            headers: {
              "Content-Type": "text/javascript"
            }
          });
        }
      }
      if (handlers.handlePage) {
        var _iteratorNormalCompletion1 = true,
          _didIteratorError1 = false,
          _iteratorError1 = void 0;
        try {
          for (var _iterator1 = compiledManifest.pageRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
            var route1 = _step1.value;
            if (!route1.compiledRegex.test(pathname)) {
              continue;
            }
            var isDynamicRoute = Object.keys(route1.routeKeys).length > 0;
            var isNotFoundRoute = route1.page.endsWith("/+not-found");
            if (looksLikeStaticFile && isNotFoundRoute) {
              var _route_middlewares;
              if (debugRouter) {
                console.info(`[one] \u26A1 ${pathname} \u2192 bare 404 for static probe on ${route1.page}`);
              }
              if (!((_route_middlewares = route1.middlewares) === null || _route_middlewares === void 0 ? void 0 : _route_middlewares.length)) {
                return null;
              }
              return await (0, import_createHandleRequest.runMiddlewares)(handlers, request, route1, async function () {
                return new Response(null, {
                  status: 404,
                  headers: {
                    "Content-Type": "text/plain"
                  }
                });
              });
            }
            if (looksLikeStaticFile && isDynamicRoute) {
              if (debugRouter) {
                console.info(`[one] \u26A1 ${pathname} \u2192 skipping dynamic route ${route1.page} for static asset`);
              }
              continue;
            }
            if (debugRouter) {
              console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route1.page} (${route1.type})`);
            }
            return (0, import_createHandleRequest.resolvePageRoute)(handlers, request, url, route1);
          }
        } catch (err) {
          _didIteratorError1 = true;
          _iteratorError1 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
              _iterator1.return();
            }
          } finally {
            if (_didIteratorError1) {
              throw _iteratorError1;
            }
          }
        }
      }
      return null;
    }
  };
}
//# sourceMappingURL=createDevHandleRequest.native.js.map