astro 6.0.0-alpha.0 → 6.0.0-alpha.1

package/dist/core/build/plugins/plugin-middleware.js

@@ -1,13 +1,11 @@
 import { vitePluginMiddlewareBuild } from "../../middleware/vite-plugin.js";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
 function pluginMiddleware(opts, internals) {
+  const plugin = vitePluginMiddlewareBuild(opts, internals);
   return {
-    targets: ["server"],
-    hooks: {
-      "build:before": () => {
-        return {
-          vitePlugin: vitePluginMiddlewareBuild(opts, internals)
-        };
-      }
+    ...plugin,
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     }
   };
 }

package/dist/core/build/plugins/plugin-noop.d.ts

@@ -0,0 +1,3 @@
+import type * as vite from 'vite';
+export declare const NOOP_MODULE_ID = "virtual:astro:noop";
+export declare function pluginNoop(): vite.Plugin;

package/dist/core/build/plugins/plugin-noop.js

@@ -0,0 +1,29 @@
+const NOOP_MODULE_ID = "virtual:astro:noop";
+const RESOLVED_NOOP_MODULE_ID = "\0" + NOOP_MODULE_ID;
+function pluginNoop() {
+  return {
+    name: "plugin-noop",
+    resolveId(id) {
+      if (id === NOOP_MODULE_ID) {
+        return RESOLVED_NOOP_MODULE_ID;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_NOOP_MODULE_ID) {
+        return "export const noop = {};";
+      }
+    },
+    generateBundle(_options, bundle) {
+      for (const [name, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "asset") continue;
+        if (chunk.facadeModuleId === RESOLVED_NOOP_MODULE_ID) {
+          delete bundle[name];
+        }
+      }
+    }
+  };
+}
+export {
+  NOOP_MODULE_ID,
+  pluginNoop
+};

package/dist/core/build/plugins/plugin-prerender.d.ts

@@ -1,4 +1,4 @@
+import type { Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from '../internal.js';
-import type { AstroBuildPlugin } from '../plugin.js';
 import type { StaticBuildOptions } from '../types.js';
-export declare function pluginPrerender(opts: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;
+export declare function pluginPrerender(_opts: StaticBuildOptions, internals: BuildInternals): VitePlugin;

package/dist/core/build/plugins/plugin-prerender.js

@@ -1,75 +1,18 @@
-import { getPrerenderMetadata } from "../../../prerender/metadata.js";
-import { ASTRO_PAGE_RESOLVED_MODULE_ID } from "./plugin-pages.js";
-import { getPagesFromVirtualModulePageName } from "./util.js";
-function vitePluginPrerender(internals) {
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+function pluginPrerender(_opts, internals) {
   return {
     name: "astro:rollup-plugin-prerender",
-    generateBundle(_, bundle) {
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
+    },
+    generateBundle() {
       const moduleIds = this.getModuleIds();
       for (const id of moduleIds) {
         const pageInfo = internals.pagesByViteID.get(id);
         if (!pageInfo) continue;
         const moduleInfo = this.getModuleInfo(id);
         if (!moduleInfo) continue;
-        const prerender = !!getPrerenderMetadata(moduleInfo);
-        pageInfo.route.prerender = prerender;
-      }
-      const nonPrerenderOnlyChunks = getNonPrerenderOnlyChunks(bundle, internals);
-      internals.prerenderOnlyChunks = Object.values(bundle).filter((chunk) => {
-        return chunk.type === "chunk" && !nonPrerenderOnlyChunks.has(chunk);
-      });
-    }
-  };
-}
-function getNonPrerenderOnlyChunks(bundle, internals) {
-  const chunks = Object.values(bundle);
-  const prerenderOnlyEntryChunks = /* @__PURE__ */ new Set();
-  const nonPrerenderOnlyEntryChunks = /* @__PURE__ */ new Set();
-  for (const chunk of chunks) {
-    if (chunk.type === "chunk" && chunk.isEntry) {
-      if (chunk.facadeModuleId?.startsWith(ASTRO_PAGE_RESOLVED_MODULE_ID)) {
-        const pageDatas = getPagesFromVirtualModulePageName(
-          internals,
-          ASTRO_PAGE_RESOLVED_MODULE_ID,
-          chunk.facadeModuleId
-        );
-        const prerender = pageDatas.every((pageData) => pageData.route.prerender);
-        if (prerender) {
-          prerenderOnlyEntryChunks.add(chunk);
-          continue;
-        }
-      }
-      nonPrerenderOnlyEntryChunks.add(chunk);
-    }
-  }
-  const nonPrerenderOnlyChunks = new Set(nonPrerenderOnlyEntryChunks);
-  for (const chunk of nonPrerenderOnlyChunks) {
-    for (const importFileName of chunk.imports) {
-      const importChunk = bundle[importFileName];
-      if (importChunk?.type === "chunk") {
-        nonPrerenderOnlyChunks.add(importChunk);
-      }
-    }
-    for (const dynamicImportFileName of chunk.dynamicImports) {
-      const dynamicImportChunk = bundle[dynamicImportFileName];
-      if (dynamicImportChunk?.type === "chunk" && !prerenderOnlyEntryChunks.has(dynamicImportChunk)) {
-        nonPrerenderOnlyChunks.add(dynamicImportChunk);
-      }
-    }
-  }
-  return nonPrerenderOnlyChunks;
-}
-function pluginPrerender(opts, internals) {
-  if (opts.settings.buildOutput === "static") {
-    return { targets: ["server"] };
-  }
-  return {
-    targets: ["server"],
-    hooks: {
-      "build:before": () => {
-        return {
-          vitePlugin: vitePluginPrerender(internals)
-        };
+        pageInfo.route.prerender = Boolean(moduleInfo?.meta?.astro?.pageOptions?.prerender);
       }
     }
   };

package/dist/core/build/plugins/plugin-scripts.d.ts

@@ -1,3 +1,6 @@
+import type { Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from '../internal.js';
-import type { AstroBuildPlugin } from '../plugin.js';
-export declare function pluginScripts(internals: BuildInternals): AstroBuildPlugin;
+/**
+ * Inline scripts from Astro files directly into the HTML.
+ */
+export declare function pluginScripts(internals: BuildInternals): VitePlugin;

package/dist/core/build/plugins/plugin-scripts.js

@@ -1,8 +1,12 @@
 import { shouldInlineAsset } from "./util.js";
-function vitePluginScripts(internals) {
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+function pluginScripts(internals) {
   let assetInlineLimit;
   return {
     name: "@astro/plugin-scripts",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;
+    },
     configResolved(config) {
       assetInlineLimit = config.build.assetsInlineLimit;
     },
@@ -25,18 +29,6 @@ function vitePluginScripts(internals) {
     }
   };
 }
-function pluginScripts(internals) {
-  return {
-    targets: ["client"],
-    hooks: {
-      "build:before": () => {
-        return {
-          vitePlugin: vitePluginScripts(internals)
-        };
-      }
-    }
-  };
-}
 export {
   pluginScripts
 };

package/dist/core/build/plugins/plugin-ssr.d.ts

@@ -1,5 +1,5 @@
+import type { Plugin as VitePlugin } from 'vite';
 import type { BuildInternals } from '../internal.js';
-import type { AstroBuildPlugin } from '../plugin.js';
 import type { StaticBuildOptions } from '../types.js';
 export declare const RESOLVED_SSR_VIRTUAL_MODULE_ID: string;
-export declare function pluginSSR(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;
+export declare function pluginSSR(options: StaticBuildOptions, internals: BuildInternals): VitePlugin[];

package/dist/core/build/plugins/plugin-ssr.js

@@ -1,20 +1,17 @@
-import { ENTRYPOINT_VIRTUAL_MODULE_ID } from "../../../actions/consts.js";
-import { MIDDLEWARE_MODULE_ID } from "../../middleware/vite-plugin.js";
-import { routeIsRedirect } from "../../redirects/index.js";
-import { VIRTUAL_ISLAND_MAP_ID } from "../../server-islands/vite-plugin-server-islands.js";
-import { addRollupInput } from "../add-rollup-input.js";
-import { SSR_MANIFEST_VIRTUAL_MODULE_ID } from "./plugin-manifest.js";
-import { ASTRO_PAGE_MODULE_ID } from "./plugin-pages.js";
-import { RENDERERS_MODULE_ID } from "./plugin-renderers.js";
-import { getVirtualModulePageName } from "./util.js";
-const SSR_VIRTUAL_MODULE_ID = "@astrojs-ssr-virtual-entry";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../../constants.js";
+const SSR_VIRTUAL_MODULE_ID = "virtual:astro:legacy-ssr-entry";
 const RESOLVED_SSR_VIRTUAL_MODULE_ID = "\0" + SSR_VIRTUAL_MODULE_ID;
-const ADAPTER_VIRTUAL_MODULE_ID = "@astrojs-ssr-adapter";
+const ADAPTER_VIRTUAL_MODULE_ID = "virtual:astro:adapter-entrypoint";
 const RESOLVED_ADAPTER_VIRTUAL_MODULE_ID = "\0" + ADAPTER_VIRTUAL_MODULE_ID;
+const ADAPTER_CONFIG_VIRTUAL_MODULE_ID = "virtual:astro:adapter-config";
+const RESOLVED_ADAPTER_CONFIG_VIRTUAL_MODULE_ID = "\0" + ADAPTER_CONFIG_VIRTUAL_MODULE_ID;
 function vitePluginAdapter(adapter) {
   return {
     name: "@astrojs/vite-plugin-astro-adapter",
     enforce: "post",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
+    },
     resolveId(id) {
       if (id === ADAPTER_VIRTUAL_MODULE_ID) {
         return RESOLVED_ADAPTER_VIRTUAL_MODULE_ID;
@@ -22,71 +19,70 @@ function vitePluginAdapter(adapter) {
     },
     async load(id) {
       if (id === RESOLVED_ADAPTER_VIRTUAL_MODULE_ID) {
-        return { code: `export * from ${JSON.stringify(adapter.serverEntrypoint)};` };
+        const adapterEntrypointStr = JSON.stringify(adapter.serverEntrypoint);
+        return {
+          code: `export * from ${adapterEntrypointStr};
+import * as _serverEntrypoint from ${adapterEntrypointStr};
+export default _serverEntrypoint.default;`
+        };
       }
     }
   };
 }
-function vitePluginSSR(internals, adapter, options) {
+function vitePluginAdapterConfig(adapter) {
   return {
-    name: "@astrojs/vite-plugin-astro-ssr-server",
+    name: "@astrojs/vite-plugin-astro-adapter-config",
     enforce: "post",
-    options(opts) {
-      const inputs = /* @__PURE__ */ new Set();
-      for (const pageData of Object.values(options.allPages)) {
-        if (routeIsRedirect(pageData.route)) {
-          continue;
-        }
-        inputs.add(getVirtualModulePageName(ASTRO_PAGE_MODULE_ID, pageData.component));
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
+    },
+    resolveId(id) {
+      if (id === ADAPTER_CONFIG_VIRTUAL_MODULE_ID) {
+        return RESOLVED_ADAPTER_CONFIG_VIRTUAL_MODULE_ID;
       }
-      const adapterServerEntrypoint = options.settings.adapter?.serverEntrypoint;
-      if (adapterServerEntrypoint) {
-        inputs.add(ADAPTER_VIRTUAL_MODULE_ID);
+    },
+    load(id) {
+      if (id === RESOLVED_ADAPTER_CONFIG_VIRTUAL_MODULE_ID) {
+        return {
+          code: `export const args = ${adapter.args ? JSON.stringify(adapter.args, null, 2) : "undefined"};
+export const exports = ${adapter.exports ? JSON.stringify(adapter.exports) : "undefined"};
+export const adapterFeatures = ${adapter.adapterFeatures ? JSON.stringify(adapter.adapterFeatures, null, 2) : "undefined"};
+export const serverEntrypoint = ${JSON.stringify(adapter.serverEntrypoint)};`
+        };
       }
-      inputs.add(SSR_VIRTUAL_MODULE_ID);
-      return addRollupInput(opts, Array.from(inputs));
+    }
+  };
+}
+function vitePluginSSR(internals, adapter) {
+  return {
+    name: "@astrojs/vite-plugin-astro-ssr-server",
+    enforce: "post",
+    applyToEnvironment(environment) {
+      return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr;
     },
     resolveId(id) {
       if (id === SSR_VIRTUAL_MODULE_ID) {
         return RESOLVED_SSR_VIRTUAL_MODULE_ID;
       }
     },
-    async load(id) {
+    load(id) {
       if (id === RESOLVED_SSR_VIRTUAL_MODULE_ID) {
-        const { allPages } = options;
-        const imports = [];
-        const contents = [];
         const exports = [];
-        let i = 0;
-        const pageMap = [];
-        for (const pageData of Object.values(allPages)) {
-          if (routeIsRedirect(pageData.route)) {
-            continue;
-          }
-          const virtualModuleName = getVirtualModulePageName(
-            ASTRO_PAGE_MODULE_ID,
-            pageData.component
+        if (adapter.exports) {
+          exports.push(
+            ...adapter.exports?.map((name) => {
+              if (name === "default") {
+                return `export default _exports.default;`;
+              } else {
+                return `export const ${name} = _exports['${name}'];`;
+              }
+            }) ?? []
           );
-          let module = await this.resolve(virtualModuleName);
-          if (module) {
-            const variable = `_page${i}`;
-            imports.push(`const ${variable} = () => import("${virtualModuleName}");`);
-            const pageData2 = internals.pagesByKeys.get(pageData.key);
-            pageMap.push(
-              `[${JSON.stringify(pageData2?.component || pageData.component)}, ${variable}]`
-            );
-            i++;
-          }
         }
-        contents.push(`const pageMap = new Map([
-    ${pageMap.join(",\n    ")}
-]);`);
-        exports.push(`export { pageMap }`);
-        const middleware = await this.resolve(MIDDLEWARE_MODULE_ID);
-        const ssrCode = generateSSRCode(adapter, middleware.id);
-        imports.push(...ssrCode.imports);
-        contents.push(...ssrCode.contents);
-        return { code: [...imports, ...contents, ...exports].join("\n") };
+        return {
+          code: `import _exports from 'astro/entrypoints/legacy';
+${exports.join("\n")}`
+        };
       }
     },
     async generateBundle(_opts, bundle) {
@@ -95,85 +91,17 @@ function vitePluginSSR(internals, adapter, options) {
           internals.staticFiles.add(chunk.fileName);
         }
       }
-      for (const [, chunk] of Object.entries(bundle)) {
-        if (chunk.type === "asset") {
-          continue;
-        }
-        if (chunk.modules[RESOLVED_SSR_VIRTUAL_MODULE_ID]) {
-          internals.ssrEntryChunk = chunk;
-        }
-      }
     }
   };
 }
 function pluginSSR(options, internals) {
+  const adapter = options.settings.adapter;
   const ssr = options.settings.buildOutput === "server";
-  return {
-    targets: ["server"],
-    hooks: {
-      "build:before": () => {
-        const adapter = options.settings.adapter;
-        const ssrPlugin = ssr && vitePluginSSR(internals, adapter, options);
-        const vitePlugin = [vitePluginAdapter(adapter)];
-        if (ssrPlugin) {
-          vitePlugin.unshift(ssrPlugin);
-        }
-        return {
-          enforce: "after-user-plugins",
-          vitePlugin
-        };
-      },
-      "build:post": async () => {
-        if (!ssr) {
-          return;
-        }
-        if (!internals.ssrEntryChunk) {
-          throw new Error(`Did not generate an entry chunk for SSR`);
-        }
-        internals.ssrEntryChunk.fileName = options.settings.config.build.serverEntry;
-      }
-    }
-  };
-}
-function generateSSRCode(adapter, middlewareId) {
-  const edgeMiddleware = adapter?.adapterFeatures?.edgeMiddleware ?? false;
-  const imports = [
-    `import { renderers } from '${RENDERERS_MODULE_ID}';`,
-    `import * as serverEntrypointModule from '${ADAPTER_VIRTUAL_MODULE_ID}';`,
-    `import { manifest as defaultManifest } from '${SSR_MANIFEST_VIRTUAL_MODULE_ID}';`,
-    `import { serverIslandMap } from '${VIRTUAL_ISLAND_MAP_ID}';`
-  ];
-  const contents = [
-    edgeMiddleware ? `const middleware = (_, next) => next()` : "",
-    `const _manifest = Object.assign(defaultManifest, {`,
-    `    pageMap,`,
-    `    serverIslandMap,`,
-    `    renderers,`,
-    `    actions: () => import("${ENTRYPOINT_VIRTUAL_MODULE_ID}"),`,
-    `    middleware: ${edgeMiddleware ? "undefined" : `() => import("${middlewareId}")`}`,
-    `});`,
-    `const _args = ${adapter.args ? JSON.stringify(adapter.args, null, 4) : "undefined"};`,
-    adapter.exports ? `const _exports = serverEntrypointModule.createExports(_manifest, _args);` : "",
-    ...adapter.exports?.map((name) => {
-      if (name === "default") {
-        return `export default _exports.default;`;
-      } else {
-        return `export const ${name} = _exports['${name}'];`;
-      }
-    }) ?? [],
-    // NOTE: This is intentionally obfuscated!
-    // Do NOT simplify this to something like `serverEntrypointModule.start?.(_manifest, _args)`
-    // They are NOT equivalent! Some bundlers will throw if `start` is not exported, but we
-    // only want to silently ignore it... hence the dynamic, obfuscated weirdness.
-    `const _start = 'start';
-if (Object.prototype.hasOwnProperty.call(serverEntrypointModule, _start)) {
-	serverEntrypointModule[_start](_manifest, _args);
-}`
-  ];
-  return {
-    imports,
-    contents
-  };
+  const plugins = [vitePluginAdapter(adapter), vitePluginAdapterConfig(adapter)];
+  if (ssr) {
+    plugins.unshift(vitePluginSSR(internals, adapter));
+  }
+  return plugins;
 }
 export {
   RESOLVED_SSR_VIRTUAL_MODULE_ID,

package/dist/core/build/plugins/util.d.ts

@@ -1,13 +1,4 @@
-import type { BuildOptions, Rollup, Plugin as VitePlugin } from 'vite';
-import type { BuildInternals } from '../internal.js';
-import type { PageBuildData } from '../types.js';
-type OutputOptionsHook = Extract<VitePlugin['outputOptions'], Function>;
-type OutputOptions = Parameters<OutputOptionsHook>[0];
-type ExtendManualChunksHooks = {
-    before?: Rollup.GetManualChunk;
-    after?: Rollup.GetManualChunk;
-};
-export declare function extendManualChunks(outputOptions: OutputOptions, hooks: ExtendManualChunksHooks): void;
+import type { BuildOptions } from 'vite';
 export declare const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
 /**
  * Generate a unique key to identify each page in the build process.
@@ -15,19 +6,4 @@ export declare const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
  * @param componentPath Usually pageData.component
  */
 export declare function makePageDataKey(route: string, componentPath: string): string;
-/**
- * Prevents Rollup from triggering other plugins in the process by masking the extension (hence the virtual file).
- * Inverse function of getComponentFromVirtualModulePageName() below.
- * @param virtualModulePrefix The prefix used to create the virtual module
- * @param path Page component path
- */
-export declare function getVirtualModulePageName(virtualModulePrefix: string, path: string): string;
-/**
- * From the VirtualModulePageName, and the internals, get all pageDatas that use this
- * component as their entry point.
- * @param virtualModulePrefix The prefix used to create the virtual module
- * @param id Virtual module name
- */
-export declare function getPagesFromVirtualModulePageName(internals: BuildInternals, virtualModulePrefix: string, id: string): PageBuildData[];
 export declare function shouldInlineAsset(assetContent: string, assetPath: string, assetsInlineLimit: NonNullable<BuildOptions['assetsInlineLimit']>): boolean;
-export {};

package/dist/core/build/plugins/util.js

@@ -1,52 +1,8 @@
-import { extname } from "node:path";
-function extendManualChunks(outputOptions, hooks) {
-  const manualChunks = outputOptions.manualChunks;
-  outputOptions.manualChunks = function(id, meta) {
-    if (hooks.before) {
-      let value = hooks.before(id, meta);
-      if (value) {
-        return value;
-      }
-    }
-    if (typeof manualChunks == "object") {
-      if (id in manualChunks) {
-        let value = manualChunks[id];
-        return value[0];
-      }
-    } else if (typeof manualChunks === "function") {
-      const outid = manualChunks.call(this, id, meta);
-      if (outid) {
-        return outid;
-      }
-    }
-    if (hooks.after) {
-      return hooks.after(id, meta) || null;
-    }
-    return null;
-  };
-}
 const ASTRO_PAGE_EXTENSION_POST_PATTERN = "@_@";
 const ASTRO_PAGE_KEY_SEPARATOR = "&";
 function makePageDataKey(route, componentPath) {
   return route + ASTRO_PAGE_KEY_SEPARATOR + componentPath;
 }
-function getVirtualModulePageName(virtualModulePrefix, path) {
-  const extension = extname(path);
-  return virtualModulePrefix + (extension.startsWith(".") ? path.slice(0, -extension.length) + extension.replace(".", ASTRO_PAGE_EXTENSION_POST_PATTERN) : path);
-}
-function getPagesFromVirtualModulePageName(internals, virtualModulePrefix, id) {
-  const path = getComponentFromVirtualModulePageName(virtualModulePrefix, id);
-  const pages = [];
-  internals.pagesByKeys.forEach((pageData) => {
-    if (pageData.component === path) {
-      pages.push(pageData);
-    }
-  });
-  return pages;
-}
-function getComponentFromVirtualModulePageName(virtualModulePrefix, id) {
-  return id.slice(virtualModulePrefix.length).replace(ASTRO_PAGE_EXTENSION_POST_PATTERN, ".");
-}
 function shouldInlineAsset(assetContent, assetPath, assetsInlineLimit) {
   if (typeof assetsInlineLimit === "function") {
     const result = assetsInlineLimit(assetPath, Buffer.from(assetContent));
@@ -60,9 +16,6 @@ function shouldInlineAsset(assetContent, assetPath, assetsInlineLimit) {
 }
 export {
   ASTRO_PAGE_EXTENSION_POST_PATTERN,
-  extendManualChunks,
-  getPagesFromVirtualModulePageName,
-  getVirtualModulePageName,
   makePageDataKey,
   shouldInlineAsset
 };

package/dist/core/build/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { BuildInternals } from './internal.js';
+import type { PageBuildData, StylesheetAsset } from './types.js';
+/**
+ * From its route and component, get the page data from the build internals.
+ * @param internals Build Internals with all the pages
+ * @param route The route of the page, used to identify the page
+ * @param component The component of the page, used to identify the page
+ */
+export declare function getPageData(internals: BuildInternals, route: string, component: string): PageBuildData | undefined;
+interface OrderInfo {
+    depth: number;
+    order: number;
+}
+/**
+ * Sort a page's CSS by depth. A higher depth means that the CSS comes from shared subcomponents.
+ * A lower depth means it comes directly from the top-level page.
+ * Can be used to sort stylesheets so that shared rules come first
+ * and page-specific rules come after.
+ */
+export declare function cssOrder(a: OrderInfo, b: OrderInfo): 1 | -1;
+/**
+ * Merges inline CSS into as few stylesheets as possible,
+ * preserving ordering when there are non-inlined in between.
+ */
+export declare function mergeInlineCss(acc: Array<StylesheetAsset>, current: StylesheetAsset): Array<StylesheetAsset>;
+export {};

package/dist/core/build/runtime.js

@@ -0,0 +1,45 @@
+import { makePageDataKey } from "./plugins/util.js";
+function getPageData(internals, route, component) {
+  let pageData = internals.pagesByKeys.get(makePageDataKey(route, component));
+  if (pageData) {
+    return pageData;
+  }
+  return void 0;
+}
+function cssOrder(a, b) {
+  let depthA = a.depth, depthB = b.depth, orderA = a.order, orderB = b.order;
+  if (orderA === -1 && orderB >= 0) {
+    return 1;
+  } else if (orderB === -1 && orderA >= 0) {
+    return -1;
+  } else if (orderA > orderB) {
+    return 1;
+  } else if (orderA < orderB) {
+    return -1;
+  } else {
+    if (depthA === -1) {
+      return -1;
+    } else if (depthB === -1) {
+      return 1;
+    } else {
+      return depthA > depthB ? -1 : 1;
+    }
+  }
+}
+function mergeInlineCss(acc, current) {
+  const lastAdded = acc.at(acc.length - 1);
+  const lastWasInline = lastAdded?.type === "inline";
+  const currentIsInline = current?.type === "inline";
+  if (lastWasInline && currentIsInline) {
+    const merged = { type: "inline", content: lastAdded.content + current.content };
+    acc[acc.length - 1] = merged;
+    return acc;
+  }
+  acc.push(current);
+  return acc;
+}
+export {
+  cssOrder,
+  getPageData,
+  mergeInlineCss
+};

package/dist/core/build/static-build.d.ts

@@ -3,9 +3,9 @@ import type { RouteData } from '../../types/public/internal.js';
 import type { StaticBuildOptions } from './types.js';
 export declare function viteBuild(opts: StaticBuildOptions): Promise<{
     internals: BuildInternals;
-    ssrOutputChunkNames: string[];
+    prerenderOutputDir: URL;
 }>;
-export declare function staticBuild(opts: StaticBuildOptions, internals: BuildInternals, ssrOutputChunkNames: string[]): Promise<void>;
+export declare function staticBuild(opts: StaticBuildOptions, internals: BuildInternals, prerenderOutputDir: URL): Promise<void>;
 /**
  * This function takes the virtual module name of any page entrypoint and
  * transforms it to generate a final `.mjs` output file.