one/dist/cjs/vercel/build/buildVercelOutputDirectory.js

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

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: !0 });
}, __copyProps = (to, from, except, desc) => {
  if (from && typeof from == "object" || typeof from == "function")
    for (let key of __getOwnPropNames(from))
      !__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: !0 }) : target,
  mod
)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
var buildVercelOutputDirectory_exports = {};
__export(buildVercelOutputDirectory_exports, {
  buildVercelOutputDirectory: () => buildVercelOutputDirectory
});
module.exports = __toCommonJS(buildVercelOutputDirectory_exports);
var import_node_path = require("node:path"), import_fs_extra = __toESM(require("fs-extra"), 1), import_ts_pattern = require("ts-pattern"), import_createApiServerlessFunction = require("./generate/createApiServerlessFunction"), import_createSsrServerlessFunction = require("./generate/createSsrServerlessFunction"), import_vc_package_base = require("./config/vc-package-base"), import_vc_build_output_config_base = require("./config/vc-build-output-config-base"), import_getPathFromRoute = require("./getPathFromRoute");
const { copy, ensureDir, existsSync, writeJSON } = import_fs_extra.default;
async function moveAllFiles(src, dest) {
  try {
    await copy(src, dest, { overwrite: !0, errorOnExist: !1 });
  } catch (err) {
    console.error("Error moving files:", err);
  }
}
function getMiddlewaresByNamedRegex(buildInfoForWriting) {
  return buildInfoForWriting.manifest.allRoutes.filter((r) => r.middlewares && r.middlewares.length > 0).map((r) => [r.namedRegex, r.middlewares.map((m) => m.contextKey.startsWith("dist/middlewares/") ? m.contextKey.substring(17) : m.contextKey)]).sort((a, b) => b[0].length - a[0].length);
}
const buildVercelOutputDirectory = async ({
  apiOutput,
  buildInfoForWriting,
  clientDir,
  oneOptionsRoot,
  postBuildLogs
}) => {
  const { routeToBuildInfo } = buildInfoForWriting;
  if (apiOutput) {
    const compiltedApiRoutes = (apiOutput?.output ?? []).filter(
      (o) => (0, import_ts_pattern.isMatching)({ code: import_ts_pattern.P.string, facadeModuleId: import_ts_pattern.P.string }, o)
    );
    for (const route of buildInfoForWriting.manifest.apiRoutes) {
      const compiledRoute = compiltedApiRoutes.find((compiled) => compiled.facadeModuleId.includes(route.file.replace("./", "")));
      compiledRoute ? (postBuildLogs.push(
        `[one.build][vercel] generating serverless function for apiRoute ${route.page}`
      ), await (0, import_createApiServerlessFunction.createApiServerlessFunction)(route, compiledRoute.code, oneOptionsRoot, postBuildLogs)) : console.warn(`
 \u{1F528}[one.build][vercel] apiRoute missing code compilation for`, route.file);
    }
  }
  const vercelOutputFunctionsDir = (0, import_node_path.join)(oneOptionsRoot, ".vercel/output/functions");
  await ensureDir(vercelOutputFunctionsDir);
  for (const route of buildInfoForWriting.manifest.pageRoutes)
    switch (route.type) {
      case "ssr": {
        routeToBuildInfo[route.file] && (postBuildLogs.push(
          `[one.build][vercel] generate serverless function for ${route.page} with ${route.type}`
        ), await (0, import_createSsrServerlessFunction.createSsrServerlessFunction)(
          route,
          buildInfoForWriting,
          oneOptionsRoot,
          postBuildLogs
        ));
        break;
      }
      default:
        break;
    }
  const distMiddlewareDir = (0, import_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, "dist", "middlewares"));
  if (existsSync(distMiddlewareDir)) {
    const vercelMiddlewareDir = (0, import_node_path.resolve)(
      (0, import_node_path.join)(oneOptionsRoot, ".vercel/output/functions/_middleware.func")
    );
    await ensureDir(vercelMiddlewareDir), postBuildLogs.push(
      `[one.build][vercel] copying middlewares from ${distMiddlewareDir} to ${vercelMiddlewareDir}`
    ), await moveAllFiles((0, import_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, "dist", "middlewares")), vercelMiddlewareDir);
    const vercelMiddlewarePackageJsonFilePath = (0, import_node_path.resolve)((0, import_node_path.join)(vercelMiddlewareDir, "package.json"));
    postBuildLogs.push(
      `[one.build][vercel] writing package.json to ${vercelMiddlewarePackageJsonFilePath}`
    ), await writeJSON(vercelMiddlewarePackageJsonFilePath, import_vc_package_base.serverlessVercelPackageJson);
    const wrappedMiddlewareEntryPointFilename = "_wrapped_middleware.js", wrappedMiddlewareEntryPointPath = (0, import_node_path.resolve)(
      (0, import_node_path.join)(vercelMiddlewareDir, wrappedMiddlewareEntryPointFilename)
    ), middlewaresByNamedRegex = getMiddlewaresByNamedRegex(buildInfoForWriting), middlewaresToVariableNameMap = middlewaresByNamedRegex.reduce((acc, [namedRegex, middlewares]) => ((Array.isArray(middlewares) ? middlewares : [middlewares]).forEach((middleware) => {
      const middlewareVariableName = middleware.replace(/\.[a-z]+$/, "").replaceAll("/", "_");
      acc[middleware] = middlewareVariableName;
    }), acc), {});
    await import_fs_extra.default.writeFile(
      wrappedMiddlewareEntryPointPath,
      `
const middlewaresByNamedRegex = ${JSON.stringify(middlewaresByNamedRegex)}
${Object.entries(middlewaresToVariableNameMap).map(([path, variableName]) => `import ${variableName} from './${path}'`).join(`
`)}

function getMiddleware(path) {
  switch (path){
      ${Object.entries(middlewaresToVariableNameMap).map(([path, variableName]) => `case '${path}': return ${variableName}`).join(`
`)}
      default: return null
  }
}

const next = (e) => {
  const t = new Headers(null == e ? void 0 : e.headers)
  t.set('x-middleware-next', '1')
  return new Response(null, { ...e, headers: t })
}

const wrappedMiddlewareFunction = (request, event) => {
  const url = new URL(request.url)
  const pathname = url.pathname
  
  // Find matching middlewares for this request
  const matchingMiddlewares = middlewaresByNamedRegex
    .filter(([namedRegex]) => new RegExp(namedRegex).test(pathname))
    .reduce((prev, current) => prev.length > current[1]?.length ? prev : current[1], []);
  
  // Import and execute the middleware function
  const boundNext = () => {
    if (matchingMiddlewares.length === 0) {
      return next(request)
    }
      
    const middleware = getMiddleware(matchingMiddlewares.shift())
    return middleware ? middleware({request, event, next: boundNext}) : next(request)
  };
  return boundNext()
}

export { wrappedMiddlewareFunction as default }
  `
    );
    const middlewareVercelConfigFilePath = (0, import_node_path.resolve)((0, import_node_path.join)(vercelMiddlewareDir, ".vc-config.json"));
    postBuildLogs.push(
      `[one.build][vercel] writing .vc-config.json to ${middlewareVercelConfigFilePath}`
    ), await writeJSON(middlewareVercelConfigFilePath, {
      runtime: "edge",
      // Seems that middlewares only work with edge runtime
      entrypoint: wrappedMiddlewareEntryPointFilename
    });
  }
  const vercelOutputStaticDir = (0, import_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, ".vercel/output/static"));
  await ensureDir(vercelOutputStaticDir), postBuildLogs.push(
    `[one.build][vercel] copying static files from ${clientDir} to ${vercelOutputStaticDir}`
  ), await moveAllFiles(clientDir, vercelOutputStaticDir);
  const vercelConfigFilePath = (0, import_node_path.resolve)((0, import_node_path.join)(oneOptionsRoot, ".vercel/output", "config.json"));
  await writeJSON(vercelConfigFilePath, {
    ...import_vc_build_output_config_base.vercelBuildOutputConfigBase,
    routes: [
      ...import_vc_build_output_config_base.vercelBuildOutputConfigBase.routes,
      ...existsSync(distMiddlewareDir) ? [
        {
          src: "/(.*)",
          middlewarePath: "_middleware",
          continue: !0
        }
      ] : [],
      {
        handle: "rewrite"
      },
      ...buildInfoForWriting.manifest.allRoutes.filter((r) => r.routeKeys && Object.keys(r.routeKeys).length > 0).map((r) => ({
        src: r.namedRegex,
        dest: `${(0, import_getPathFromRoute.getPathFromRoute)(r) || "/"}?${Object.entries(r.routeKeys).map(([k, v]) => `${k}=$${v}`).join("&")}`
      }))
    ]
  }), postBuildLogs.push(`[one.build] wrote vercel config to: ${vercelConfigFilePath}`);
};
//# sourceMappingURL=buildVercelOutputDirectory.js.map