one
Version:
One is a new React Framework that makes Vite serve both native and web.
838 lines (835 loc) • 33.7 kB
JavaScript
;
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 workerHandler_exports = {};
__export(workerHandler_exports, {
createWorkerHandler: () => createWorkerHandler
});
module.exports = __toCommonJS(workerHandler_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_isResponse = require("../utils/isResponse.native.js");
var import_resolveResponse = require("../vite/resolveResponse.native.js");
var import_ssrLoaderData = require("./ssrLoaderData.native.js");
var import_staticHtmlFetcher = require("./staticHtmlFetcher.native.js");
function _instanceof(left, right) {
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
return !!right[Symbol.hasInstance](left);
} else {
return left instanceof right;
}
}
function _type_of(obj) {
"@swc/helpers - typeof";
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function createWorkerHandler(options) {
var _oneOptions_web;
var {
oneOptions
} = options;
var currentLazyRoutes = options.lazyRoutes;
var compiledManifest = (0, import_createHandleRequest.compileManifest)(options.buildInfo.manifest);
var routeToBuildInfo = options.buildInfo.routeToBuildInfo;
var routeMap = options.buildInfo.routeMap;
var currentPreloads = options.buildInfo.preloads;
var currentCssPreloads = options.buildInfo.cssPreloads;
var debugRouter = process.env.ONE_DEBUG_ROUTER;
var redirects = (_oneOptions_web = oneOptions.web) === null || _oneOptions_web === void 0 ? void 0 : _oneOptions_web.redirects;
var compiledRedirects = null;
if (redirects === null || redirects === void 0 ? void 0 : redirects.length) {
compiledRedirects = redirects.map(function (r) {
var regexSource = r.source.replace(/:(\w+)/g, function (_, name) {
return `(?<${name}>[^/]+)`;
});
return {
regex: new RegExp(`^${regexSource}$`),
destination: r.destination,
permanent: r.permanent || false
};
});
}
var useStreaming = !process.env.ONE_BUFFERED_SSR;
var htmlHeaders = {
"content-type": "text/html"
};
var ssrHtmlHeaders = {
"content-type": "text/html",
"cache-control": "no-cache"
};
var loaderCache = /* @__PURE__ */new Map();
var moduleImportCache = /* @__PURE__ */new Map();
var loaderCacheFnMap = /* @__PURE__ */new Map();
var pendingLoaderResults = /* @__PURE__ */new Map();
var render = null;
var renderStream = null;
var renderLoading = null;
var renderGeneration = 0;
function ensureRenderLoaded() {
if (render) return;
if (renderLoading) return renderLoading;
var gen = ++renderGeneration;
renderLoading = async function () {
var entry = await currentLazyRoutes.serverEntry();
if (gen !== renderGeneration) return;
render = entry.default.render;
renderStream = entry.default.renderStream || null;
}();
return renderLoading;
}
function findNearestNotFoundPath(urlPath) {
var cur = urlPath;
while (cur) {
var parent = cur.lastIndexOf("/") > 0 ? cur.slice(0, cur.lastIndexOf("/")) : "";
if (routeMap[`${parent}/+not-found`]) return `${parent}/+not-found`;
if (!parent) break;
cur = parent;
}
return "/+not-found";
}
function make404LoaderJs(path, logReason) {
var nfPath = findNearestNotFoundPath(path);
if (logReason) console.error(`[one] 404 loader for ${path}: ${logReason}`);
return `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`;
}
async function readStaticHtml(htmlPath) {
var fetchStaticHtml = (0, import_staticHtmlFetcher.getFetchStaticHtml)();
if (fetchStaticHtml) return await fetchStaticHtml(htmlPath);
if (debugRouter) {
console.warn(`[one/worker] no fetchStaticHtml set, cannot read ${htmlPath}`);
}
return null;
}
function resolveLoaderSync(lazyKey) {
var cacheKey = lazyKey || "";
var cached = loaderCache.get(cacheKey);
if (cached !== void 0) return cached;
return async function () {
var _ref;
var routeExported;
if (moduleImportCache.has(cacheKey)) {
routeExported = moduleImportCache.get(cacheKey);
} else if (lazyKey && currentLazyRoutes.pages[lazyKey]) {
routeExported = await currentLazyRoutes.pages[lazyKey]();
moduleImportCache.set(cacheKey, routeExported);
} else {
console.warn(`[one/worker] no lazy route for ${cacheKey}`);
loaderCache.set(cacheKey, null);
return null;
}
var loader = (routeExported === null || routeExported === void 0 ? void 0 : routeExported.loader) || null;
loaderCache.set(cacheKey, loader);
loaderCacheFnMap.set(cacheKey, (_ref = routeExported === null || routeExported === void 0 ? void 0 : routeExported.loaderCache) !== null && _ref !== void 0 ? _ref : null);
return loader;
}();
}
async function importAndRunLoader(routeId, lazyKey, loaderProps) {
if (!lazyKey) return {
loaderData: void 0,
routeId
};
var cacheMapKey = lazyKey;
var loaderCacheFn = loaderCacheFnMap.get(cacheMapKey);
var coalFullKey;
var coalTtl = 0;
if (loaderCacheFn) {
var _ref;
var cacheResult = loaderCacheFn(loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params, loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.request);
var cacheKey = typeof cacheResult === "string" ? cacheResult : cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.key;
coalTtl = typeof cacheResult === "string" ? 0 : (_ref = cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.ttl) !== null && _ref !== void 0 ? _ref : 0;
if (cacheKey != null) {
coalFullKey = routeId + "\0" + cacheKey;
var existing = pendingLoaderResults.get(coalFullKey);
if (existing && (!existing.expires || Date.now() < existing.expires)) {
var loaderData = await existing.promise;
return {
loaderData,
routeId
};
}
}
}
try {
var loaderOrPromise = resolveLoaderSync(lazyKey);
var loader = _instanceof(loaderOrPromise, Promise) ? await loaderOrPromise : loaderOrPromise;
if (!loader) return {
loaderData: void 0,
routeId
};
if (coalFullKey) {
var promise = loader(loaderProps);
var entry = {
promise,
expires: 0
};
pendingLoaderResults.set(coalFullKey, entry);
promise.then(function () {
entry.expires = coalTtl > 0 ? Date.now() + coalTtl : 0;
if (coalTtl <= 0) Promise.resolve().then(function () {
return pendingLoaderResults.delete(coalFullKey);
});
}, function () {
return pendingLoaderResults.delete(coalFullKey);
});
var loaderData1 = await promise;
return {
loaderData: loaderData1,
routeId
};
}
var loaderData2 = await loader(loaderProps);
return {
loaderData: loaderData2,
routeId
};
} catch (err) {
if ((0, import_isResponse.isResponse)(err)) throw err;
if ((err === null || err === void 0 ? void 0 : err.code) === "ENOENT") return {
loaderData: void 0,
routeId,
isEnoent: true
};
console.error(`[one] Error running loader for ${routeId}:`, err);
return {
loaderData: void 0,
routeId
};
}
}
var requestHandlers = {
async handleStaticFile() {
return null;
},
async handleAPI(param) {
var {
route
} = param;
if (currentLazyRoutes.api[route.page]) {
return await currentLazyRoutes.api[route.page]();
}
console.warn(`[one/worker] no lazy API route for ${route.page}`);
return null;
},
async loadMiddleware(route) {
if (currentLazyRoutes.middlewares[route.contextKey]) {
return await currentLazyRoutes.middlewares[route.contextKey]();
}
console.warn(`[one/worker] no lazy middleware for ${route.contextKey}`);
return null;
},
async handleLoader(param) {
var {
route,
loaderProps
} = param;
var routeFile = route.routeFile || route.file;
var loader;
try {
var loaderResult = resolveLoaderSync(routeFile);
loader = _instanceof(loaderResult, Promise) ? await loaderResult : loaderResult;
} catch (err) {
if ((err === null || err === void 0 ? void 0 : err.code) === "ERR_MODULE_NOT_FOUND") return null;
throw err;
}
if (!loader) return null;
var json;
try {
json = await loader(loaderProps);
} catch (err) {
if ((err === null || err === void 0 ? void 0 : err.code) === "ENOENT") {
return make404LoaderJs((loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/", `ENOENT ${(err === null || err === void 0 ? void 0 : err.path) || err}`);
}
throw err;
}
if ((0, import_isResponse.isResponse)(json)) throw json;
return `export function loader() { return ${JSON.stringify(json)} }`;
},
async handlePage(param) {
var {
route,
url,
loaderProps
} = param;
var routeBuildInfo = routeToBuildInfo[route.file];
if (route.type === "ssr") {
if (!routeBuildInfo) {
console.error(`Error in route`, route);
throw new Error(`No buildinfo found for ${url}, route: ${route.file}, in keys:
${Object.keys(routeToBuildInfo).join("\n ")}`);
}
try {
var _globalThis___vxrnresetState, _globalThis;
var layoutRoutes = route.layouts || [];
var layoutLoaderPromises = [];
var noLoaderResults = [];
var _iteratorNormalCompletion = true,
_didIteratorError = false,
_iteratorError = void 0;
try {
for (var _iterator = layoutRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var layout = _step.value;
var cacheKey = layout.contextKey || "";
var cachedLoader = loaderCache.get(cacheKey);
if (cachedLoader === null) {
noLoaderResults.push({
loaderData: void 0,
routeId: layout.contextKey
});
} else {
layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var pageLoaderPromise = importAndRunLoader(route.file, route.file, loaderProps);
var layoutResults;
var pageResult;
try {
if (layoutLoaderPromises.length === 0) {
layoutResults = noLoaderResults;
pageResult = await pageLoaderPromise;
} else {
var [asyncLayoutResults, pr] = await Promise.all([Promise.all(layoutLoaderPromises), pageLoaderPromise]);
layoutResults = [...noLoaderResults, ...asyncLayoutResults];
pageResult = pr;
}
} catch (err) {
if ((0, import_isResponse.isResponse)(err)) return err;
throw err;
}
if (pageResult.isEnoent) {
var nfPath = findNearestNotFoundPath((loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/");
var nfHtml = routeMap[nfPath];
if (nfHtml) {
var html = await readStaticHtml(nfHtml);
if (html) {
return new Response(html, {
headers: {
"content-type": "text/html"
},
status: 404
});
}
}
return new Response("404 Not Found", {
status: 404
});
}
var matchPathname = (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/";
var matchParams = (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {};
var matches = new Array(layoutResults.length + 1);
for (var i = 0; i < layoutResults.length; i++) {
var result = layoutResults[i];
matches[i] = {
routeId: result.routeId,
pathname: matchPathname,
params: matchParams,
loaderData: result.loaderData
};
}
matches[layoutResults.length] = {
routeId: pageResult.routeId,
pathname: matchPathname,
params: matchParams,
loaderData: pageResult.loaderData
};
var loaderData = pageResult.loaderData;
var _iteratorNormalCompletion1 = true,
_didIteratorError1 = false,
_iteratorError1 = void 0;
try {
var _loop = function () {
var layout2 = _step1.value;
var key = layout2.contextKey;
var loaderFn = loaderCache.get(key);
if (loaderFn) {
var result2 = layoutResults.find(function (r) {
return r.routeId === key;
});
if (result2) (0, import_ssrLoaderData.setSSRLoaderData)(loaderFn, result2.loaderData);
}
};
for (var _iterator1 = layoutRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) _loop();
} catch (err) {
_didIteratorError1 = true;
_iteratorError1 = err;
} finally {
try {
if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
_iterator1.return();
}
} finally {
if (_didIteratorError1) {
throw _iteratorError1;
}
}
}
var pageLoaderFn = loaderCache.get(route.file);
if (pageLoaderFn) (0, import_ssrLoaderData.setSSRLoaderData)(pageLoaderFn, pageResult.loaderData);
(_globalThis___vxrnresetState = (_globalThis = globalThis)["__vxrnresetState"]) === null || _globalThis___vxrnresetState === void 0 ? void 0 : _globalThis___vxrnresetState.call(_globalThis);
var renderProps = {
mode: route.type,
loaderData,
loaderProps,
path: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
preloads: routeBuildInfo.criticalPreloads || routeBuildInfo.preloads,
deferredPreloads: routeBuildInfo.deferredPreloads,
css: routeBuildInfo.css,
cssContents: routeBuildInfo.cssContents,
matches
};
var _rl = ensureRenderLoaded();
if (_rl) await _rl;
var status = route.isNotFound ? 404 : 200;
var responseHeaders = route.isNotFound ? htmlHeaders : ssrHtmlHeaders;
if (useStreaming) {
var stream = await renderStream(renderProps);
return new Response(stream, {
headers: responseHeaders,
status
});
}
var rendered = await render(renderProps);
return new Response(rendered, {
headers: responseHeaders,
status
});
} catch (err) {
var _ref;
if ((0, import_isResponse.isResponse)(err)) return err;
console.error(`[one] Error rendering SSR route ${route.file}
${(_ref = err === null || err === void 0 ? void 0 : err["stack"]) !== null && _ref !== void 0 ? _ref : err}
url: ${url}`);
return null;
}
} else {
var layoutRoutes1 = route.layouts || [];
var needsSpaShell = route.type === "spa" && layoutRoutes1.some(function (layout2) {
return layout2.layoutRenderMode === "ssg" || layout2.layoutRenderMode === "ssr";
});
if (needsSpaShell) {
try {
var _globalThis___vxrnresetState1, _globalThis1;
var layoutResults1 = await Promise.all(layoutRoutes1.map(function (layout2) {
return importAndRunLoader(layout2.contextKey, layout2.contextKey, loaderProps);
}));
var matches1 = layoutResults1.map(function (result2) {
return {
routeId: result2.routeId,
pathname: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
params: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.params) || {},
loaderData: result2.loaderData
};
});
(_globalThis___vxrnresetState1 = (_globalThis1 = globalThis)["__vxrnresetState"]) === null || _globalThis___vxrnresetState1 === void 0 ? void 0 : _globalThis___vxrnresetState1.call(_globalThis1);
var _rl1 = ensureRenderLoaded();
if (_rl1) await _rl1;
var spaRouteBuildInfo = routeToBuildInfo[route.file];
var rendered1 = await render({
mode: "spa-shell",
loaderData: void 0,
loaderProps,
path: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
preloads: (spaRouteBuildInfo === null || spaRouteBuildInfo === void 0 ? void 0 : spaRouteBuildInfo.criticalPreloads) || (spaRouteBuildInfo === null || spaRouteBuildInfo === void 0 ? void 0 : spaRouteBuildInfo.preloads),
deferredPreloads: spaRouteBuildInfo === null || spaRouteBuildInfo === void 0 ? void 0 : spaRouteBuildInfo.deferredPreloads,
css: spaRouteBuildInfo === null || spaRouteBuildInfo === void 0 ? void 0 : spaRouteBuildInfo.css,
cssContents: spaRouteBuildInfo === null || spaRouteBuildInfo === void 0 ? void 0 : spaRouteBuildInfo.cssContents,
matches: matches1
});
return new Response(rendered1, {
headers: htmlHeaders,
status: route.isNotFound ? 404 : 200
});
} catch (err) {
var _ref1;
if ((0, import_isResponse.isResponse)(err)) return err;
console.error(`[one] Error rendering spa-shell for ${route.file}
${(_ref1 = err === null || err === void 0 ? void 0 : err["stack"]) !== null && _ref1 !== void 0 ? _ref1 : err}
url: ${url}`);
}
}
var isDynamicRoute = Object.keys(route.routeKeys).length > 0;
var routeCleanPath = route.urlCleanPath.replace(/\?/g, "");
var notFoundKey = route.isNotFound ? route.page.replace(/\[([^\]]+)\]/g, ":$1") : null;
var htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[routeBuildInfo === null || routeBuildInfo === void 0 ? void 0 : routeBuildInfo.cleanPath];
if (htmlPath) {
var html1 = await readStaticHtml(htmlPath);
if (html1) {
return new Response(html1, {
headers: htmlHeaders,
status: route.isNotFound ? 404 : 200
});
}
}
if (isDynamicRoute) {
var notFoundRoute = findNearestNotFoundPath(url.pathname);
var notFoundHtmlPath = routeMap[notFoundRoute];
if (notFoundHtmlPath) {
var notFoundHtml = await readStaticHtml(notFoundHtmlPath);
if (notFoundHtml) {
var notFoundMarker = `<script>window.__one404=${JSON.stringify({
originalPath: url.pathname,
notFoundPath: notFoundRoute
})}</script>`;
var injectedHtml = notFoundHtml.includes("</head>") ? notFoundHtml.replace("</head>", `${notFoundMarker}</head>`) : notFoundHtml.replace("<body", `${notFoundMarker}<body`);
return new Response(injectedHtml, {
headers: htmlHeaders,
status: 404
});
}
}
return new Response("404 Not Found", {
status: 404
});
}
return null;
}
}
};
function setCacheHeaders(response, route, isAPI) {
if (!response.headers.has("cache-control") && !response.headers.has("Cache-Control")) {
try {
if (isAPI) {
response.headers.set("cache-control", "no-store");
} else if (route.type === "ssg" || route.type === "spa") {
response.headers.set("cache-control", "public, s-maxage=60, stale-while-revalidate=120");
} else {
response.headers.set("cache-control", "no-cache");
}
} catch (unused) {}
}
return response;
}
async function handleRequest(request) {
var url = (0, import_createHandleRequest.getURLfromRequestURL)(request);
var pathname = url.pathname;
var method = request.method;
if (compiledRedirects) {
var _iteratorNormalCompletion = true,
_didIteratorError = false,
_iteratorError = void 0;
try {
for (var _iterator = compiledRedirects[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var redirect = _step.value;
var match = redirect.regex.exec(pathname);
if (match) {
var destination = redirect.destination;
if (match.groups) {
var _iteratorNormalCompletion1 = true,
_didIteratorError1 = false,
_iteratorError1 = void 0;
try {
for (var _iterator1 = Object.entries(match.groups)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
var [name, value] = _step1.value;
destination = destination.replace(`:${name}`, value);
}
} catch (err) {
_didIteratorError1 = true;
_iteratorError1 = err;
} finally {
try {
if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
_iterator1.return();
}
} finally {
if (_didIteratorError1) {
throw _iteratorError1;
}
}
}
}
if (debugRouter) console.info(`[one] \u21AA redirect ${pathname} \u2192 ${destination}`);
return new Response(null, {
status: redirect.permanent ? 301 : 302,
headers: {
location: new URL(destination, url.origin).toString()
}
});
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
if (pathname.endsWith(import_constants.PRELOAD_JS_POSTFIX)) {
if (!currentPreloads[pathname]) {
return new Response("", {
headers: {
"Content-Type": "text/javascript"
}
});
}
return null;
}
if (pathname.endsWith(import_constants.CSS_PRELOAD_JS_POSTFIX)) {
if (!(currentCssPreloads === null || currentCssPreloads === void 0 ? void 0 : currentCssPreloads[pathname])) {
return new Response("export default Promise.resolve()", {
headers: {
"Content-Type": "text/javascript"
}
});
}
return null;
}
if (pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(pathname);
var _iteratorNormalCompletion2 = true,
_didIteratorError2 = false,
_iteratorError2 = void 0;
try {
for (var _iterator2 = compiledManifest.pageRoutes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var route = _step2.value;
if (route.file === "") continue;
if (!route.compiledRegex.test(originalUrl)) continue;
if (route.type === "ssg" && Object.keys(route.routeKeys).length > 0 && !routeMap[originalUrl]) {
return new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
headers: {
"Content-Type": "text/javascript"
}
});
}
if (route.hasLoader === false) {
return new Response("export function loader() { return undefined }", {
headers: {
"Content-Type": "text/javascript"
}
});
}
var loaderRoute = {
...route,
routeFile: route.file,
file: route.loaderServerPath || pathname
};
var finalUrl = new URL(originalUrl, url.origin);
finalUrl.search = url.search;
var cleanedRequest = new Request(finalUrl, request);
try {
return await (0, import_createHandleRequest.resolveLoaderRoute)(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
} catch (err) {
if ((err === null || err === void 0 ? void 0 : err.code) === "ERR_MODULE_NOT_FOUND") {
return new Response("export function loader() { return undefined }", {
headers: {
"Content-Type": "text/javascript"
}
});
}
console.error(`Error running loader: ${err}`);
return null;
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return null;
}
if (pathname.endsWith(".js") || pathname.endsWith(".css")) {
return null;
}
var _iteratorNormalCompletion3 = true,
_didIteratorError3 = false,
_iteratorError3 = void 0;
try {
for (var _iterator3 = compiledManifest.apiRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var route1 = _step3.value;
if (route1.compiledRegex.test(pathname)) {
if (debugRouter) console.info(`[one] \u26A1 ${pathname} \u2192 matched API route: ${route1.page}`);
var response = await (0, import_createHandleRequest.resolveAPIRoute)(requestHandlers, request, url, route1);
if (response && (0, import_isResponse.isResponse)(response)) {
return setCacheHeaders(response, route1, true);
}
return null;
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
if (method === "GET") {
var _iteratorNormalCompletion4 = true,
_didIteratorError4 = false,
_iteratorError4 = void 0;
try {
var _loop = async function () {
var route2 = _step4.value;
var _route_middlewares;
if (!route2.compiledRegex.test(pathname)) return "continue";
if (debugRouter) {
console.info(`[one] \u26A1 ${pathname} \u2192 matched page route: ${route2.page} (${route2.type})`);
}
if (route2.type === "ssr" && !((_route_middlewares = route2.middlewares) === null || _route_middlewares === void 0 ? void 0 : _route_middlewares.length)) {
var params = {};
var match2 = route2.compiledRegex.exec(pathname);
if (match2 === null || match2 === void 0 ? void 0 : match2.groups) {
var _iteratorNormalCompletion5 = true,
_didIteratorError5 = false,
_iteratorError5 = void 0;
try {
for (var _iterator5 = Object.entries(match2.groups)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
var [key, value2] = _step5.value;
params[route2.routeKeys[key]] = value2;
}
} catch (err) {
_didIteratorError5 = true;
_iteratorError5 = err;
} finally {
try {
if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
_iterator5.return();
}
} finally {
if (_didIteratorError5) {
throw _iteratorError5;
}
}
}
}
var loaderProps = {
path: pathname,
search: url.search,
subdomain: (0, import_createHandleRequest.getSubdomain)(url),
request,
params
};
var response2 = await (0, import_resolveResponse.resolveResponse)(async function () {
try {
return await requestHandlers.handlePage({
request,
route: route2,
url,
loaderProps
});
} catch (err) {
if ((0, import_isResponse.isResponse)(err)) return err;
throw err;
}
});
if (response2 && (0, import_isResponse.isResponse)(response2)) {
return {
v: setCacheHeaders(response2, route2, false)
};
}
return {
v: null
};
}
try {
var response1 = await (0, import_createHandleRequest.resolvePageRoute)(requestHandlers, request, url, route2);
if (response1 && (0, import_isResponse.isResponse)(response1)) {
return {
v: setCacheHeaders(response1, route2, false)
};
}
} catch (err) {
console.error(` [one] Error handling request: ${err["stack"]}`);
}
return {
v: null
};
};
for (var _iterator4 = compiledManifest.pageRoutes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
var _ret = await _loop();
if (_type_of(_ret) === "object") return _ret.v;
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
}
return null;
}
function updateRoutes(newBuildInfo, newLazyRoutes) {
compiledManifest = (0, import_createHandleRequest.compileManifest)(newBuildInfo.manifest);
routeToBuildInfo = newBuildInfo.routeToBuildInfo;
routeMap = newBuildInfo.routeMap;
currentPreloads = newBuildInfo.preloads;
currentCssPreloads = newBuildInfo.cssPreloads;
if (newLazyRoutes) currentLazyRoutes = newLazyRoutes;
loaderCache.clear();
moduleImportCache.clear();
loaderCacheFnMap.clear();
pendingLoaderResults.clear();
render = null;
renderStream = null;
renderLoading = null;
}
return {
handleRequest,
updateRoutes
};
}
//# sourceMappingURL=workerHandler.native.js.map