one/dist/cjs/cli/buildPage.native.js

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

"use strict";

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 buildPage_exports = {};
__export(buildPage_exports, {
  buildPage: () => buildPage,
  printBuildTimings: () => printBuildTimings
});
module.exports = __toCommonJS(buildPage_exports);
var import_path = require("path");
var import_fs_extra = __toESM(require("fs-extra"), 1);
var constants = __toESM(require("../constants.native.js"), 1);
var import_constants = require("../constants.native.js");
var import_cleanUrl = require("../utils/cleanUrl.native.js");
var import_isResponse = require("../utils/isResponse.native.js");
var import_toAbsolute = require("../utils/toAbsolute.native.js");
var import_replaceLoader = require("../vite/replaceLoader.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;
  }
}
var {
  readFile,
  outputFile
} = import_fs_extra.default;
function urlPathToFilePath(urlPath) {
  var parts = urlPath.replace(/^\//, "").split("/");
  return (0, import_path.join)(...parts);
}
var buildTiming = process.env.ONE_BUILD_TIMING === "1";
var timings = {};
function recordTiming(label, ms) {
  var _timings, _label;
  if (!buildTiming) return;
  ((_timings = timings)[_label = label] || (_timings[_label] = [])).push(ms);
}
function printBuildTimings() {
  if (!buildTiming) return;
  console.info("\n\u{1F4CA} Build timing breakdown:");
  var _iteratorNormalCompletion = true,
    _didIteratorError = false,
    _iteratorError = void 0;
  try {
    for (var _iterator = Object.entries(timings)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var [label, times] = _step.value;
      var total = times.reduce(function (a, b) {
        return a + b;
      }, 0);
      var avg = total / times.length;
      console.info(`  ${label}: ${avg.toFixed(1)}ms avg, ${total.toFixed(0)}ms total (${times.length} calls)`);
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }
}
async function buildPage(serverEntry, path, relativeId, params, foundRoute, clientManifestEntry, staticDir, clientDir, builtMiddlewares, serverJsPath, preloads, allCSS, layoutCSS, routePreloads, allCSSContents, criticalPreloads, deferredPreloads, useAfterLCP, useAfterLCPAggressive) {
  var t0 = performance.now();
  var render = await getRender(serverEntry);
  recordTiming("getRender", performance.now() - t0);
  var htmlPath = `${path.endsWith("/") ? `${removeTrailingSlash(path)}/index` : path}.html`;
  var clientJsPath = clientManifestEntry ? (0, import_path.join)(clientDir, clientManifestEntry.file) : "";
  var htmlOutPath = (0, import_toAbsolute.toAbsolute)((0, import_path.join)(staticDir, htmlPath));
  var preloadPath = (0, import_cleanUrl.getPreloadPath)(path);
  var cssPreloadPath = (0, import_cleanUrl.getPreloadCSSPath)(path);
  var loaderPath = "";
  var loaderData = {};
  try {
    var _foundRoute_layouts;
    var routeImports = [];
    var routeRegistrations = [];
    var routeIndex = 0;
    var _iteratorNormalCompletion = true,
      _didIteratorError = false,
      _iteratorError = void 0;
    try {
      for (var _iterator = Object.entries(routePreloads)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var [routeKey, bundlePath] = _step.value;
        var varName = `_r${routeIndex++}`;
        routeImports.push(`import * as ${varName} from "${bundlePath}"`);
        routeRegistrations.push(`registerPreloadedRoute("${routeKey}", ${varName})`);
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return != null) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
    var registrationCalls = routeRegistrations.map(function (call) {
      return call.replace("registerPreloadedRoute(", "window.__oneRegisterPreloadedRoute(");
    });
    var preloadContent = [
    // import all route modules
    ...routeImports,
    // static imports for cache warming (original behavior)
    ...preloads.map(function (preload) {
      return `import "${preload}"`;
    }),
    // register all route modules using window global
    ...registrationCalls].join("\n");
    t0 = performance.now();
    await import_fs_extra.default.writeFile((0, import_path.join)(clientDir, urlPathToFilePath(preloadPath)), preloadContent);
    recordTiming("writePreload", performance.now() - t0);
    var uniqueCSS = [...new Set(allCSS)];
    var cssPreloadContent = `
const CSS_TIMEOUT = 1000
const cssUrls = ${JSON.stringify(uniqueCSS)}

// Global cache for loaded CSS - avoids DOM queries and tracks across navigations
const loaded = (window.__oneLoadedCSS ||= new Set())

// Prefetch CSS without applying - called on link hover
export function prefetchCSS() {
  cssUrls.forEach(href => {
    if (loaded.has(href)) return
    if (document.querySelector(\`link[href="\${href}"]\`)) return
    const link = document.createElement('link')
    link.rel = 'prefetch'
    link.as = 'style'
    link.href = href
    document.head.appendChild(link)
  })
}

// Inject CSS to apply styles - called on actual navigation
export function injectCSS() {
  return Promise.all(cssUrls.map(href => {
    // Skip if already loaded
    if (loaded.has(href)) return Promise.resolve()
    // Remove any prefetch link for this href
    const prefetchLink = document.querySelector(\`link[rel="prefetch"][href="\${href}"]\`)
    if (prefetchLink) prefetchLink.remove()
    // Skip if stylesheet already exists in DOM
    if (document.querySelector(\`link[rel="stylesheet"][href="\${href}"]\`)) {
      loaded.add(href)
      return Promise.resolve()
    }
    return new Promise(resolve => {
      const link = document.createElement('link')
      link.rel = 'stylesheet'
      link.href = href
      const timeoutId = setTimeout(() => {
        console.warn('[one] CSS load timeout:', href)
        loaded.add(href)
        resolve()
      }, CSS_TIMEOUT)
      link.onload = link.onerror = () => {
        clearTimeout(timeoutId)
        loaded.add(href)
        resolve()
      }
      document.head.appendChild(link)
    })
  }))
}

// For backwards compatibility, also prefetch on import
prefetchCSS()
`;
    t0 = performance.now();
    await import_fs_extra.default.writeFile((0, import_path.join)(clientDir, urlPathToFilePath(cssPreloadPath)), cssPreloadContent);
    recordTiming("writeCSSPreload", performance.now() - t0);
    t0 = performance.now();
    var exported = await import((0, import_toAbsolute.toAbsolute)(serverJsPath));
    recordTiming("importServerModule", performance.now() - t0);
    var loaderProps = {
      path,
      params
    };
    var matches = [];
    t0 = performance.now();
    if ((_foundRoute_layouts = foundRoute.layouts) === null || _foundRoute_layouts === void 0 ? void 0 : _foundRoute_layouts.length) {
      var layoutResults = await Promise.all(foundRoute.layouts.map(async function (layout) {
        try {
          var _layoutExported_loader;
          var layoutServerPath = layout.loaderServerPath;
          if (!layoutServerPath) {
            return {
              contextKey: layout.contextKey,
              loaderData: void 0
            };
          }
          var serverDir = (0, import_path.join)(clientDir, "..", "server");
          var layoutExported = await import((0, import_toAbsolute.toAbsolute)((0, import_path.join)(serverDir, layoutServerPath)));
          var layoutLoaderData = await (layoutExported === null || layoutExported === void 0 ? void 0 : (_layoutExported_loader = layoutExported.loader) === null || _layoutExported_loader === void 0 ? void 0 : _layoutExported_loader.call(layoutExported, loaderProps));
          return {
            contextKey: layout.contextKey,
            loaderData: layoutLoaderData
          };
        } catch (err) {
          if ((0, import_isResponse.isResponse)(err)) {
            throw err;
          }
          console.warn(`[one] Warning: layout loader failed for ${layout.contextKey}:`, err);
          return {
            contextKey: layout.contextKey,
            loaderData: void 0
          };
        }
      }));
      var _iteratorNormalCompletion1 = true,
        _didIteratorError1 = false,
        _iteratorError1 = void 0;
      try {
        for (var _iterator1 = layoutResults[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
          var result = _step1.value;
          matches.push({
            routeId: result.contextKey,
            pathname: path,
            params: params || {},
            loaderData: result.loaderData
          });
        }
      } catch (err) {
        _didIteratorError1 = true;
        _iteratorError1 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
            _iterator1.return();
          }
        } finally {
          if (_didIteratorError1) {
            throw _iteratorError1;
          }
        }
      }
    }
    recordTiming("layoutLoaders", performance.now() - t0);
    t0 = performance.now();
    var loaderRedirectInfo = null;
    if (exported.loader && foundRoute.type !== "ssr") {
      var _loaderData_constructor;
      try {
        var _ref;
        var _exported_loader;
        loaderData = (_ref = await ((_exported_loader = exported.loader) === null || _exported_loader === void 0 ? void 0 : _exported_loader.call(exported, loaderProps))) !== null && _ref !== void 0 ? _ref : null;
      } catch (err) {
        if ((0, import_isResponse.isResponse)(err)) {
          loaderRedirectInfo = extractRedirectInfo(err);
        } else {
          throw err;
        }
      }
      if (!loaderRedirectInfo && loaderData && ((0, import_isResponse.isResponse)(loaderData) || _instanceof(loaderData, Response) || (loaderData === null || loaderData === void 0 ? void 0 : (_loaderData_constructor = loaderData.constructor) === null || _loaderData_constructor === void 0 ? void 0 : _loaderData_constructor.name) === "Response")) {
        loaderRedirectInfo = extractRedirectInfo(loaderData);
        loaderData = {};
      }
      if (clientJsPath) {
        var loaderPartialPath = (0, import_path.join)(clientDir, urlPathToFilePath((0, import_cleanUrl.getLoaderPath)(path)));
        var uncachedNativePath = loaderPartialPath.replace(constants.LOADER_JS_POSTFIX, import_constants.LOADER_JS_POSTFIX_UNCACHED).replace(/\.js$/, ".native.js");
        if (loaderRedirectInfo) {
          var redirectData = JSON.stringify({
            __oneRedirect: loaderRedirectInfo.path,
            __oneRedirectStatus: loaderRedirectInfo.status
          });
          await outputFile(loaderPartialPath, `export function loader(){return ${redirectData}}`);
          var nativeCjs = `exports.loader = function(){return ${redirectData}}`;
          await outputFile(loaderPartialPath.replace(/\.js$/, ".native.js"), nativeCjs);
          await outputFile(uncachedNativePath, nativeCjs);
          loaderPath = (0, import_cleanUrl.getLoaderPath)(path);
          loaderData = {};
        } else {
          var code = await readFile(clientJsPath, "utf-8");
          var withLoader =
          // super dirty to quickly make ssr loaders work until we have better
          `
if (typeof document === 'undefined') globalThis.document = {}
` + (0, import_replaceLoader.replaceLoader)({
            code,
            loaderData
          });
          await outputFile(loaderPartialPath, withLoader);
          var nativeCjs1 = `exports.loader = function(){return ${JSON.stringify(loaderData)}}`;
          await outputFile(loaderPartialPath.replace(/\.js$/, ".native.js"), nativeCjs1);
          await outputFile(uncachedNativePath, nativeCjs1);
          loaderPath = (0, import_cleanUrl.getLoaderPath)(path);
        }
      }
    }
    recordTiming("pageLoader", performance.now() - t0);
    matches.push({
      routeId: foundRoute.file,
      pathname: path,
      params: params || {},
      loaderData
    });
    if (foundRoute.type !== "ssr") {
      var _globalThis___vxrnresetState, _globalThis;
      (_globalThis___vxrnresetState = (_globalThis = globalThis)["__vxrnresetState"]) === null || _globalThis___vxrnresetState === void 0 ? void 0 : _globalThis___vxrnresetState.call(_globalThis);
      if (foundRoute.type === "ssg") {
        var renderPreloads = criticalPreloads || preloads;
        var renderDeferredPreloads = useAfterLCPAggressive ? [] : deferredPreloads;
        t0 = performance.now();
        var html = await render({
          path,
          preloads: renderPreloads,
          deferredPreloads: renderDeferredPreloads,
          loaderProps,
          loaderData,
          css: allCSS,
          cssContents: allCSSContents,
          mode: "ssg",
          routePreloads,
          matches
        });
        recordTiming("ssrRender", performance.now() - t0);
        if (useAfterLCP) {
          html = applyAfterLCPScriptLoad(html, preloads);
        }
        t0 = performance.now();
        await outputFile(htmlOutPath, html);
        recordTiming("writeHTML", performance.now() - t0);
      } else if (foundRoute.type === "spa") {
        var _foundRoute_layouts1;
        var needsSpaShell = (_foundRoute_layouts1 = foundRoute.layouts) === null || _foundRoute_layouts1 === void 0 ? void 0 : _foundRoute_layouts1.some(function (layout) {
          return layout.layoutRenderMode === "ssg" || layout.layoutRenderMode === "ssr";
        });
        if (needsSpaShell) {
          var _globalThis___vxrnresetState1, _globalThis1;
          (_globalThis___vxrnresetState1 = (_globalThis1 = globalThis)["__vxrnresetState"]) === null || _globalThis___vxrnresetState1 === void 0 ? void 0 : _globalThis___vxrnresetState1.call(_globalThis1);
          var renderPreloads1 = criticalPreloads || preloads;
          var renderDeferredPreloads1 = deferredPreloads || [];
          var layoutMatches = matches.slice(0, -1);
          t0 = performance.now();
          var html1 = await render({
            path,
            preloads: renderPreloads1,
            deferredPreloads: renderDeferredPreloads1,
            loaderProps,
            // 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,
            css: allCSS,
            cssContents: allCSSContents,
            mode: "spa-shell",
            routePreloads,
            matches: layoutMatches
          });
          recordTiming("spaShellRender", performance.now() - t0);
          if (useAfterLCP) {
            html1 = applyAfterLCPScriptLoad(html1, preloads);
          }
          t0 = performance.now();
          await outputFile(htmlOutPath, html1);
          recordTiming("writeHTML", performance.now() - t0);
        } else {
          let renderCSSTag2 = function (file, index) {
            var content = allCSSContents === null || allCSSContents === void 0 ? void 0 : allCSSContents[index];
            if (content) {
              return `    <style>${content}</style>`;
            }
            return `    <link rel="stylesheet" href=${file} />`;
          };
          var renderCSSTag = renderCSSTag2;
          var layoutCSSSet = new Set(layoutCSS);
          var layoutCssOutput = allCSS.map(function (file, i) {
            return layoutCSSSet.has(file) ? renderCSSTag2(file, i) : "";
          }).filter(Boolean).join("\n");
          var pageCssOutput = allCSS.map(function (file, i) {
            return !layoutCSSSet.has(file) ? renderCSSTag2(file, i) : "";
          }).filter(Boolean).join("\n");
          var criticalScripts = (criticalPreloads || preloads).map(function (preload) {
            return `   <script type="module" src="${preload}"></script>`;
          }).join("\n");
          await outputFile(htmlOutPath, `<!DOCTYPE html><html><head>
            ${constants.getSpaHeaderElements({
            serverContext: {
              loaderProps,
              loaderData
            }
          })}
            ${layoutCssOutput}
            ${criticalScripts}
            ${pageCssOutput}
          </head><body></body></html>`);
        }
      }
    }
  } catch (err) {
    var errMsg = _instanceof(err, Error) ? `${err.message}
${err.stack}` : `${err}`;
    console.error(`Error building static page at ${path} with id ${relativeId}:

${errMsg}

loaderData:

${JSON.stringify(loaderData || null, null, 2)}
params:

${JSON.stringify(params || null, null, 2)}`);
    console.error(err);
    throw err;
  }
  var middlewares = (foundRoute.middlewares || []).map(function (x) {
    return builtMiddlewares[x.contextKey];
  });
  var cleanPath = path === "/" ? path : removeTrailingSlash(path);
  return {
    type: foundRoute.type,
    css: allCSS,
    layoutCSS,
    cssContents: allCSSContents,
    routeFile: foundRoute.file,
    middlewares,
    cleanPath,
    preloadPath,
    cssPreloadPath,
    loaderPath,
    clientJsPath,
    serverJsPath,
    htmlPath,
    loaderData,
    params,
    path,
    preloads,
    criticalPreloads,
    deferredPreloads
  };
}
async function getRender(serverEntry) {
  try {
    var _serverImport_default_default;
    var serverImport = await import(serverEntry);
    var render = serverImport.default.render || ((_serverImport_default_default = serverImport.default.default) === null || _serverImport_default_default === void 0 ? void 0 : _serverImport_default_default.render);
    if (typeof render !== "function") {
      throw new Error(`didn't find render function in entry: ${serverEntry}`);
    }
    return render;
  } catch (err) {
    console.error(`\u274C Error importing the root entry:`);
    console.error(`  This error happened in the built file: ${serverEntry}`);
    console.error(err["stack"]);
    throw err;
  }
}
function removeTrailingSlash(path) {
  return path.endsWith("/") ? path.slice(0, path.length - 1) : path;
}
function extractRedirectInfo(response) {
  if (response.status >= 300 && response.status < 400) {
    var location = response.headers.get("location");
    if (location) {
      try {
        var url = new URL(location);
        return {
          path: url.pathname + url.search + url.hash,
          status: response.status
        };
      } catch (unused) {
        return {
          path: location,
          status: response.status
        };
      }
    }
  }
  return null;
}
function applyAfterLCPScriptLoad(html, preloads) {
  html = html.replace(/<script\s+type="module"[^>]*async[^>]*><\/script>/gi, "");
  var loaderScript = `
<script>
(function() {
  var scripts = ${JSON.stringify(preloads)};
  function loadScripts() {
    scripts.forEach(function(src) {
      var script = document.createElement('script');
      script.type = 'module';
      script.src = src;
      document.head.appendChild(script);
    });
  }
  function waitIdle(n) {
    if (n <= 0) {
      requestAnimationFrame(function() {
        requestAnimationFrame(loadScripts);
      });
      return;
    }
    setTimeout(function() {
      setTimeout(function() {
        waitIdle(n - 1);
      }, 0);
    }, 0);
  }
  waitIdle(5);
})();
</script>`;
  html = html.replace("</head>", `${loaderScript}</head>`);
  return html;
}
//# sourceMappingURL=buildPage.native.js.map