astro 4.4.15 → 4.5.0

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

@@ -12,6 +12,7 @@ import { pluginMiddleware } from "./plugin-middleware.js";
 import { pluginPages } from "./plugin-pages.js";
 import { pluginPrerender } from "./plugin-prerender.js";
 import { pluginRenderers } from "./plugin-renderers.js";
+import { pluginScripts } from "./plugin-scripts.js";
 import { pluginSSR, pluginSSRSplit } from "./plugin-ssr.js";
 function registerAllPlugins({ internals, options, register }) {
   register(pluginComponentEntry(internals));
@@ -26,7 +27,11 @@ function registerAllPlugins({ internals, options, register }) {
   register(astroHeadBuildPlugin(internals));
   register(pluginPrerender(options, internals));
   register(astroConfigBuildPlugin(options, internals));
-  register(pluginHoistedScripts(options, internals));
+  if (options.settings.config.experimental.directRenderScript) {
+    register(pluginScripts(internals));
+  } else {
+    register(pluginHoistedScripts(options, internals));
+  }
   register(pluginSSR(options, internals));
   register(pluginSSRSplit(options, internals));
   register(pluginChunks());

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

@@ -9,82 +9,6 @@ function isPropagatedAsset(id) {
     return false;
   }
 }
-async function doesParentImportChild(parentInfo, childInfo, childExportNames) {
-  if (!childInfo || !parentInfo.ast || !childExportNames)
-    return "no";
-  if (childExportNames === "dynamic" || parentInfo.dynamicallyImportedIds?.includes(childInfo.id)) {
-    return "dynamic";
-  }
-  const imports = [];
-  const exports = [];
-  for (const node of parentInfo.ast.body) {
-    if (node.type === "ImportDeclaration") {
-      imports.push(node);
-    } else if (node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration") {
-      exports.push(node);
-    }
-  }
-  const importNames = [];
-  const exportNames = [];
-  for (const node of imports) {
-    const resolved = await this.resolve(node.source.value, parentInfo.id);
-    if (!resolved || resolved.id !== childInfo.id)
-      continue;
-    for (const specifier of node.specifiers) {
-      if (specifier.type === "ImportNamespaceSpecifier")
-        continue;
-      const name = specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.imported.name;
-      if (childExportNames.includes(name)) {
-        importNames.push(specifier.local.name);
-      }
-    }
-  }
-  for (const node of exports) {
-    if (node.type === "ExportDefaultDeclaration") {
-      if (node.declaration.type === "Identifier" && importNames.includes(node.declaration.name)) {
-        exportNames.push("default");
-      }
-    } else {
-      if (node.source) {
-        const resolved = await this.resolve(node.source.value, parentInfo.id);
-        if (!resolved || resolved.id !== childInfo.id)
-          continue;
-        for (const specifier of node.specifiers) {
-          if (childExportNames.includes(specifier.local.name)) {
-            importNames.push(specifier.local.name);
-            exportNames.push(specifier.exported.name);
-          }
-        }
-      }
-      if (node.declaration) {
-        if (node.declaration.type !== "VariableDeclaration")
-          continue;
-        for (const declarator of node.declaration.declarations) {
-          if (declarator.init?.type !== "Identifier")
-            continue;
-          if (declarator.id.type !== "Identifier")
-            continue;
-          if (importNames.includes(declarator.init.name)) {
-            exportNames.push(declarator.id.name);
-          }
-        }
-      }
-      for (const specifier of node.specifiers) {
-        if (importNames.includes(specifier.local.name)) {
-          exportNames.push(specifier.exported.name);
-        }
-      }
-    }
-  }
-  if (!importNames.length)
-    return "no";
-  if (parentInfo.id.endsWith(".astro")) {
-    exportNames.push("default");
-  } else if (parentInfo.id.endsWith(".mdx")) {
-    exportNames.push("Content");
-  }
-  return exportNames;
-}
 function vitePluginAnalyzer(options, internals) {
   function hoistedScriptScanner() {
     const uniqueHoistedIds = /* @__PURE__ */ new Map();
@@ -97,29 +21,9 @@ function vitePluginAnalyzer(options, internals) {
           hoistedScripts.add(hid);
         }
         if (hoistedScripts.size) {
-          const depthsToChildren = /* @__PURE__ */ new Map();
-          const depthsToExportNames = /* @__PURE__ */ new Map();
-          depthsToExportNames.set(0, ["default"]);
-          for (const [parentInfo, depth] of walkParentInfos(from, this, function until(importer) {
+          for (const [parentInfo] of walkParentInfos(from, this, function until(importer) {
             return isPropagatedAsset(importer);
           })) {
-            if (options.settings.config.experimental.optimizeHoistedScript) {
-              depthsToChildren.set(depth, parentInfo);
-              if (depth > 0) {
-                const childInfo = depthsToChildren.get(depth - 1);
-                const childExportNames = depthsToExportNames.get(depth - 1);
-                const doesImport = await doesParentImportChild.call(
-                  this,
-                  parentInfo,
-                  childInfo,
-                  childExportNames
-                );
-                if (doesImport === "no") {
-                  continue;
-                }
-                depthsToExportNames.set(depth, doesImport);
-              }
-            }
             if (isPropagatedAsset(parentInfo.id)) {
               for (const [nestedParentInfo] of walkParentInfos(from, this)) {
                 if (moduleIsTopLevelPage(nestedParentInfo)) {
@@ -188,7 +92,9 @@ function vitePluginAnalyzer(options, internals) {
   return {
     name: "@astro/rollup-plugin-astro-analyzer",
     async generateBundle() {
-      const hoistScanner = hoistedScriptScanner();
+      const hoistScanner = options.settings.config.experimental.directRenderScript ? { scan: async () => {
+      }, finalize: () => {
+      } } : hoistedScriptScanner();
       const ids = this.getModuleIds();
       for (const id of ids) {
         const info = this.getModuleInfo(id);
@@ -232,6 +138,12 @@ function vitePluginAnalyzer(options, internals) {
             trackClientOnlyPageDatas(internals, newPageData, clientOnlys);
           }
         }
+        if (options.settings.config.experimental.directRenderScript && astro.scripts.length) {
+          for (let i = 0; i < astro.scripts.length; i++) {
+            const hid = `${id.replace("/@fs", "")}?astro&type=script&index=${i}&lang.ts`;
+            internals.discoveredScripts.add(hid);
+          }
+        }
       }
       hoistScanner.finalize();
     }

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

@@ -125,6 +125,22 @@ function rollupPluginAstroBuildCSS(options) {
       }
     }
   };
+  const cssScopeToPlugin = {
+    name: "astro:rollup-plugin-css-scope-to",
+    renderChunk(_, chunk, __, meta) {
+      for (const id in chunk.modules) {
+        const modMeta = this.getModuleInfo(id)?.meta;
+        const cssScopeTo = modMeta?.astroCss?.cssScopeTo;
+        if (cssScopeTo && !isCssScopeToRendered(cssScopeTo, Object.values(meta.chunks))) {
+          delete chunk.modules[id];
+          const moduleIdsIndex = chunk.moduleIds.indexOf(id);
+          if (moduleIdsIndex > -1) {
+            chunk.moduleIds.splice(moduleIdsIndex, 1);
+          }
+        }
+      }
+    }
+  };
   const singleCssPlugin = {
     name: "astro:rollup-plugin-single-css",
     enforce: "post",
@@ -197,7 +213,7 @@ function rollupPluginAstroBuildCSS(options) {
       });
     }
   };
-  return [cssBuildPlugin, singleCssPlugin, inlineStylesheetsPlugin];
+  return [cssBuildPlugin, cssScopeToPlugin, singleCssPlugin, inlineStylesheetsPlugin];
 }
 function* getParentClientOnlys(id, ctx, internals) {
   for (const [info] of walkParentInfos(id, ctx)) {
@@ -222,6 +238,16 @@ function appendCSSToPage(pageData, meta, pagesToCss, depth, order) {
     }
   }
 }
+function isCssScopeToRendered(cssScopeTo, chunks) {
+  for (const moduleId in cssScopeTo) {
+    const exports = cssScopeTo[moduleId];
+    const renderedModule = chunks.find((c) => c.moduleIds.includes(moduleId))?.modules[moduleId];
+    if (renderedModule?.renderedExports.some((e) => exports.includes(e))) {
+      return true;
+    }
+  }
+  return false;
+}
 export {
   pluginCSS
 };

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

@@ -1,11 +1,12 @@
 import { fileURLToPath } from "node:url";
 import glob from "fast-glob";
 import {} from "vite";
+import { getAssetsPrefix } from "../../../assets/utils/getAssetsPrefix.js";
 import { normalizeTheLocale } from "../../../i18n/index.js";
 import { toRoutingStrategy } from "../../../i18n/utils.js";
 import { runHookBuildSsr } from "../../../integrations/index.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
-import { joinPaths, prependForwardSlash } from "../../path.js";
+import { fileExtension, joinPaths, prependForwardSlash } from "../../path.js";
 import { serializeRouteData } from "../../routing/index.js";
 import { addRollupInput } from "../add-rollup-input.js";
 import { getOutFile, getOutFolder } from "../common.js";
@@ -120,7 +121,8 @@ function buildManifest(opts, internals, staticFiles) {
   }
   const prefixAssetPath = (pth) => {
     if (settings.config.build.assetsPrefix) {
-      return joinPaths(settings.config.build.assetsPrefix, pth);
+      const pf = getAssetsPrefix(fileExtension(pth), settings.config.build.assetsPrefix);
+      return joinPaths(pf, pth);
     } else {
       return prependForwardSlash(joinPaths(settings.config.base, pth));
     }
@@ -208,6 +210,7 @@ function buildManifest(opts, internals, staticFiles) {
     renderers: [],
     clientDirectives: Array.from(settings.clientDirectives),
     entryModules,
+    inlinedScripts: Array.from(internals.inlinedScripts),
     assets: staticFiles.map(prefixAssetPath),
     i18n: i18nManifest,
     buildFormat: settings.config.build.format

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

@@ -0,0 +1,8 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { BuildInternals } from '../internal.js';
+import type { AstroBuildPlugin } from '../plugin.js';
+/**
+ * Used by the `experimental.directRenderScript` option to inline scripts directly into the HTML.
+ */
+export declare function vitePluginScripts(internals: BuildInternals): VitePlugin;
+export declare function pluginScripts(internals: BuildInternals): AstroBuildPlugin;

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

@@ -0,0 +1,34 @@
+import { shouldInlineAsset } from "./util.js";
+function vitePluginScripts(internals) {
+  let assetInlineLimit;
+  return {
+    name: "@astro/plugin-scripts",
+    configResolved(config) {
+      assetInlineLimit = config.build.assetsInlineLimit;
+    },
+    async generateBundle(_options, bundle) {
+      for (const [id, output] of Object.entries(bundle)) {
+        if (output.type === "chunk" && output.facadeModuleId && internals.discoveredScripts.has(output.facadeModuleId) && output.imports.length === 0 && output.dynamicImports.length === 0 && shouldInlineAsset(output.code, output.fileName, assetInlineLimit)) {
+          internals.inlinedScripts.set(output.facadeModuleId, output.code.trim());
+          delete bundle[id];
+        }
+      }
+    }
+  };
+}
+function pluginScripts(internals) {
+  return {
+    targets: ["client"],
+    hooks: {
+      "build:before": () => {
+        return {
+          vitePlugin: vitePluginScripts(internals)
+        };
+      }
+    }
+  };
+}
+export {
+  pluginScripts,
+  vitePluginScripts
+};

package/dist/core/compile/compile.d.ts

@@ -2,6 +2,7 @@ import type { TransformResult } from '@astrojs/compiler';
 import type { ResolvedConfig } from 'vite';
 import type { AstroConfig } from '../../@types/astro.js';
 import type { AstroPreferences } from '../../preferences/index.js';
+import type { CompileCssResult } from './types.js';
 export interface CompileProps {
     astroConfig: AstroConfig;
     viteConfig: ResolvedConfig;
@@ -9,13 +10,6 @@ export interface CompileProps {
     filename: string;
     source: string;
 }
-export interface CompileCssResult {
-    code: string;
-    /**
-     * The dependencies of the transformed CSS (Normalized paths)
-     */
-    dependencies?: string[];
-}
 export interface CompileResult extends Omit<TransformResult, 'css'> {
     css: CompileCssResult[];
 }

package/dist/core/compile/compile.js

@@ -12,7 +12,7 @@ async function compile({
   filename,
   source
 }) {
-  const cssDeps = [];
+  const cssPartialCompileResults = [];
   const cssTransformErrors = [];
   let transformResult;
   try {
@@ -29,10 +29,11 @@ async function compile({
       resultScopedSlot: true,
       transitionsAnimationURL: "astro/components/viewtransitions.css",
       annotateSourceFile: viteConfig.command === "serve" && astroConfig.devToolbar && astroConfig.devToolbar.enabled && await preferences.get("devToolbar.enabled"),
+      renderScript: astroConfig.experimental.directRenderScript,
       preprocessStyle: createStylePreprocessor({
         filename,
         viteConfig,
-        cssDeps,
+        cssPartialCompileResults,
         cssTransformErrors
       }),
       async resolvePath(specifier) {
@@ -53,8 +54,8 @@ async function compile({
   return {
     ...transformResult,
     css: transformResult.css.map((code, i) => ({
-      code,
-      dependencies: cssDeps[i]
+      ...cssPartialCompileResults[i],
+      code
     }))
   };
 }

package/dist/core/compile/style.d.ts

@@ -1,9 +1,10 @@
 import type { TransformOptions } from '@astrojs/compiler';
 import { type ResolvedConfig } from 'vite';
-import type { CompileCssResult } from './compile.js';
-export declare function createStylePreprocessor({ filename, viteConfig, cssDeps, cssTransformErrors, }: {
+import type { CompileCssResult } from './types.js';
+export type PartialCompileCssResult = Pick<CompileCssResult, 'isGlobal' | 'dependencies'>;
+export declare function createStylePreprocessor({ filename, viteConfig, cssPartialCompileResults, cssTransformErrors, }: {
     filename: string;
     viteConfig: ResolvedConfig;
-    cssDeps: CompileCssResult['dependencies'][];
+    cssPartialCompileResults: Partial<CompileCssResult>[];
     cssTransformErrors: Error[];
 }): TransformOptions['preprocessStyle'];

package/dist/core/compile/style.js

@@ -4,7 +4,7 @@ import { AstroErrorData, CSSError, positionAt } from "../errors/index.js";
 function createStylePreprocessor({
   filename,
   viteConfig,
-  cssDeps,
+  cssPartialCompileResults,
   cssTransformErrors
 }) {
   let processedStylesCount = 0;
@@ -14,9 +14,10 @@ function createStylePreprocessor({
     const id = `${filename}?astro&type=style&index=${index}&lang${lang}`;
     try {
       const result = await preprocessCSS(content, id, viteConfig);
-      if (result.deps) {
-        cssDeps[index] = [...result.deps].map((dep) => normalizePath(dep));
-      }
+      cssPartialCompileResults[index] = {
+        isGlobal: !!attrs["is:global"],
+        dependencies: result.deps ? [...result.deps].map((dep) => normalizePath(dep)) : []
+      };
       let map;
       if (result.map) {
         if (typeof result.map === "string") {

package/dist/core/compile/types.d.ts

@@ -5,3 +5,14 @@ export type TransformStyleResult = null | {
     deps: Set<string>;
 };
 export type TransformStyle = (source: string, lang: string) => TransformStyleResult | Promise<TransformStyleResult>;
+export interface CompileCssResult {
+    code: string;
+    /**
+     * Whether this is `<style is:global>`
+     */
+    isGlobal: boolean;
+    /**
+     * The dependencies of the transformed CSS (Normalized/forward-slash-only absolute paths)
+     */
+    dependencies: string[];
+}