vite-plugin-vercel 9.0.6 → 10.0.0-beta.0

package/dist/types-BjqDHPFV.d.ts

@@ -0,0 +1,121 @@
+/// <reference types="@photonjs/core" />
+
+import { Photon } from '@photonjs/core';
+import { Rewrite, Header, Redirect } from '@vercel/routing-utils';
+import { VercelOutputPrerenderConfig, VercelOutputConfig } from '@vite-plugin-vercel/schemas';
+
+type ViteVercelRewrite = Rewrite & {
+    enforce?: "pre" | "post";
+};
+type ViteVercelRedirect = Redirect & {
+    enforce?: "pre" | "post";
+};
+interface ViteVercelConfig {
+    /**
+     * How long Functions should be allowed to run for every request, in seconds.
+     * If left empty, default value for your plan will be used.
+     */
+    defaultMaxDuration?: number;
+    /**
+     * Default expiration time (in seconds) for prerender functions.
+     * Defaults to 86400 seconds (24h).
+     * @see {@link https://vercel.com/docs/concepts/next.js/incremental-static-regeneration}
+     * @see {@link https://vercel.com/docs/build-output-api/v3#vercel-primitives/prerender-functions/configuration}
+     */
+    expiration?: number;
+    /**
+     * @see {@link https://vercel.com/docs/projects/project-configuration#rewrites}
+     */
+    rewrites?: ViteVercelRewrite[];
+    /**
+     * @see {@link https://vercel.com/docs/projects/project-configuration#headers}
+     * @beta
+     */
+    headers?: Header[];
+    /**
+     * @see {@link https://vercel.com/docs/projects/project-configuration#redirects}
+     */
+    redirects?: ViteVercelRedirect[];
+    /**
+     * @see {@link https://vercel.com/docs/projects/project-configuration#cleanurls}
+     */
+    cleanUrls?: boolean;
+    /**
+     * @see {@link https://vercel.com/docs/projects/project-configuration#trailingslash}
+     */
+    trailingSlash?: boolean;
+    /**
+     * When true, the Serverless Function will stream the response to the client.
+     * @see {@link https://vercel.com/docs/build-output-api/v3/primitives#serverless-function-configuration}
+     */
+    defaultSupportsResponseStreaming?: boolean;
+    /**
+     * Use `getEntriesFromFs` for mapping your filesystem routes to entries.
+     * If you are interfacing this plugin with a framework, entries can also be added through the Photon API
+     */
+    entries?: Record<string, Photon.EntryUniversalHandler>;
+    /**
+     * TODO
+     */
+    server?: Photon.EntryServer;
+    /**
+     * Advanced configuration to override .vercel/output/config.json
+     * @see {@link https://vercel.com/docs/build-output-api/v3/configuration#configuration}
+     * @protected
+     */
+    config?: Partial<Omit<VercelOutputConfig, "version">>;
+    /**
+     * Defaults to `.vercel/output`. Mostly useful for testing purpose
+     * @protected
+     */
+    outDir?: string;
+}
+interface VercelOutputIsr extends VercelOutputPrerenderConfig {
+    symlink?: string;
+    route?: string;
+}
+interface VercelEntryOptions {
+    /**
+     * Relative to `.vercel/output/functions`, without extension
+     */
+    destination?: string;
+    /**
+     * If `true`, guesses route for the function, and adds it to config.json (mimics defaults Vercel behavior).
+     * If a string is provided, it will be equivalent to a `rewrites` rule.
+     * Set to `false` to disable
+     */
+    route?: string | boolean;
+    /**
+     * Ensures that the route is added before or after others
+     */
+    enforce?: "post" | "pre";
+    /**
+     * Set to `true` to mark this function as an Edge Function
+     */
+    edge?: boolean;
+    /**
+     * Additional headers
+     */
+    headers?: Record<string, string> | null;
+    /**
+     * ISR config
+     */
+    isr?: VercelOutputIsr;
+    /**
+     * When true, the Serverless Function will stream the response to the client
+     */
+    streaming?: boolean;
+    /**
+     * When true, do not build output files for this entry
+     */
+    disabled?: boolean;
+}
+declare module "@photonjs/core" {
+    namespace Photon {
+        interface EntryBase {
+            vercel?: VercelEntryOptions;
+        }
+    }
+}
+
+export type { ViteVercelConfig as V, ViteVercelRewrite as a, ViteVercelRedirect as b };

package/dist/universal-middleware-dev.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="@photonjs/core" />
+
+import './types-BjqDHPFV.js';
+import { UniversalMiddleware } from '@universal-middleware/core';
+import { Photon } from '@photonjs/core';
+import '@vercel/routing-utils';
+import '@vite-plugin-vercel/schemas';
+
+declare const applyVercelHeaders: UniversalMiddleware<Universal.Context & {
+    photon?: {
+        handler?: Photon.EntryUniversalHandler;
+        server?: Photon.EntryServer;
+    };
+}>;
+declare const _default: UniversalMiddleware[];
+
+export { applyVercelHeaders, _default as default };

package/dist/universal-middleware-dev.js

@@ -0,0 +1,24 @@
+// src/photon/universal-middleware-dev.ts
+import { enhance, MiddlewareOrder } from "@universal-middleware/core";
+var applyVercelHeaders = (_request, context) => {
+  console.log(_request.url, context);
+  const headers = context.photon?.handler?.vercel?.headers ?? context.photon?.server?.vercel?.headers;
+  if (!headers) return;
+  return (response) => {
+    for (const [key, value] of Object.entries(headers)) {
+      response.headers.set(key, value);
+    }
+    return response;
+  };
+};
+var universal_middleware_dev_default = [
+  enhance(applyVercelHeaders, {
+    name: "vercel:headers",
+    immutable: true,
+    order: MiddlewareOrder.HEADER_MANAGEMENT
+  })
+];
+export {
+  applyVercelHeaders,
+  universal_middleware_dev_default as default
+};

package/dist/universal-middleware-prod.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="@photonjs/core" />
+
+import './types-BjqDHPFV.js';
+import { UniversalMiddleware } from '@universal-middleware/core';
+import '@photonjs/core';
+import '@vercel/routing-utils';
+import '@vite-plugin-vercel/schemas';
+
+declare const overrideVercelRequest: UniversalMiddleware;
+declare const _default: UniversalMiddleware[];
+
+export { _default as default, overrideVercelRequest };

package/dist/universal-middleware-prod.js

@@ -0,0 +1,20 @@
+import {
+  getOriginalRequest
+} from "./chunk-YN5MUEL2.js";
+
+// src/photon/universal-middleware-prod.ts
+import { enhance } from "@universal-middleware/core";
+var overrideVercelRequest = (request) => {
+  Object.assign(request, getOriginalRequest(request));
+};
+var universal_middleware_prod_default = [
+  enhance(overrideVercelRequest, {
+    name: "vercel:request",
+    immutable: true,
+    order: Number.MIN_SAFE_INTEGER
+  })
+];
+export {
+  universal_middleware_prod_default as default,
+  overrideVercelRequest
+};

package/dist/utils.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="@photonjs/core" />
+
+import './types-BjqDHPFV.js';
+import { Photon } from '@photonjs/core';
+import '@vercel/routing-utils';
+import '@vite-plugin-vercel/schemas';
+
+declare function getEntriesFromFs(dir: string, { destination, tryParseExports }: {
+    destination?: string | undefined;
+    tryParseExports?: boolean | undefined;
+}): Promise<Record<string, Photon.EntryUniversalHandler>>;
+declare function extractExports(filepath: string): Promise<{
+    edge?: boolean | undefined;
+    headers?: Record<string, string> | undefined;
+    streaming?: boolean | undefined;
+    isr?: {
+        expiration: number | false;
+    } | undefined;
+} | null>;
+
+declare function getOriginalRequest(request: Request): Request;
+
+export { extractExports, getEntriesFromFs, getOriginalRequest };

package/dist/utils.js

@@ -0,0 +1,81 @@
+import {
+  entryToRou3
+} from "./chunk-OCCU6UM5.js";
+import "./chunk-UTQ72LMT.js";
+import {
+  getOriginalRequest
+} from "./chunk-YN5MUEL2.js";
+
+// src/utils/fs-entries.ts
+import path from "path";
+import glob from "fast-glob";
+import { generateCode, loadFile } from "magicast";
+import { normalizePath } from "vite";
+import { vercelEndpointExports } from "@vite-plugin-vercel/schemas";
+async function getEntriesFromFs(dir, { destination = dir, tryParseExports = true }) {
+  const normalizedDir = normalizePath(dir);
+  destination = normalizePath(destination);
+  const apiEntries = glob.sync(`${path.posix.resolve(normalizedDir)}/**/*.?(m)[jt]s?(x)`).filter((filepath) => !path.basename(filepath).startsWith("_"));
+  const entryPoints = {};
+  for (const filePath of apiEntries) {
+    const outFilePath = pathRelativeTo(filePath, normalizedDir);
+    const parsed = path.posix.parse(outFilePath);
+    let xports;
+    if (tryParseExports) {
+      xports = await extractExports(filePath);
+    }
+    const key = path.posix.join(destination, parsed.dir, parsed.name);
+    const entry = {
+      id: filePath,
+      name: key,
+      type: "universal-handler",
+      compositionMode: "isolated",
+      vercel: {
+        route: true,
+        destination: key,
+        edge: xports?.edge,
+        isr: xports?.isr,
+        headers: xports?.headers,
+        streaming: xports?.streaming
+      }
+    };
+    entry.route = entryToRou3(entry)[0];
+    entryPoints[key] = entry;
+  }
+  return entryPoints;
+}
+async function extractExports(filepath) {
+  try {
+    const mod = await loadFile(filepath);
+    const subject = {
+      edge: evalExport(mod.exports.edge),
+      headers: evalExport(mod.exports.headers),
+      streaming: evalExport(mod.exports.streaming),
+      isr: evalExport(mod.exports.isr)
+    };
+    return vercelEndpointExports.parse(subject);
+  } catch (e) {
+    console.warn(`Warning: failed to read exports of '${filepath}'`, e);
+    return null;
+  }
+}
+function pathRelativeTo(filePath, rel) {
+  return normalizePath(path.relative(normalizePath(path.resolve(rel)), path.resolve(filePath)));
+}
+function isPrimitive(test) {
+  return test !== Object(test);
+}
+function _eval(code) {
+  const func = new Function(`{ return function(){ return ${code} } };`);
+  return func.call(null).call(null);
+}
+function evalExport(exp) {
+  if (!exp) return;
+  const code = isPrimitive(exp) ? exp : generateCode(exp).code;
+  return _eval(code);
+}
+export {
+  extractExports,
+  getEntriesFromFs,
+  getOriginalRequest
+};

package/index.d.ts

@@ -1,10 +1,2 @@
-import type { ViteVercelConfig } from "./dist";
-
 export * from "./dist";
 export { default } from "./dist";
-
-declare module "vite" {
-  export interface UserConfig {
-    vercel?: ViteVercelConfig;
-  }
-}

package/package.json

@@ -1,59 +1,56 @@
 {
   "name": "vite-plugin-vercel",
-  "version": "9.0.6",
+  "version": "10.0.0-beta.0",
   "type": "module",
   "files": [
     "dist",
     "*.d.ts"
   ],
-  "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
+    ".": "./dist/index.js",
+    "./universal-middleware": "./dist/universal-middleware-prod.js",
+    "./universal-middleware/dev": "./dist/universal-middleware-dev.js",
+    "./utils": "./dist/utils.js",
+    "./api": "./dist/api.js",
     "./types": {
       "types": "./index.d.ts"
     }
   },
-  "types": "./index.d.ts",
   "description": "Vercel adapter for vite",
   "author": "Joël Charles <joel.charles91@gmail.com>",
   "repository": "https://github.com/magne4000/vite-plugin-vercel",
   "license": "MIT",
   "peerDependencies": {
-    "vike": "*",
-    "vite": "^4.4 || ^5.0.2 || ^6",
-    "@vite-plugin-vercel/vike": "9.0.5"
-  },
-  "peerDependenciesMeta": {
-    "@vite-plugin-vercel/vike": {
-      "optional": true
-    },
-    "vike": {
-      "optional": true
-    }
+    "vite": ">=7.1"
   },
   "devDependencies": {
-    "@types/node": "^18.19.54",
-    "tsup": "^8.3.5",
-    "typescript": "^5.6.3",
-    "vike": "^0.4.229",
-    "vite": "^6.3.5",
-    "@vite-plugin-vercel/vike": "9.0.5"
+    "@types/node": "^20.19.13",
+    "@universal-middleware/express": "^0.4.19",
+    "@vercel/node": "^5.3.21",
+    "rollup": "^4.50.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.5"
   },
   "dependencies": {
     "@brillout/libassert": "^0.5.8",
-    "@manypkg/find-root": "^2.2.3",
-    "@vercel/build-utils": "^8.4.12",
-    "@vercel/nft": "^0.27.6",
-    "@vercel/routing-utils": "^3.1.0",
-    "esbuild": "^0.24.0",
-    "fast-glob": "^3.3.2",
+    "@manypkg/find-root": "^3.1.0",
+    "@photonjs/core": "^0.0.13",
+    "@photonjs/runtime": "^0.0.10",
+    "@universal-middleware/core": "^0.4.10",
+    "@universal-middleware/vercel": "^0.4.22",
+    "@vercel/build-utils": "^12.1.0",
+    "@vercel/nft": "^0.30.1",
+    "@vercel/routing-utils": "^5.1.1",
+    "convert-route": "^0.1.1",
+    "esbuild": "^0.25.9",
+    "fast-glob": "^3.3.3",
     "magicast": "^0.3.5",
-    "zod": "^3.23.8"
+    "path-to-regexp": "^8.3.0",
+    "strip-ansi": "^7.1.2",
+    "vite-plugin-wasm": "^3.5.0",
+    "@vite-plugin-vercel/schemas": "^1.0.0"
   },
   "scripts": {
     "build": "tsup",