one
Version:
One is a new React Framework that makes Vite serve both native and web.
968 lines (963 loc) • 40.5 kB
JavaScript
;
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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __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 || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod));
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
value: true
}), mod);
var oneServe_exports = {};
__export(oneServe_exports, {
oneServe: () => oneServe
});
module.exports = __toCommonJS(oneServe_exports);
var import_promises = require("fs/promises");
var import_path = require("path");
var import_constants = require("../constants.native.js");
var import_createHandleRequest = require("../createHandleRequest.native.js");
var import_cleanUrl = require("../utils/cleanUrl.native.js");
var import_toAbsolute = require("../utils/toAbsolute.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;
}
var debugRouter = process.env.ONE_DEBUG_ROUTER;
function forwardHeaders(response, context) {
var _response_headers_getSetCookie, _response_headers;
var setCookies = (_response_headers_getSetCookie = (_response_headers = response.headers).getSetCookie) === null || _response_headers_getSetCookie === void 0 ? void 0 : _response_headers_getSetCookie.call(_response_headers);
if (setCookies === null || setCookies === void 0 ? void 0 : setCookies.length) {
var _iteratorNormalCompletion = true,
_didIteratorError = false,
_iteratorError = void 0;
try {
for (var _iterator = setCookies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var cookie = _step.value;
context.header("set-cookie", cookie, {
append: true
});
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
response.headers.forEach(function (value, key) {
if (key === "set-cookie") return;
context.header(key, value);
});
}
async function readStaticHtml(htmlPath) {
var outDir = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "dist";
var fetchStaticHtml = (0, import_staticHtmlFetcher.getFetchStaticHtml)();
if (fetchStaticHtml) {
var html = await fetchStaticHtml(htmlPath);
if (html) return html;
}
try {
return await (0, import_promises.readFile)((0, import_path.join)(`${outDir}/client`, htmlPath), "utf-8");
} catch (unused) {
return null;
}
}
async function oneServe(oneOptions, buildInfo, app, options) {
var _oneOptions_web, _oneOptions_build_api, _oneOptions_build;
var outDir = buildInfo.outDir || "dist";
var {
resolveAPIRoute,
resolveLoaderRoute,
resolvePageRoute
} = await import("../createHandleRequest");
var {
isResponse
} = await import("../utils/isResponse");
var {
isStatusRedirect
} = await import("../utils/isStatus");
var {
resolveResponse
} = await import("../vite/resolveResponse");
var isAPIRequest = /* @__PURE__ */new WeakMap();
var redirects = (_oneOptions_web = oneOptions.web) === null || _oneOptions_web === void 0 ? void 0 : _oneOptions_web.redirects;
if (redirects) {
var _iteratorNormalCompletion = true,
_didIteratorError = false,
_iteratorError = void 0;
try {
var _loop = function () {
var redirect = _step.value;
app.get(redirect.source, function (context) {
var destinationUrl = redirect.destination.replace(/:\w+/g, function (param) {
var paramName = param.substring(1);
return context.req.param(paramName) || "";
});
if (debugRouter) {
console.info(`[one] \u21AA redirect ${context.req.path} \u2192 ${destinationUrl}`);
}
return context.redirect(destinationUrl, redirect.permanent ? 301 : 302);
});
};
for (var _iterator = redirects[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;
}
}
}
}
if (!buildInfo) {
throw new Error(`No build info found, have you run build?`);
}
var {
routeToBuildInfo,
routeMap
} = buildInfo;
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)}}}`;
}
var serverOptions = {
...oneOptions,
root: "."
};
var apiCJS = ((_oneOptions_build = oneOptions.build) === null || _oneOptions_build === void 0 ? void 0 : (_oneOptions_build_api = _oneOptions_build.api) === null || _oneOptions_build_api === void 0 ? void 0 : _oneOptions_build_api.outputFormat) === "cjs";
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();
function resolveLoaderSync(serverPath, lazyKey) {
var cacheKey = lazyKey || serverPath || "";
var cached = loaderCache.get(cacheKey);
if (cached !== void 0) return cached;
return async function () {
var _ref;
var pathToResolve = serverPath || lazyKey || "";
var resolvedPath = pathToResolve.includes(`${outDir}/server`) ? pathToResolve : (0, import_path.join)("./", `${outDir}/server`, pathToResolve);
var routeExported;
if (moduleImportCache.has(cacheKey)) {
routeExported = moduleImportCache.get(cacheKey);
} else {
var _options_lazyRoutes_pages, _options_lazyRoutes;
routeExported = lazyKey ? (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : (_options_lazyRoutes_pages = _options_lazyRoutes.pages) === null || _options_lazyRoutes_pages === void 0 ? void 0 : _options_lazyRoutes_pages[lazyKey]) ? await options.lazyRoutes.pages[lazyKey]() : await import((0, import_toAbsolute.toAbsolute)(resolvedPath)) : await import((0, import_toAbsolute.toAbsolute)(serverPath));
moduleImportCache.set(cacheKey, routeExported);
}
var loader = (routeExported === null || routeExported === void 0 ? void 0 : routeExported.loader) || null;
loaderCache.set(cacheKey, loader);
var loaderCacheFn = (_ref = routeExported === null || routeExported === void 0 ? void 0 : routeExported.loaderCache) !== null && _ref !== void 0 ? _ref : null;
loaderCacheFnMap.set(cacheKey, loaderCacheFn);
return loader;
}();
}
async function importAndRunLoader(routeId, serverPath, lazyKey, loaderProps) {
if (!serverPath && !lazyKey) {
return {
loaderData: void 0,
routeId
};
}
var cacheMapKey = lazyKey || serverPath || "";
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(serverPath, 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 () {
pendingLoaderResults.delete(coalFullKey);
});
var loaderData1 = await promise;
return {
loaderData: loaderData1,
routeId
};
}
var loaderData2 = await loader(loaderProps);
return {
loaderData: loaderData2,
routeId
};
} catch (err) {
if (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 render = null;
var renderStream = null;
var renderLoading = null;
function ensureRenderLoaded() {
if (render) return;
if (renderLoading) return renderLoading;
renderLoading = async function () {
var _options_lazyRoutes, _oneOptions_build2;
var entry = (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : _options_lazyRoutes.serverEntry) ? await options.lazyRoutes.serverEntry() : await import((0, import_path.resolve)(process.cwd(), `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${_type_of((_oneOptions_build2 = oneOptions.build) === null || _oneOptions_build2 === void 0 ? void 0 : _oneOptions_build2.server) === "object" && oneOptions.build.server.outputFormat === "cjs" ? "c" : ""}js`));
render = entry.default.render;
renderStream = entry.default.renderStream;
}();
return renderLoading;
}
var clientDir = (0, import_path.join)(process.cwd(), outDir, "client");
var requestHandlers = {
async handleStaticFile(filePath) {
try {
var fullPath = (0, import_path.join)(clientDir, filePath);
var content = await (0, import_promises.readFile)(fullPath, "utf-8");
return new Response(content, {
headers: {
"Content-Type": "text/javascript"
}
});
} catch (unused) {
return null;
}
},
async handleAPI(param) {
var {
route: route2
} = param;
var _options_lazyRoutes_api, _options_lazyRoutes;
if (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : (_options_lazyRoutes_api = _options_lazyRoutes.api) === null || _options_lazyRoutes_api === void 0 ? void 0 : _options_lazyRoutes_api[route2.page]) {
return await options.lazyRoutes.api[route2.page]();
}
var fileName = route2.page.slice(1).replace(/\[/g, "_").replace(/\]/g, "_");
var apiFile = (0, import_path.join)(process.cwd(), outDir, "api", fileName + (apiCJS ? ".cjs" : ".js"));
return await import(apiFile);
},
async loadMiddleware(route2) {
var _options_lazyRoutes_middlewares, _options_lazyRoutes;
if (options === null || options === void 0 ? void 0 : (_options_lazyRoutes = options.lazyRoutes) === null || _options_lazyRoutes === void 0 ? void 0 : (_options_lazyRoutes_middlewares = _options_lazyRoutes.middlewares) === null || _options_lazyRoutes_middlewares === void 0 ? void 0 : _options_lazyRoutes_middlewares[route2.contextKey]) {
return await options.lazyRoutes.middlewares[route2.contextKey]();
}
return await import((0, import_toAbsolute.toAbsolute)(route2.contextKey));
},
async handleLoader(param) {
var {
route: route2,
loaderProps
} = param;
var routeFile = route2.routeFile || route2.file;
var serverPath = route2.file.includes(`${outDir}/server`) ? route2.file : (0, import_path.join)("./", `${outDir}/server`, route2.file);
var loader;
try {
var loaderResult = resolveLoaderSync(serverPath, 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 (isResponse(json)) {
throw json;
}
return `export function loader() { return ${JSON.stringify(json)} }`;
},
async handlePage(param) {
var {
route: route2,
url,
loaderProps
} = param;
var _$buildInfo = routeToBuildInfo[route2.file];
if (route2.type === "ssr") {
if (!_$buildInfo) {
console.error(`Error in route`, route2);
throw new Error(`No buildinfo found for ${url}, route: ${route2.file}, in keys:
${Object.keys(routeToBuildInfo).join("\n ")}`);
}
try {
var _globalThis___vxrnresetState, _globalThis;
var layoutRoutes = route2.layouts || [];
var layoutLoaderPromises = [];
var noLoaderResults = [];
var _iteratorNormalCompletion3 = true,
_didIteratorError3 = false,
_iteratorError3 = void 0;
try {
for (var _iterator3 = layoutRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var layout = _step3.value;
var serverPath = layout.loaderServerPath || layout.contextKey;
var cacheKey = layout.contextKey || serverPath || "";
var cachedLoader = loaderCache.get(cacheKey);
if (cachedLoader === null) {
noLoaderResults.push({
loaderData: void 0,
routeId: layout.contextKey
});
} else {
layoutLoaderPromises.push(importAndRunLoader(layout.contextKey, serverPath, layout.contextKey, loaderProps));
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
var pageLoaderPromise = importAndRunLoader(route2.file, _$buildInfo.serverJsPath, route2.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 (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) {
try {
var html = await (0, import_promises.readFile)((0, import_path.join)(process.cwd(), `${outDir}/client`, nfHtml), "utf-8");
return new Response(html, {
headers: {
"content-type": "text/html"
},
status: 404
});
} catch (unused) {}
}
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 _iteratorNormalCompletion12 = true,
_didIteratorError12 = false,
_iteratorError12 = void 0;
try {
var _loop2 = function () {
var layout2 = _step12.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 _iterator12 = layoutRoutes[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) _loop2();
} catch (err) {
_didIteratorError12 = true;
_iteratorError12 = err;
} finally {
try {
if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
_iterator12.return();
}
} finally {
if (_didIteratorError12) {
throw _iteratorError12;
}
}
}
var pageLoaderFn = loaderCache.get(route2.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: route2.type,
loaderData,
loaderProps,
path: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
preloads: _$buildInfo.criticalPreloads || _$buildInfo.preloads,
deferredPreloads: _$buildInfo.deferredPreloads,
css: _$buildInfo.css,
cssContents: _$buildInfo.cssContents,
matches
};
var _rl = ensureRenderLoaded();
if (_rl) await _rl;
var status = route2.isNotFound ? 404 : 200;
var responseHeaders = route2.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 (isResponse(err)) {
return err;
}
console.error(`[one] Error rendering SSR route ${route2.file}
${(_ref = err === null || err === void 0 ? void 0 : err["stack"]) !== null && _ref !== void 0 ? _ref : err}
url: ${url}`);
}
} else {
var layoutRoutes1 = route2.layouts || [];
var needsSpaShell = route2.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) {
var serverPath2 = layout2.loaderServerPath || layout2.contextKey;
return importAndRunLoader(layout2.contextKey, serverPath2, 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 _rl3 = ensureRenderLoaded();
if (_rl3) await _rl3;
var rendered1 = await render({
mode: "spa-shell",
// don't pass loaderData for spa-shell - the page loader runs on client
// passing {} here would make useLoaderState think data is preloaded
loaderData: void 0,
loaderProps,
path: (loaderProps === null || loaderProps === void 0 ? void 0 : loaderProps.path) || "/",
preloads: (_$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.criticalPreloads) || (_$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.preloads),
deferredPreloads: _$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.deferredPreloads,
css: _$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.css,
cssContents: _$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.cssContents,
matches: matches1
});
return new Response(rendered1, {
headers: htmlHeaders,
status: route2.isNotFound ? 404 : 200
});
} catch (err) {
var _ref1;
if (isResponse(err)) {
return err;
}
console.error(`[one] Error rendering spa-shell for ${route2.file}
${(_ref1 = err === null || err === void 0 ? void 0 : err["stack"]) !== null && _ref1 !== void 0 ? _ref1 : err}
url: ${url}`);
}
}
var isDynamicRoute = Object.keys(route2.routeKeys).length > 0;
var routeCleanPath = route2.urlCleanPath.replace(/\?/g, "");
var notFoundKey = route2.isNotFound ? route2.page.replace(/\[([^\]]+)\]/g, ":$1") : null;
var htmlPath = notFoundKey ? routeMap[notFoundKey] : isDynamicRoute ? routeMap[routeCleanPath] || routeMap[url.pathname] : routeMap[url.pathname] || routeMap[_$buildInfo === null || _$buildInfo === void 0 ? void 0 : _$buildInfo.cleanPath];
if (htmlPath) {
var html1 = await readStaticHtml(htmlPath, outDir);
if (html1) {
var headers = new Headers();
headers.set("content-type", "text/html");
return new Response(html1, {
headers,
status: route2.isNotFound ? 404 : 200
});
}
}
if (isDynamicRoute) {
var notFoundRoute = findNearestNotFoundPath(url.pathname);
var notFoundHtmlPath = routeMap[notFoundRoute];
if (notFoundHtmlPath) {
var notFoundHtml = await readStaticHtml(notFoundHtmlPath, outDir);
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`);
var headers1 = new Headers();
headers1.set("content-type", "text/html");
return new Response(injectedHtml, {
headers: headers1,
status: 404
});
}
}
return new Response("404 Not Found", {
status: 404
});
}
}
}
};
function createHonoHandler(route2) {
var isDynamicOrNotFound = route2.page.endsWith("/+not-found") || Object.keys(route2.routeKeys).length > 0;
return async function (context, next) {
try {
var _route_middlewares;
var request = context.req.raw;
if (isDynamicOrNotFound) {
if (options === null || options === void 0 ? void 0 : options.serveStaticAssets) {
var staticAssetResponse = await options.serveStaticAssets({
context
});
if (staticAssetResponse) {
return await (0, import_createHandleRequest.runMiddlewares)(requestHandlers, request, route2, async function () {
return staticAssetResponse;
});
}
}
}
var reqPath = context.req.path;
if (reqPath.endsWith(".js") || reqPath.endsWith(".css")) {
return next();
}
if (route2.type === "ssr" && !((_route_middlewares = route2.middlewares) === null || _route_middlewares === void 0 ? void 0 : _route_middlewares.length) && !reqPath.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
if (debugRouter) {
console.info(`[one] \u26A1 ${reqPath} \u2192 matched page route: ${route2.page} (ssr)`);
}
var pathname = reqPath;
var rawUrl = request.url;
var qIdx = rawUrl.indexOf("?");
var search = qIdx >= 0 ? rawUrl.slice(qIdx) : "";
var params = {};
var match = route2.compiledRegex.exec(pathname);
if (match === null || match === void 0 ? void 0 : match.groups) {
var _iteratorNormalCompletion3 = true,
_didIteratorError3 = false,
_iteratorError3 = void 0;
try {
for (var _iterator3 = Object.entries(match.groups)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var [key, value] = _step3.value;
var namedKey = route2.routeKeys[key];
params[namedKey] = value;
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
}
var loaderProps = {
path: pathname,
search,
subdomain: (0, import_createHandleRequest.getSubdomain)((0, import_createHandleRequest.getURLfromRequestURL)(request)),
request,
params
};
var url = (0, import_createHandleRequest.getURLfromRequestURL)(request);
var response = await resolveResponse(async function () {
try {
return await requestHandlers.handlePage({
request,
route: route2,
url,
loaderProps
});
} catch (err) {
if (isResponse(err)) {
return err;
}
throw err;
}
});
if (response) {
if (isResponse(response)) {
if (isStatusRedirect(response.status)) {
var location = `${response.headers.get("location") || ""}`;
forwardHeaders(response, context);
return context.redirect(location, response.status);
}
return response;
}
return next();
}
return next();
}
var url1 = (0, import_createHandleRequest.getURLfromRequestURL)(request);
var response1 = await function () {
if (url1.pathname.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(url1.pathname);
if (route2.type === "ssg" && Object.keys(route2.routeKeys).length > 0) {
if (!routeMap[originalUrl]) {
return new Response(make404LoaderJs(originalUrl, "ssg route not in routeMap"), {
headers: {
"Content-Type": "text/javascript"
}
});
}
}
var finalUrl = new URL(originalUrl, url1.origin);
finalUrl.search = url1.search;
var cleanedRequest = new Request(finalUrl, request);
return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route2);
}
switch (route2.type) {
case "api":
{
if (debugRouter) {
console.info(`[one] \u26A1 ${url1.pathname} \u2192 matched API route: ${route2.page}`);
}
return resolveAPIRoute(requestHandlers, request, url1, route2);
}
case "ssg":
case "spa":
case "ssr":
{
if (debugRouter) {
console.info(`[one] \u26A1 ${url1.pathname} \u2192 matched page route: ${route2.page} (${route2.type})`);
}
return resolvePageRoute(requestHandlers, request, url1, route2);
}
}
}();
if (response1) {
if (isResponse(response1)) {
if (isStatusRedirect(response1.status)) {
var location1 = `${response1.headers.get("location") || ""}`;
forwardHeaders(response1, context);
return context.redirect(location1, response1.status);
}
if (isAPIRequest.get(request)) {
try {
if (!response1.headers.has("cache-control") && !response1.headers.has("Cache-Control")) {
response1.headers.set("cache-control", "no-store");
}
return response1;
} catch (err) {
console.info(`Error updating cache header on api route "${context.req.path}" to no-store, it is ${response1.headers.get("cache-control")}, continue`, err);
}
}
if (!response1.headers.has("cache-control") && !response1.headers.has("Cache-Control")) {
if (route2.type === "ssg" || route2.type === "spa") {
response1.headers.set("cache-control", "public, s-maxage=60, stale-while-revalidate=120");
} else {
response1.headers.set("cache-control", "no-cache");
}
}
return response1;
}
return next();
}
} catch (err) {
console.error(` [one] Error handling request: ${err["stack"]}`);
}
return next();
};
}
var compiledManifest = (0, import_createHandleRequest.compileManifest)(buildInfo.manifest);
var _iteratorNormalCompletion1 = true,
_didIteratorError1 = false,
_iteratorError1 = void 0;
try {
for (var _iterator1 = compiledManifest.apiRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
var route = _step1.value;
app.get(route.urlPath, createHonoHandler(route));
app.put(route.urlPath, createHonoHandler(route));
app.post(route.urlPath, createHonoHandler(route));
app.delete(route.urlPath, createHonoHandler(route));
app.patch(route.urlPath, createHonoHandler(route));
if (route.urlPath !== route.urlCleanPath) {
app.get(route.urlCleanPath, createHonoHandler(route));
app.put(route.urlCleanPath, createHonoHandler(route));
app.post(route.urlCleanPath, createHonoHandler(route));
app.delete(route.urlCleanPath, createHonoHandler(route));
app.patch(route.urlCleanPath, createHonoHandler(route));
}
}
} catch (err) {
_didIteratorError1 = true;
_iteratorError1 = err;
} finally {
try {
if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
_iterator1.return();
}
} finally {
if (_didIteratorError1) {
throw _iteratorError1;
}
}
}
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 route1 = _step2.value;
app.get(route1.urlPath, createHonoHandler(route1));
if (route1.urlPath !== route1.urlCleanPath) {
app.get(route1.urlCleanPath, createHonoHandler(route1));
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
var {
preloads,
cssPreloads
} = buildInfo;
app.get("*", async function (c, next) {
if (c.req.path.endsWith(import_constants.PRELOAD_JS_POSTFIX)) {
if (!preloads[c.req.path]) {
c.header("Content-Type", "text/javascript");
c.status(200);
return c.body(``);
}
}
if (c.req.path.endsWith(import_constants.CSS_PRELOAD_JS_POSTFIX)) {
if (!(cssPreloads === null || cssPreloads === void 0 ? void 0 : cssPreloads[c.req.path])) {
c.header("Content-Type", "text/javascript");
c.status(200);
return c.body(`export default Promise.resolve()`);
}
}
if (c.req.path.endsWith(import_constants.LOADER_JS_POSTFIX_UNCACHED)) {
var request = c.req.raw;
var url = (0, import_createHandleRequest.getURLfromRequestURL)(request);
var originalUrl = (0, import_cleanUrl.getPathFromLoaderPath)(c.req.path);
var _iteratorNormalCompletion3 = true,
_didIteratorError3 = false,
_iteratorError3 = void 0;
try {
for (var _iterator3 = compiledManifest.pageRoutes[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var route2 = _step3.value;
if (route2.file === "") {
continue;
}
if (!route2.compiledRegex.test(originalUrl)) {
continue;
}
if (route2.type === "ssg" && Object.keys(route2.routeKeys).length > 0 && !routeMap[originalUrl]) {
c.header("Content-Type", "text/javascript");
c.status(200);
return c.body(make404LoaderJs(originalUrl, "ssg route not in routeMap"));
}
var loaderRoute = {
...route2,
routeFile: route2.file,
// preserve original for lazy route lookup
file: route2.loaderServerPath || c.req.path
};
var finalUrl = new URL(originalUrl, url.origin);
finalUrl.search = url.search;
var cleanedRequest = new Request(finalUrl, request);
try {
var resolved = await resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, loaderRoute);
return resolved;
} catch (err) {
if ((err === null || err === void 0 ? void 0 : err.code) === "ERR_MODULE_NOT_FOUND") {
c.header("Content-Type", "text/javascript");
c.status(200);
return c.body(`export function loader() { return undefined }`);
}
console.error(`Error running loader: ${err}`);
return next();
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
}
return next();
});
}
//# sourceMappingURL=oneServe.native.js.map