astro 2.0.6 → 2.0.7

package/dist/cli/sync/index.js

@@ -1,18 +1,32 @@
 import { dim } from "kleur/colors";
 import { performance } from "node:perf_hooks";
-import { contentObservable, createContentTypesGenerator } from "../../content/index.js";
+import { createServer } from "vite";
+import { createContentTypesGenerator } from "../../content/index.js";
+import { globalContentConfigObserver } from "../../content/utils.js";
 import { getTimeStat } from "../../core/build/util.js";
+import { createVite } from "../../core/create-vite.js";
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 import { info } from "../../core/logger/core.js";
 import { setUpEnvTs } from "../../vite-plugin-inject-env-ts/index.js";
 async function sync(settings, { logging, fs }) {
   const timerStart = performance.now();
+  const tempViteServer = await createServer(
+    await createVite(
+      {
+        server: { middlewareMode: true, hmr: false },
+        optimizeDeps: { entries: [] },
+        logLevel: "silent"
+      },
+      { settings, logging, mode: "build", fs }
+    )
+  );
   try {
     const contentTypesGenerator = await createContentTypesGenerator({
-      contentConfigObserver: contentObservable({ status: "loading" }),
+      contentConfigObserver: globalContentConfigObserver,
       logging,
       fs,
-      settings
+      settings,
+      viteServer: tempViteServer
     });
     const typesResult = await contentTypesGenerator.init();
     if (typesResult.typesGenerated === false) {
@@ -25,6 +39,8 @@ async function sync(settings, { logging, fs }) {
     }
   } catch (e) {
     throw new AstroError(AstroErrorData.GenerateContentTypesError);
+  } finally {
+    await tempViteServer.close();
   }
   info(logging, "content", `Types generated ${dim(getTimeStat(timerStart, performance.now()))}`);
   await setUpEnvTs({ settings, logging, fs });

package/dist/content/index.d.ts

@@ -1,5 +1,6 @@
+export { attachContentServerListeners } from './server-listeners.js';
 export { createContentTypesGenerator } from './types-generator.js';
 export { contentObservable, getContentPaths, getDotAstroTypeReference } from './utils.js';
-export { astroContentAssetPropagationPlugin, astroContentProdBundlePlugin, } from './vite-plugin-content-assets.js';
-export { astroContentServerPlugin } from './vite-plugin-content-server.js';
+export { astroContentAssetPropagationPlugin } from './vite-plugin-content-assets.js';
+export { astroContentImportPlugin } from './vite-plugin-content-imports.js';
 export { astroContentVirtualModPlugin } from './vite-plugin-content-virtual-mod.js';

package/dist/content/index.js

@@ -1,16 +1,14 @@
+import { attachContentServerListeners } from "./server-listeners.js";
 import { createContentTypesGenerator } from "./types-generator.js";
 import { contentObservable, getContentPaths, getDotAstroTypeReference } from "./utils.js";
-import {
-  astroContentAssetPropagationPlugin,
-  astroContentProdBundlePlugin
-} from "./vite-plugin-content-assets.js";
-import { astroContentServerPlugin } from "./vite-plugin-content-server.js";
+import { astroContentAssetPropagationPlugin } from "./vite-plugin-content-assets.js";
+import { astroContentImportPlugin } from "./vite-plugin-content-imports.js";
 import { astroContentVirtualModPlugin } from "./vite-plugin-content-virtual-mod.js";
 export {
   astroContentAssetPropagationPlugin,
-  astroContentProdBundlePlugin,
-  astroContentServerPlugin,
+  astroContentImportPlugin,
   astroContentVirtualModPlugin,
+  attachContentServerListeners,
   contentObservable,
   createContentTypesGenerator,
   getContentPaths,

package/dist/content/internal.js

@@ -3,6 +3,7 @@ import { prependForwardSlash } from "../core/path.js";
 import {
   createComponent,
   createHeadAndContent,
+  createScopedResult,
   renderComponent,
   renderScriptElement,
   renderStyleElement,
@@ -139,7 +140,13 @@ async function render({
       }
       return createHeadAndContent(
         unescapeHTML(styles + links + scripts),
-        renderTemplate`${renderComponent(result, "Content", mod.Content, props, slots)}`
+        renderTemplate`${renderComponent(
+          createScopedResult(result),
+          "Content",
+          mod.Content,
+          props,
+          slots
+        )}`
       );
     },
     propagation: "self"

package/dist/content/server-listeners.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type fsMod from 'node:fs';
+import type { ViteDevServer } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import { LogOptions } from '../core/logger/core.js';
+interface ContentServerListenerParams {
+    fs: typeof fsMod;
+    logging: LogOptions;
+    settings: AstroSettings;
+    viteServer: ViteDevServer;
+}
+export declare function attachContentServerListeners({ viteServer, fs, logging, settings, }: ContentServerListenerParams): Promise<void>;
+export {};

package/dist/content/server-listeners.js

@@ -0,0 +1,65 @@
+import { cyan } from "kleur/colors";
+import { pathToFileURL } from "node:url";
+import { info } from "../core/logger/core.js";
+import { appendForwardSlash } from "../core/path.js";
+import { createContentTypesGenerator } from "./types-generator.js";
+import { getContentPaths, globalContentConfigObserver } from "./utils.js";
+async function attachContentServerListeners({
+  viteServer,
+  fs,
+  logging,
+  settings
+}) {
+  const contentPaths = getContentPaths(settings.config);
+  if (fs.existsSync(contentPaths.contentDir)) {
+    info(
+      logging,
+      "content",
+      `Watching ${cyan(
+        contentPaths.contentDir.href.replace(settings.config.root.href, "")
+      )} for changes`
+    );
+    await attachListeners();
+  } else {
+    viteServer.watcher.on("addDir", contentDirListener);
+    async function contentDirListener(dir) {
+      if (appendForwardSlash(pathToFileURL(dir).href) === contentPaths.contentDir.href) {
+        info(logging, "content", `Content dir found. Watching for changes`);
+        await attachListeners();
+        viteServer.watcher.removeListener("addDir", contentDirListener);
+      }
+    }
+  }
+  async function attachListeners() {
+    const contentGenerator = await createContentTypesGenerator({
+      fs,
+      settings,
+      logging,
+      viteServer,
+      contentConfigObserver: globalContentConfigObserver
+    });
+    await contentGenerator.init();
+    info(logging, "content", "Types generated");
+    viteServer.watcher.on("add", (entry) => {
+      contentGenerator.queueEvent({ name: "add", entry });
+    });
+    viteServer.watcher.on(
+      "addDir",
+      (entry) => contentGenerator.queueEvent({ name: "addDir", entry })
+    );
+    viteServer.watcher.on(
+      "change",
+      (entry) => contentGenerator.queueEvent({ name: "change", entry })
+    );
+    viteServer.watcher.on("unlink", (entry) => {
+      contentGenerator.queueEvent({ name: "unlink", entry });
+    });
+    viteServer.watcher.on(
+      "unlinkDir",
+      (entry) => contentGenerator.queueEvent({ name: "unlinkDir", entry })
+    );
+  }
+}
+export {
+  attachContentServerListeners
+};

package/dist/content/types-generator.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import type fsMod from 'node:fs';
+import { ViteDevServer } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
 import { LogOptions } from '../core/logger/core.js';
-import { ContentObservable, ContentPaths } from './utils.js';
+import { ContentObservable } from './utils.js';
 type ChokidarEvent = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
 type RawContentEvent = {
     name: ChokidarEvent;
@@ -12,12 +13,14 @@ type CreateContentGeneratorParams = {
     contentConfigObserver: ContentObservable;
     logging: LogOptions;
     settings: AstroSettings;
+    /** This is required for loading the content config */
+    viteServer: ViteDevServer;
     fs: typeof fsMod;
 };
 type EventOpts = {
     logLevel: 'info' | 'warn';
 };
-export declare function createContentTypesGenerator({ contentConfigObserver, fs, logging, settings, }: CreateContentGeneratorParams): Promise<{
+export declare function createContentTypesGenerator({ contentConfigObserver, fs, logging, settings, viteServer, }: CreateContentGeneratorParams): Promise<{
     init: () => Promise<{
         typesGenerated: true;
     } | {
@@ -26,5 +29,4 @@ export declare function createContentTypesGenerator({ contentConfigObserver, fs,
     }>;
     queueEvent: (rawEvent: RawContentEvent, opts?: EventOpts) => void;
 }>;
-export declare function getEntryType(entryPath: string, paths: ContentPaths): 'content' | 'config' | 'unknown' | 'generated-types';
 export {};

package/dist/content/types-generator.js

@@ -4,12 +4,13 @@ import * as path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { normalizePath } from "vite";
 import { info, warn } from "../core/logger/core.js";
-import { appendForwardSlash, isRelativePath } from "../core/path.js";
-import { contentFileExts, CONTENT_TYPES_FILE } from "./consts.js";
+import { isRelativePath } from "../core/path.js";
+import { CONTENT_TYPES_FILE } from "./consts.js";
 import {
   getContentPaths,
   getEntryInfo,
   getEntrySlug,
+  getEntryType,
   loadContentConfig,
   NoCollectionError,
   parseFrontmatter
@@ -20,7 +21,8 @@ async function createContentTypesGenerator({
   contentConfigObserver,
   fs,
   logging,
-  settings
+  settings,
+  viteServer
 }) {
   const contentTypes = {};
   const contentPaths = getContentPaths(settings.config);
@@ -72,12 +74,12 @@ async function createContentTypesGenerator({
       return { shouldGenerateTypes: true };
     }
     const fileType = getEntryType(fileURLToPath(event.entry), contentPaths);
-    if (fileType === "generated-types") {
+    if (fileType === "ignored") {
       return { shouldGenerateTypes: false };
     }
     if (fileType === "config") {
       contentConfigObserver.set({ status: "loading" });
-      const config = await loadContentConfig({ fs, settings });
+      const config = await loadContentConfig({ fs, settings, viteServer });
       if (config) {
         contentConfigObserver.set({ status: "loaded", config });
       } else {
@@ -85,20 +87,19 @@ async function createContentTypesGenerator({
       }
       return { shouldGenerateTypes: true };
     }
-    if (fileType === "unknown") {
+    if (fileType === "unsupported") {
+      if (event.name === "unlink") {
+        return { shouldGenerateTypes: false };
+      }
       const entryInfo2 = getEntryInfo({
         entry: event.entry,
         contentDir: contentPaths.contentDir,
         allowFilesOutsideCollection: true
       });
-      if (entryInfo2.id.startsWith("_") && (event.name === "add" || event.name === "change")) {
-        return { shouldGenerateTypes: false };
-      } else {
-        return {
-          shouldGenerateTypes: false,
-          error: new UnsupportedFileTypeError(entryInfo2.id)
-        };
-      }
+      return {
+        shouldGenerateTypes: false,
+        error: new UnsupportedFileTypeError(entryInfo2.id)
+      };
     }
     const entryInfo = getEntryInfo({
       entry: event.entry,
@@ -220,19 +221,6 @@ function setEntry(contentTypes, collectionKey, entryKey, slug) {
 function removeEntry(contentTypes, collectionKey, entryKey) {
   delete contentTypes[collectionKey][entryKey];
 }
-function getEntryType(entryPath, paths) {
-  const { dir: rawDir, ext, base } = path.parse(entryPath);
-  const dir = appendForwardSlash(pathToFileURL(rawDir).href);
-  if (contentFileExts.includes(ext)) {
-    return "content";
-  } else if (new URL(base, dir).href === paths.config.href) {
-    return "config";
-  } else if (new URL(base, dir).href === new URL(CONTENT_TYPES_FILE, paths.cacheDir).href) {
-    return "generated-types";
-  } else {
-    return "unknown";
-  }
-}
 async function writeContentFiles({
   fs,
   contentPaths,
@@ -299,6 +287,5 @@ function warnNonexistentCollections({
   }
 }
 export {
-  createContentTypesGenerator,
-  getEntryType
+  createContentTypesGenerator
 };

package/dist/content/utils.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import matter from 'gray-matter';
 import type fsMod from 'node:fs';
+import { ViteDevServer } from 'vite';
 import { z } from 'zod';
 import { AstroConfig, AstroSettings } from '../@types/astro.js';
 export declare const collectionConfigParser: z.ZodObject<{
@@ -60,16 +61,26 @@ export declare function getEntryInfo(params: Pick<ContentPaths, 'contentDir'> &
     entry: URL;
     allowFilesOutsideCollection?: true;
 }): EntryInfo;
+export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config'>): 'content' | 'config' | 'ignored' | 'unsupported';
 /**
  * Match YAML exception handling from Astro core errors
  * @see 'astro/src/core/errors.ts'
  */
 export declare function parseFrontmatter(fileContents: string, filePath: string): matter.GrayMatterFile<string>;
-export declare function loadContentConfig({ fs, settings, }: {
+/**
+ * The content config is loaded separately from other `src/` files.
+ * This global observable lets dependent plugins (like the content flag plugin)
+ * subscribe to changes during dev server updates.
+ */
+export declare const globalContentConfigObserver: ContentObservable;
+export declare function loadContentConfig({ fs, settings, viteServer, }: {
     fs: typeof fsMod;
     settings: AstroSettings;
+    viteServer: ViteDevServer;
 }): Promise<ContentConfig | undefined>;
 type ContentCtx = {
+    status: 'init';
+} | {
     status: 'loading';
 } | {
     status: 'error';

package/dist/content/utils.js

@@ -1,12 +1,12 @@
 import { slug as githubSlug } from "github-slugger";
 import matter from "gray-matter";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createServer, normalizePath } from "vite";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { normalizePath } from "vite";
 import { z } from "zod";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { CONTENT_TYPES_FILE } from "./consts.js";
-import { astroContentVirtualModPlugin } from "./vite-plugin-content-virtual-mod.js";
+import { appendForwardSlash } from "../core/path.js";
+import { contentFileExts, CONTENT_TYPES_FILE } from "./consts.js";
 const collectionConfigParser = z.object({
   schema: z.any().optional()
 });
@@ -103,6 +103,32 @@ function getEntryInfo({
   };
   return res;
 }
+function getEntryType(entryPath, paths) {
+  const { dir: rawDir, ext, base } = path.parse(entryPath);
+  const dir = appendForwardSlash(pathToFileURL(rawDir).href);
+  const fileUrl = new URL(base, dir);
+  if (hasUnderscoreInPath(fileUrl) || isOnIgnoreList(fileUrl)) {
+    return "ignored";
+  } else if (contentFileExts.includes(ext)) {
+    return "content";
+  } else if (fileUrl.href === paths.config.href) {
+    return "config";
+  } else {
+    return "unsupported";
+  }
+}
+function isOnIgnoreList(fileUrl) {
+  const { base } = path.parse(fileURLToPath(fileUrl));
+  return [".DS_Store"].includes(base);
+}
+function hasUnderscoreInPath(fileUrl) {
+  const parts = fileUrl.pathname.split("/");
+  for (const part of parts) {
+    if (part.startsWith("_"))
+      return true;
+  }
+  return false;
+}
 const flattenErrorPath = (errorPath) => errorPath.join(".");
 const errorMap = (error, ctx) => {
   if (error.code === "invalid_type") {
@@ -140,31 +166,22 @@ function parseFrontmatter(fileContents, filePath) {
     }
   }
 }
+const globalContentConfigObserver = contentObservable({ status: "init" });
 async function loadContentConfig({
   fs,
-  settings
+  settings,
+  viteServer
 }) {
   const contentPaths = getContentPaths(settings.config);
-  const tempConfigServer = await createServer({
-    root: fileURLToPath(settings.config.root),
-    server: { middlewareMode: true, hmr: false },
-    optimizeDeps: { entries: [] },
-    clearScreen: false,
-    appType: "custom",
-    logLevel: "silent",
-    plugins: [astroContentVirtualModPlugin({ settings })]
-  });
   let unparsedConfig;
   if (!fs.existsSync(contentPaths.config)) {
     return void 0;
   }
   try {
     const configPathname = fileURLToPath(contentPaths.config);
-    unparsedConfig = await tempConfigServer.ssrLoadModule(configPathname);
+    unparsedConfig = await viteServer.ssrLoadModule(configPathname);
   } catch (e) {
     throw e;
-  } finally {
-    await tempConfigServer.close();
   }
   const config = contentConfigParser.safeParse(unparsedConfig);
   if (config.success) {
@@ -218,6 +235,8 @@ export {
   getEntryData,
   getEntryInfo,
   getEntrySlug,
+  getEntryType,
+  globalContentConfigObserver,
   loadContentConfig,
   msg,
   parseFrontmatter

package/dist/content/vite-plugin-content-assets.d.ts

@@ -1,8 +1,8 @@
 import type { Plugin } from 'vite';
 import { BuildInternals } from '../core/build/internal.js';
+import { AstroBuildPlugin } from '../core/build/plugin.js';
+import type { StaticBuildOptions } from '../core/build/types';
 export declare function astroContentAssetPropagationPlugin({ mode }: {
     mode: string;
 }): Plugin;
-export declare function astroContentProdBundlePlugin({ internals }: {
-    internals: BuildInternals;
-}): Plugin;
+export declare function astroConfigBuildPlugin(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

package/dist/content/vite-plugin-content-assets.js

@@ -1,7 +1,9 @@
+import npath from "node:path";
 import { pathToFileURL } from "url";
 import { moduleIsTopLevelPage, walkParentInfos } from "../core/build/graph.js";
 import { getPageDataByViteID } from "../core/build/internal.js";
 import { createViteLoader } from "../core/module-loader/vite.js";
+import { prependForwardSlash } from "../core/path.js";
 import { getStylesForURL } from "../core/render/dev/css.js";
 import { getScriptsForURL } from "../core/render/dev/scripts.js";
 import {
@@ -61,29 +63,86 @@ function astroContentAssetPropagationPlugin({ mode }) {
     }
   };
 }
-function astroContentProdBundlePlugin({ internals }) {
+function astroConfigBuildPlugin(options, internals) {
+  let ssrPluginContext = void 0;
   return {
-    name: "astro:content-prod-bundle",
-    async generateBundle(_options, bundle) {
-      var _a;
-      for (const [_, chunk] of Object.entries(bundle)) {
-        if (chunk.type === "chunk" && chunk.code.includes(LINKS_PLACEHOLDER)) {
-          for (const id of Object.keys(chunk.modules)) {
-            for (const [pageInfo, depth, order] of walkParentInfos(id, this)) {
-              if (moduleIsTopLevelPage(pageInfo)) {
-                const pageViteID = pageInfo.id;
-                const pageData = getPageDataByViteID(internals, pageViteID);
-                if (!pageData)
-                  continue;
-                const entryCss = (_a = pageData.contentCollectionCss) == null ? void 0 : _a.get(id);
-                if (!entryCss)
-                  continue;
-                chunk.code = chunk.code.replace(
-                  JSON.stringify(LINKS_PLACEHOLDER),
-                  JSON.stringify([...entryCss])
-                );
+    build: "ssr",
+    hooks: {
+      "build:before": ({ build }) => {
+        return {
+          vitePlugin: {
+            name: "astro:content-build-plugin",
+            generateBundle() {
+              if (build === "ssr") {
+                ssrPluginContext = this;
+              }
+            }
+          }
+        };
+      },
+      "build:post": ({ ssrOutputs, clientOutputs, mutate }) => {
+        var _a, _b;
+        const outputs = ssrOutputs.flatMap((o) => o.output);
+        for (const chunk of outputs) {
+          if (chunk.type === "chunk" && (chunk.code.includes(LINKS_PLACEHOLDER) || chunk.code.includes(SCRIPTS_PLACEHOLDER))) {
+            let entryCSS = /* @__PURE__ */ new Set();
+            let entryScripts = /* @__PURE__ */ new Set();
+            for (const id of Object.keys(chunk.modules)) {
+              for (const [pageInfo] of walkParentInfos(id, ssrPluginContext)) {
+                if (moduleIsTopLevelPage(pageInfo)) {
+                  const pageViteID = pageInfo.id;
+                  const pageData = getPageDataByViteID(internals, pageViteID);
+                  if (!pageData)
+                    continue;
+                  const _entryCss = (_a = pageData.propagatedStyles) == null ? void 0 : _a.get(id);
+                  const _entryScripts = (_b = pageData.propagatedScripts) == null ? void 0 : _b.get(id);
+                  if (_entryCss) {
+                    for (const value of _entryCss) {
+                      entryCSS.add(value);
+                    }
+                  }
+                  if (_entryScripts) {
+                    for (const value of _entryScripts) {
+                      entryScripts.add(value);
+                    }
+                  }
+                }
+              }
+            }
+            let newCode = chunk.code;
+            if (entryCSS.size) {
+              newCode = newCode.replace(
+                JSON.stringify(LINKS_PLACEHOLDER),
+                JSON.stringify([...entryCSS])
+              );
+            }
+            if (entryScripts.size) {
+              const entryFileNames = /* @__PURE__ */ new Set();
+              for (const output of clientOutputs) {
+                for (const clientChunk of output.output) {
+                  if (clientChunk.type !== "chunk")
+                    continue;
+                  for (const [id] of Object.entries(clientChunk.modules)) {
+                    if (entryScripts.has(id)) {
+                      entryFileNames.add(clientChunk.fileName);
+                    }
+                  }
+                }
               }
+              newCode = newCode.replace(
+                JSON.stringify(SCRIPTS_PLACEHOLDER),
+                JSON.stringify(
+                  [...entryFileNames].map((src) => ({
+                    props: {
+                      src: prependForwardSlash(npath.posix.join(options.settings.config.base, src)),
+                      type: "module"
+                    },
+                    children: ""
+                  }))
+                )
+              );
             }
+            mutate(chunk, "server", newCode);
           }
         }
       }
@@ -91,6 +150,6 @@ function astroContentProdBundlePlugin({ internals }) {
   };
 }
 export {
-  astroContentAssetPropagationPlugin,
-  astroContentProdBundlePlugin
+  astroConfigBuildPlugin,
+  astroContentAssetPropagationPlugin
 };

package/dist/content/vite-plugin-content-imports.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import type fsMod from 'node:fs';
+import type { Plugin } from 'vite';
+import { AstroSettings } from '../@types/astro.js';
+export declare function astroContentImportPlugin({ fs, settings, }: {
+    fs: typeof fsMod;
+    settings: AstroSettings;
+}): Plugin;