vite-plugin-vercel 0.0.3 → 0.0.6

package/dist/index.cjs

@@ -0,0 +1,424 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => allPlugins
+});
+module.exports = __toCommonJS(src_exports);
+var import_promises5 = __toESM(require("fs/promises"), 1);
+
+// src/utils.ts
+var import_vite = require("vite");
+var import_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+function getRoot(config) {
+  return (0, import_vite.normalizePath)(config.root || process.cwd());
+}
+function getOutDir(config, force) {
+  const p = (0, import_vite.normalizePath)(config.build.outDir);
+  if (!force)
+    return p;
+  return import_path.default.join(import_path.default.dirname(p), force);
+}
+function getOutput(config, suffix) {
+  var _a, _b;
+  return import_path.default.join(((_a = config.vercel) == null ? void 0 : _a.outDir) ? "" : getRoot(config), ((_b = config.vercel) == null ? void 0 : _b.outDir) ?? ".vercel/output", suffix ?? "");
+}
+function pathRelativeToApi(filePath, config) {
+  const root = getRoot(config);
+  return (0, import_vite.normalizePath)(import_path.default.relative(import_path.default.join(root, "api"), filePath));
+}
+async function copyDir(src, dest) {
+  await import_promises.default.mkdir(dest, { recursive: true });
+  const entries = await import_promises.default.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_path.default.join(src, entry.name);
+    const destPath = import_path.default.join(dest, entry.name);
+    entry.isDirectory() ? await copyDir(srcPath, destPath) : await import_promises.default.copyFile(srcPath, destPath);
+  }
+}
+
+// src/config.ts
+var import_path2 = __toESM(require("path"), 1);
+
+// src/schemas/config/config.ts
+var import_zod = require("zod");
+var HasOrMissing = import_zod.z.array(import_zod.z.union([
+  import_zod.z.object({
+    type: import_zod.z.literal("host"),
+    value: import_zod.z.string()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("header"),
+    key: import_zod.z.string(),
+    value: import_zod.z.string().optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("cookie"),
+    key: import_zod.z.string(),
+    value: import_zod.z.string().optional()
+  }).strict(),
+  import_zod.z.object({
+    type: import_zod.z.literal("query"),
+    key: import_zod.z.string(),
+    value: import_zod.z.string().optional()
+  }).strict()
+])).optional();
+var vercelOutputConfigSchema = import_zod.z.object({
+  version: import_zod.z.literal(3),
+  routes: import_zod.z.array(import_zod.z.union([
+    import_zod.z.object({
+      src: import_zod.z.string(),
+      dest: import_zod.z.string().optional(),
+      headers: import_zod.z.record(import_zod.z.string()).optional(),
+      methods: import_zod.z.array(import_zod.z.string()).optional(),
+      status: import_zod.z.number().int().positive().optional(),
+      continue: import_zod.z.boolean().optional(),
+      check: import_zod.z.boolean().optional(),
+      missing: HasOrMissing,
+      has: HasOrMissing,
+      locale: import_zod.z.object({
+        redirect: import_zod.z.record(import_zod.z.string()).optional(),
+        cookie: import_zod.z.string().optional()
+      }).strict().optional(),
+      middlewarePath: import_zod.z.string().optional()
+    }).strict(),
+    import_zod.z.object({
+      handle: import_zod.z.union([
+        import_zod.z.literal("rewrite"),
+        import_zod.z.literal("filesystem"),
+        import_zod.z.literal("resource"),
+        import_zod.z.literal("miss"),
+        import_zod.z.literal("hit"),
+        import_zod.z.literal("error")
+      ]),
+      src: import_zod.z.string().optional(),
+      dest: import_zod.z.string().optional(),
+      status: import_zod.z.number().optional()
+    }).strict()
+  ])).optional(),
+  images: import_zod.z.object({
+    sizes: import_zod.z.tuple([
+      import_zod.z.number().int().positive(),
+      import_zod.z.number().int().positive()
+    ]),
+    domains: import_zod.z.array(import_zod.z.string()).nonempty().optional(),
+    minimumCacheTTL: import_zod.z.number().int().positive().optional(),
+    formats: import_zod.z.union([import_zod.z.literal("image/avif"), import_zod.z.literal("image/webp")]).array().nonempty().optional(),
+    dangerouslyAllowSVG: import_zod.z.boolean().optional(),
+    contentSecurityPolicy: import_zod.z.string().optional()
+  }).strict().optional(),
+  wildcard: import_zod.z.array(import_zod.z.object({
+    domain: import_zod.z.string(),
+    value: import_zod.z.string()
+  }).strict()).optional(),
+  overrides: import_zod.z.record(import_zod.z.object({
+    path: import_zod.z.string().optional(),
+    contentType: import_zod.z.string().optional()
+  }).strict()).optional(),
+  cache: import_zod.z.array(import_zod.z.string()).optional()
+}).strict();
+
+// src/config.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_routing_utils = require("@vercel/routing-utils");
+function getConfig(resolvedConfig, config) {
+  var _a, _b, _c, _d, _e;
+  const { routes } = (0, import_routing_utils.getTransformedRoutes)({
+    nowConfig: {
+      cleanUrls: true
+    }
+  });
+  return vercelOutputConfigSchema.parse(__spreadProps(__spreadValues({
+    version: 3
+  }, (_a = resolvedConfig.vercel) == null ? void 0 : _a.config), {
+    routes: [
+      ...routes ?? [],
+      ...(config == null ? void 0 : config.routes) ?? [],
+      ...((_c = (_b = resolvedConfig.vercel) == null ? void 0 : _b.config) == null ? void 0 : _c.routes) ?? []
+    ],
+    overrides: __spreadValues(__spreadValues({}, (_e = (_d = resolvedConfig.vercel) == null ? void 0 : _d.config) == null ? void 0 : _e.overrides), config == null ? void 0 : config.overrides)
+  }));
+}
+function getConfigDestination(resolvedConfig) {
+  return import_path2.default.join(getOutput(resolvedConfig), "config.json");
+}
+async function writeConfig(resolvedConfig, config) {
+  await import_promises2.default.writeFile(getConfigDestination(resolvedConfig), JSON.stringify(getConfig(resolvedConfig, config), void 0, 2), "utf-8");
+}
+
+// src/build.ts
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_esbuild = require("esbuild");
+
+// src/assert.ts
+var import_libassert = require("@brillout/libassert");
+var libName = "vite-plugin-vercel";
+function assert(condition, errorMessage) {
+  if (condition) {
+    return;
+  }
+  const err = (0, import_libassert.newError)(`[${libName}][Wrong Usage] ${errorMessage}`, 2);
+  throw err;
+}
+
+// src/schemas/config/vc-config.ts
+var import_zod2 = require("zod");
+var vercelOutputEdgeVcConfigSchema = import_zod2.z.object({
+  runtime: import_zod2.z.literal("edge"),
+  entrypoint: import_zod2.z.string(),
+  envVarsInUse: import_zod2.z.array(import_zod2.z.string()).optional()
+}).strict();
+var vercelOutputServerlessVcConfigSchema = import_zod2.z.object({
+  runtime: import_zod2.z.string(),
+  handler: import_zod2.z.string(),
+  memory: import_zod2.z.number().int().min(128).max(3008).optional(),
+  maxDuration: import_zod2.z.number().int().positive().optional(),
+  environment: import_zod2.z.record(import_zod2.z.string()).optional(),
+  regions: import_zod2.z.array(import_zod2.z.string()).optional()
+}).strict();
+var vercelOutputServerlessNodeVcConfigSchema = vercelOutputServerlessVcConfigSchema.extend({
+  launcherType: import_zod2.z.literal("Nodejs"),
+  shouldAddHelpers: import_zod2.z.boolean().optional(),
+  shouldAddSourcemapSupport: import_zod2.z.boolean().optional(),
+  awsLambdaHandler: import_zod2.z.string().optional()
+}).strict();
+var vercelOutputVcConfigSchema = import_zod2.z.union([
+  vercelOutputEdgeVcConfigSchema,
+  vercelOutputServerlessVcConfigSchema,
+  vercelOutputServerlessNodeVcConfigSchema
+]);
+
+// src/build.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+function getAdditionalEndpoints(resolvedConfig) {
+  var _a;
+  return (((_a = resolvedConfig.vercel) == null ? void 0 : _a.additionalEndpoints) ?? []).map((e) => __spreadProps(__spreadValues({}, e), {
+    destination: e.destination + ".func"
+  }));
+}
+function getEntries(resolvedConfig) {
+  const apiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_path3.default.basename(filepath).startsWith("_"));
+  return apiEntries.reduce((entryPoints, filePath) => {
+    const outFilePath = pathRelativeToApi(filePath, resolvedConfig);
+    const parsed = import_path3.default.parse(outFilePath);
+    const entry = {
+      source: filePath,
+      destination: `api/${import_path3.default.join(parsed.dir, parsed.name)}.func`
+    };
+    entryPoints.push(entry);
+    return entryPoints;
+  }, getAdditionalEndpoints(resolvedConfig));
+}
+var standardBuildOptions = {
+  bundle: true,
+  target: "es2020",
+  format: "cjs",
+  platform: "node",
+  logLevel: "info",
+  minify: true
+};
+async function buildFn(resolvedConfig, entry, buildOptions) {
+  assert(entry.destination.length > 0, `Endpoint ${typeof entry.source === "string" ? entry.source : "-"} does not have build destination`);
+  const outfile = import_path3.default.join(getOutput(resolvedConfig, "functions"), entry.destination, "index.js");
+  const options = Object.assign({}, standardBuildOptions, { outfile });
+  if (buildOptions) {
+    Object.assign(options, buildOptions);
+  }
+  if (!options.stdin) {
+    if (typeof entry.source === "string") {
+      options.entryPoints = [entry.source];
+    } else {
+      assert(typeof entry.source === "object", `\`{ source }\` must be a string or an object`);
+      assert(typeof entry.source.contents === "string", `\`{ contents }\` must be a string`);
+      options.stdin = entry.source;
+    }
+  }
+  await (0, import_esbuild.build)(options);
+  await writeVcConfig(resolvedConfig, entry.destination);
+}
+async function writeVcConfig(resolvedConfig, destination) {
+  var _a;
+  const vcConfig = import_path3.default.join(getOutput(resolvedConfig, "functions"), destination, ".vc-config.json");
+  await import_promises3.default.writeFile(vcConfig, JSON.stringify(vercelOutputVcConfigSchema.parse({
+    runtime: "nodejs16.x",
+    handler: "index.js",
+    maxDuration: (_a = resolvedConfig.vercel) == null ? void 0 : _a.defaultMaxDuration,
+    launcherType: "Nodejs",
+    shouldAddHelpers: true
+  }), void 0, 2), "utf-8");
+}
+async function buildEndpoints(resolvedConfig) {
+  const entries = getEntries(resolvedConfig);
+  for (const entry of entries) {
+    await buildFn(resolvedConfig, entry);
+  }
+}
+
+// src/prerender.ts
+var import_path4 = __toESM(require("path"), 1);
+
+// src/schemas/config/prerender-config.ts
+var import_zod3 = require("zod");
+var vercelOutputPrerenderConfigSchema = import_zod3.z.object({
+  expiration: import_zod3.z.union([import_zod3.z.number().int().positive(), import_zod3.z.literal(false)]),
+  group: import_zod3.z.number().int().optional(),
+  bypassToken: import_zod3.z.string().optional(),
+  fallback: import_zod3.z.string().optional(),
+  allowQuery: import_zod3.z.array(import_zod3.z.string()).optional()
+}).strict();
+
+// src/prerender.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+function execPrerender(resolvedConfig) {
+  var _a;
+  const prerender = (_a = resolvedConfig.vercel) == null ? void 0 : _a.prerender;
+  if (prerender === false) {
+    return;
+  }
+  return prerender == null ? void 0 : prerender(resolvedConfig);
+}
+var group = 1;
+async function writePrerenderConfig(resolvedConfig, destination, isr) {
+  const parsed = import_path4.default.parse(destination);
+  const outfile = import_path4.default.join(getOutput(resolvedConfig, "functions"), parsed.dir, parsed.name + ".prerender-config.json");
+  await import_promises4.default.mkdir(import_path4.default.join(getOutput(resolvedConfig, "functions"), parsed.dir), { recursive: true });
+  await import_promises4.default.writeFile(outfile, JSON.stringify(vercelOutputPrerenderConfigSchema.parse(__spreadValues({
+    group: group++
+  }, isr)), void 0, 2), "utf-8");
+}
+function getPrerenderSymlinkInfo(resolvedConfig, destination, target) {
+  const parsed = import_path4.default.parse(destination);
+  const targetParsed = import_path4.default.parse(target);
+  return {
+    target: import_path4.default.join(getOutput(resolvedConfig, "functions"), targetParsed.dir, targetParsed.name + ".func"),
+    link: import_path4.default.join(getOutput(resolvedConfig, "functions"), parsed.dir, parsed.name + ".func")
+  };
+}
+async function buildPrerenderConfigs(resolvedConfig) {
+  const isr = await getIsrConfig(resolvedConfig);
+  const entries = Object.entries(isr);
+  const rewrites = [];
+  for (const _a of entries) {
+    const [destination, _b] = _a, _c = _b, { symlink, route } = _c, isr2 = __objRest(_c, ["symlink", "route"]);
+    await writePrerenderConfig(resolvedConfig, destination, isr2);
+    if (symlink) {
+      const info = getPrerenderSymlinkInfo(resolvedConfig, destination, symlink);
+      await copyDir(info.target, info.link);
+    }
+    if (route) {
+      rewrites.push({
+        src: `(${route})`,
+        dest: `${destination}/?__original_path=$1`
+      });
+    }
+  }
+  return rewrites;
+}
+async function getIsrConfig(resolvedConfig) {
+  var _a;
+  const isr = ((_a = resolvedConfig.vercel) == null ? void 0 : _a.isr) ?? {};
+  if (typeof isr === "function") {
+    return await isr();
+  }
+  return isr;
+}
+
+// src/index.ts
+function vercelPlugin() {
+  let resolvedConfig;
+  return {
+    apply: "build",
+    name: "vite-plugin-vercel",
+    enforce: "post",
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    async buildStart() {
+      if (process.env.VERCEL_ENV === "production" && !process.env.ENABLE_FILE_SYSTEM_API) {
+        throw new Error("Missing ENABLE_FILE_SYSTEM_API=1 to your environment variables in your project settings");
+      }
+      if (!resolvedConfig.build.ssr) {
+        await cleanOutputDirectory(resolvedConfig);
+      } else {
+        await copyDistClientToOutputStatic(resolvedConfig);
+      }
+    },
+    async writeBundle() {
+      var _a;
+      if (!((_a = resolvedConfig.build) == null ? void 0 : _a.ssr))
+        return;
+      const overrides = await execPrerender(resolvedConfig);
+      await buildEndpoints(resolvedConfig);
+      const rewrites = await buildPrerenderConfigs(resolvedConfig);
+      await writeConfig(resolvedConfig, {
+        routes: [{ handle: "filesystem" }, ...rewrites],
+        overrides
+      });
+    }
+  };
+}
+async function copyDistClientToOutputStatic(resolvedConfig) {
+  await copyDir(getOutDir(resolvedConfig, "client"), getOutput(resolvedConfig, "static"));
+}
+async function cleanOutputDirectory(resolvedConfig) {
+  await import_promises5.default.rm(getOutput(resolvedConfig), {
+    recursive: true,
+    force: true
+  });
+}
+function allPlugins() {
+  return [vercelPlugin()];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});