one/dist/esm/vercel/build/buildVercelOutputDirectory.native.js

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

import { join, resolve } from "path";
import FSExtra from "fs-extra";
import { isMatching, P } from "ts-pattern";
import { vercelBuildOutputConfigBase } from "./config/vc-build-output-config-base.native.js";
import { serverlessVercelPackageJson } from "./config/vc-package-base.native.js";
import { createApiServerlessFunction } from "./generate/createApiServerlessFunction.native.js";
import { createSsrServerlessFunction } from "./generate/createSsrServerlessFunction.native.js";
import { getPathFromRoute } from "./getPathFromRoute.native.js";
var {
  copy,
  ensureDir,
  existsSync,
  writeJSON
} = FSExtra;
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(function (r) {
    return r.middlewares && r.middlewares.length > 0;
  }).map(function (r) {
    return [r.namedRegex, r.middlewares.map(function (m) {
      return m.contextKey.startsWith("dist/middlewares/") ? m.contextKey.substring(17) : m.contextKey;
    })];
  }).sort(function (a, b) {
    return b[0].length - a[0].length;
  });
}
var buildVercelOutputDirectory = async function (param) {
  var {
      apiOutput,
      buildInfoForWriting,
      clientDir,
      oneOptionsRoot,
      postBuildLogs
    } = param,
    {
      routeToBuildInfo
    } = buildInfoForWriting;
  if (apiOutput) {
    var _apiOutput_output,
      compiltedApiRoutes = ((_apiOutput_output = apiOutput?.output) !== null && _apiOutput_output !== void 0 ? _apiOutput_output : []).filter(function (o) {
        return isMatching({
          code: P.string,
          facadeModuleId: P.string
        }, o);
      }),
      _iteratorNormalCompletion = !0,
      _didIteratorError = !1,
      _iteratorError = void 0;
    try {
      for (var _loop = async function () {
          var route2 = _step.value,
            compiledRoute = compiltedApiRoutes.find(function (compiled) {
              var flag = compiled.facadeModuleId.includes(route2.file.replace("./", ""));
              return flag;
            });
          compiledRoute ? (postBuildLogs.push(`[one.build][vercel] generating serverless function for apiRoute ${route2.page}`), await createApiServerlessFunction(route2, compiledRoute.code, oneOptionsRoot, postBuildLogs)) : console.warn(`
 \u{1F528}[one.build][vercel] apiRoute missing code compilation for`, route2.file);
        }, _iterator = buildInfoForWriting.manifest.apiRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) await _loop();
    } catch (err) {
      _didIteratorError = !0, _iteratorError = err;
    } finally {
      try {
        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
      } finally {
        if (_didIteratorError) throw _iteratorError;
      }
    }
  }
  var vercelOutputFunctionsDir = join(oneOptionsRoot, ".vercel/output/functions");
  await ensureDir(vercelOutputFunctionsDir);
  var _iteratorNormalCompletion1 = !0,
    _didIteratorError1 = !1,
    _iteratorError1 = void 0;
  try {
    for (var _iterator1 = buildInfoForWriting.manifest.pageRoutes[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
      var route = _step1.value;
      switch (route.type) {
        case "ssr":
          {
            var builtPageRoute = routeToBuildInfo[route.file];
            builtPageRoute && (postBuildLogs.push(`[one.build][vercel] generate serverless function for ${route.page} with ${route.type}`), await createSsrServerlessFunction(route, buildInfoForWriting, oneOptionsRoot, postBuildLogs));
            break;
          }
        default:
          break;
      }
    }
  } catch (err) {
    _didIteratorError1 = !0, _iteratorError1 = err;
  } finally {
    try {
      !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
    } finally {
      if (_didIteratorError1) throw _iteratorError1;
    }
  }
  var distMiddlewareDir = resolve(join(oneOptionsRoot, "dist", "middlewares"));
  if (existsSync(distMiddlewareDir)) {
    var vercelMiddlewareDir = resolve(join(oneOptionsRoot, ".vercel/output/functions/_middleware.func"));
    await ensureDir(vercelMiddlewareDir), postBuildLogs.push(`[one.build][vercel] copying middlewares from ${distMiddlewareDir} to ${vercelMiddlewareDir}`), await moveAllFiles(resolve(join(oneOptionsRoot, "dist", "middlewares")), vercelMiddlewareDir);
    var vercelMiddlewarePackageJsonFilePath = resolve(join(vercelMiddlewareDir, "package.json"));
    postBuildLogs.push(`[one.build][vercel] writing package.json to ${vercelMiddlewarePackageJsonFilePath}`), await writeJSON(vercelMiddlewarePackageJsonFilePath, serverlessVercelPackageJson);
    var wrappedMiddlewareEntryPointFilename = "_wrapped_middleware.js",
      wrappedMiddlewareEntryPointPath = resolve(join(vercelMiddlewareDir, wrappedMiddlewareEntryPointFilename)),
      middlewaresByNamedRegex = getMiddlewaresByNamedRegex(buildInfoForWriting),
      middlewaresToVariableNameMap = middlewaresByNamedRegex.reduce(function (acc, param2) {
        var [namedRegex, middlewares] = param2;
        return (Array.isArray(middlewares) ? middlewares : [middlewares]).forEach(function (middleware) {
          var middlewareVariableName = middleware.replace(/\.[a-z]+$/, "").replaceAll("/", "_");
          acc[middleware] = middlewareVariableName;
        }), acc;
      }, {});
    await FSExtra.writeFile(wrappedMiddlewareEntryPointPath, `
const middlewaresByNamedRegex = ${JSON.stringify(middlewaresByNamedRegex)}
${Object.entries(middlewaresToVariableNameMap).map(function (param2) {
      var [path, variableName] = param2;
      return `import ${variableName} from './${path}'`;
    }).join(`
`)}

function getMiddleware(path) {
  switch (path){
      ${Object.entries(middlewaresToVariableNameMap).map(function (param2) {
      var [path, variableName] = param2;
      return `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 }
  `);
    var middlewareVercelConfigFilePath = resolve(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
    });
  }
  var vercelOutputStaticDir = resolve(join(oneOptionsRoot, ".vercel/output/static"));
  await ensureDir(vercelOutputStaticDir), postBuildLogs.push(`[one.build][vercel] copying static files from ${clientDir} to ${vercelOutputStaticDir}`), await moveAllFiles(clientDir, vercelOutputStaticDir);
  var ssrLoaderRoutes = buildInfoForWriting.manifest.pageRoutes.filter(function (r) {
      return r.type === "ssr";
    }).map(function (r) {
      var pagePath = getPathFromRoute(r) || "/",
        cleanPath = pagePath.slice(1).replace(/\//g, "_"),
        loaderPattern = cleanPath.replace(/:([^_]+)/g, "(?<$1>[^_]+)"),
        src = `^/assets/${loaderPattern}(?:_refetch_\\d+)?_\\d+_vxrn_loader\\.js$`,
        dest = `${pagePath}?__loader=1`,
        paramMatches = cleanPath.match(/:([^_]+)/g);
      if (paramMatches) {
        var _iteratorNormalCompletion2 = !0,
          _didIteratorError2 = !1,
          _iteratorError2 = void 0;
        try {
          for (var _iterator2 = paramMatches[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
            var match = _step2.value,
              paramName = match.slice(1);
            dest += `&${paramName}=$${paramName}`;
          }
        } catch (err) {
          _didIteratorError2 = !0, _iteratorError2 = err;
        } finally {
          try {
            !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
          } finally {
            if (_didIteratorError2) throw _iteratorError2;
          }
        }
      }
      return {
        src,
        dest
      };
    }),
    vercelConfigFilePath = resolve(join(oneOptionsRoot, ".vercel/output", "config.json"));
  await writeJSON(vercelConfigFilePath, {
    ...vercelBuildOutputConfigBase,
    routes: [...vercelBuildOutputConfigBase.routes, ...(existsSync(distMiddlewareDir) ? [{
      src: "/(.*)",
      middlewarePath: "_middleware",
      continue: !0
    }] : []), {
      handle: "rewrite"
    },
    // SSR loader routes must come before dynamic page routes
    ...ssrLoaderRoutes, ...buildInfoForWriting.manifest.allRoutes.filter(function (r) {
      return r.routeKeys && Object.keys(r.routeKeys).length > 0;
    }).map(function (r) {
      return {
        src: r.namedRegex,
        dest: `${getPathFromRoute(r) || "/"}?${Object.entries(r.routeKeys).map(function (param2) {
          var [k, v] = param2;
          return `${k}=$${v}`;
        }).join("&")}`
      };
    })]
  }), postBuildLogs.push(`[one.build] wrote vercel config to: ${vercelConfigFilePath}`);
};
export { buildVercelOutputDirectory };
//# sourceMappingURL=buildVercelOutputDirectory.native.js.map