feat: add vercel-static and netlify-static presets

src/build.ts

@@ -288,9 +288,10 @@ async function _build(nitro: Nitro, rollupConfig: RollupConfig) {
         await generateFSTree(nitro.options.output.serverDir)
       );
     }
-    await nitro.hooks.callHook("compiled", nitro);
   }
 
+  await nitro.hooks.callHook("compiled", nitro);
+
   // Show deploy and preview hints
   const rOutput = relative(process.cwd(), nitro.options.output.dir);
   const rewriteRelativePaths = (input: string) => {

src/options.ts

@@ -109,7 +109,6 @@ export async function loadOptions(
   // Preset
   let presetOverride =
     (configOverrides.preset as string) || process.env.NITRO_PRESET;
-  const defaultPreset = detectTarget() || "node-server";
   if (configOverrides.dev) {
     presetOverride = "nitro-dev";
   }
@@ -126,7 +125,7 @@ export async function loadOptions(
       preset: presetOverride,
     },
     defaultConfig: {
-      preset: defaultPreset,
+      preset: detectTarget() || "node-server",
     },
     defaults: NitroDefaults,
     resolve(id: string) {
@@ -149,7 +148,7 @@ export async function loadOptions(
   options.preset =
     presetOverride ||
     (layers.find((l) => l.config.preset)?.config.preset as string) ||
-    defaultPreset;
+    (detectTarget({ static: !options.build }) ?? "node-server");
 
   options.rootDir = resolve(options.rootDir || ".");
   options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(

src/presets/netlify.ts

@@ -75,23 +75,48 @@ export const netlifyEdge = defineNitroPreset({
   },
 });
 
+export const netlifyStatic = defineNitroPreset({
+  extends: "static",
+  output: {
+    publicDir: "{{ rootDir }}/dist",
+  },
+  commands: {
+    preview: "npx serve ./static",
+  },
+  hooks: {
+    async compiled(nitro: Nitro) {
+      await writeHeaders(nitro);
+      await writeRedirects(nitro);
+    },
+  },
+});
+
 async function writeRedirects(nitro: Nitro) {
   const redirectsPath = join(nitro.options.output.publicDir, "_redirects");
-  let contents = "/* /.netlify/functions/server 200";
+  const staticFallback = existsSync(
+    join(nitro.options.output.publicDir, "404.html")
+  )
+    ? "/* /404.html 404"
+    : "";
+  let contents = nitro.options.build
+    ? "/* /.netlify/functions/server 200"
+    : staticFallback;
 
   const rules = Object.entries(nitro.options.routeRules).sort(
     (a, b) => a[0].split(/\/(?!\*)/).length - b[0].split(/\/(?!\*)/).length
   );
 
-  // Rewrite static ISR paths to builder functions
-  for (const [key, value] of rules.filter(
-    ([_, value]) => value.isr !== undefined
-  )) {
-    contents = value.isr
-      ? `${key.replace("/**", "/*")}\t/.netlify/builders/server 200\n` +
-        contents
-      : `${key.replace("/**", "/*")}\t/.netlify/functions/server 200\n` +
-        contents;
+  if (nitro.options.build) {
+    // Rewrite static ISR paths to builder functions
+    for (const [key, value] of rules.filter(
+      ([_, value]) => value.isr !== undefined
+    )) {
+      contents = value.isr
+        ? `${key.replace("/**", "/*")}\t/.netlify/builders/server 200\n` +
+          contents
+        : `${key.replace("/**", "/*")}\t/.netlify/functions/server 200\n` +
+          contents;
+    }
   }
 
   for (const [key, routeRules] of rules.filter(

src/presets/vercel.ts

@@ -114,12 +114,30 @@ export const vercelEdge = defineNitroPreset({
   },
 });
 
+export const vercelStatic = defineNitroPreset({
+  extends: "static",
+  output: {
+    dir: "{{ rootDir }}/.vercel/output",
+    publicDir: "{{ output.dir }}/static",
+  },
+  commands: {
+    preview: "npx serve ./static",
+  },
+  hooks: {
+    async compiled(nitro: Nitro) {
+      const buildConfigPath = resolve(nitro.options.output.dir, "config.json");
+      const buildConfig = generateBuildConfig(nitro);
+      await writeFile(buildConfigPath, JSON.stringify(buildConfig, null, 2));
+    },
+  },
+});
+
 function generateBuildConfig(nitro: Nitro) {
   const rules = Object.entries(nitro.options.routeRules).sort(
     (a, b) => b[0].split(/\/(?!\*)/).length - a[0].split(/\/(?!\*)/).length
   );
 
-  return defu(nitro.options.vercel?.config, <VercelBuildConfigV3>{
+  const config = defu(nitro.options.vercel?.config, <VercelBuildConfigV3>{
     version: 3,
     overrides: {
       // Nitro static prerendered route overrides
@@ -163,50 +181,60 @@ function generateBuildConfig(nitro: Nitro) {
           continue: true,
         })),
       { handle: "filesystem" },
-      // ISR rules
-      ...rules
-        .filter(
-          ([key, value]) =>
-            // value.isr === false || (value.isr && key.includes("/**"))
-            value.isr !== undefined
-        )
-        .map(([key, value]) => {
-          const src = key.replace(/^(.*)\/\*\*/, "(?<url>$1/.*)");
-          if (value.isr === false) {
-            // we need to write a rule to avoid route being shadowed by another cache rule elsewhere
-            return {
-              src,
-              dest: "/__nitro",
-            };
-          }
+    ],
+  });
+
+  // Early return if we are not building a serverless function
+  if (!nitro.options.build) {
+    return config;
+  }
+
+  config.routes.push(
+    // ISR rules
+    ...rules
+      .filter(
+        ([key, value]) =>
+          // value.isr === false || (value.isr && key.includes("/**"))
+          value.isr !== undefined
+      )
+      .map(([key, value]) => {
+        const src = key.replace(/^(.*)\/\*\*/, "(?<url>$1/.*)");
+        if (value.isr === false) {
+          // we need to write a rule to avoid route being shadowed by another cache rule elsewhere
           return {
             src,
-            dest:
-              nitro.options.preset === "vercel-edge"
-                ? "/__nitro?url=$url"
-                : generateEndpoint(key) + "?url=$url",
+            dest: "/__nitro",
           };
-        }),
-      // If we are using an ISR function for /, then we need to write this explicitly
-      ...(nitro.options.routeRules["/"]?.isr
-        ? [
-            {
-              src: "(?<url>/)",
-              dest: "/__nitro-index",
-            },
-          ]
-        : []),
-      // If we are using an ISR function as a fallback, then we do not need to output the below fallback route as well
-      ...(!nitro.options.routeRules["/**"]?.isr
-        ? [
-            {
-              src: "/(.*)",
-              dest: "/__nitro",
-            },
-          ]
-        : []),
-    ],
-  });
+        }
+        return {
+          src,
+          dest:
+            nitro.options.preset === "vercel-edge"
+              ? "/__nitro?url=$url"
+              : generateEndpoint(key) + "?url=$url",
+        };
+      }),
+    // If we are using an ISR function for /, then we need to write this explicitly
+    ...(nitro.options.routeRules["/"]?.isr
+      ? [
+          {
+            src: "(?<url>/)",
+            dest: "/__nitro-index",
+          },
+        ]
+      : []),
+    // If we are using an ISR function as a fallback, then we do not need to output the below fallback route as well
+    ...(!nitro.options.routeRules["/**"]?.isr
+      ? [
+          {
+            src: "/(.*)",
+            dest: "/__nitro",
+          },
+        ]
+      : [])
+  );
+
+  return config;
 }
 
 function generateEndpoint(url: string) {

src/utils/index.ts

@@ -111,8 +111,17 @@ const autodetectableProviders: Partial<
   cleavr: "cleavr",
 };
 
-export function detectTarget() {
-  return autodetectableProviders[provider];
+const autodetectableStaticProviders: Partial<
+  Record<ProviderName, KebabCase<keyof typeof _PRESETS>>
+> = {
+  netlify: "netlify-static",
+  vercel: "vercel-static",
+};
+
+export function detectTarget(options: { static?: boolean } = {}) {
+  return options?.static
+    ? autodetectableStaticProviders[provider]
+    : autodetectableProviders[provider];
 }
 
 export async function isDirectory(path: string) {