astro 1.6.14 → 1.7.0

package/dist/@types/astro.d.ts

@@ -60,6 +60,9 @@ export interface CLIFlags {
     port?: number;
     config?: string;
     drafts?: boolean;
+    experimentalErrorOverlay?: boolean;
+    experimentalPrerender?: boolean;
+    experimentalContentCollections?: boolean;
 }
 export interface BuildConfig {
     /**
@@ -392,6 +395,8 @@ export interface AstroUserConfig {
      * @description
      * The base path to deploy to. Astro will build your pages and assets using this path as the root. Currently, this has no effect during development.
      *
+     * You can access this value in your app via `import.meta.env.BASE_URL`.
+     *
      * ```js
      * {
      *   base: '/docs'
@@ -836,6 +841,60 @@ export interface AstroUserConfig {
          */
         astroFlavoredMarkdown?: boolean;
     };
+    /**
+     * @docs
+     * @kind heading
+     * @name Experimental Flags
+     * @description
+     * Astro offers experimental flags to give users early access to new features.
+     * These flags are not guaranteed to be stable.
+     */
+    experimental?: {
+        /**
+         * @hidden
+         * Turn on experimental support for the new error overlay component.
+         */
+        errorOverlay?: boolean;
+        /**
+         * @docs
+         * @name experimental.prerender
+         * @type {boolean}
+         * @default `false`
+         * @version 1.7.0
+         * @description
+         * Enable experimental support for prerendered pages when generating a server.
+         *
+         * To enable this feature, set `experimental.prerender` to `true` in your Astro config:
+         *
+         * ```js
+         * {
+         * 	experimental: {
+         *		prerender: true,
+         * 	},
+         * }
+         * ```
+         */
+        prerender?: boolean;
+        /**
+         * @docs
+         * @name experimental.contentCollections
+         * @type {boolean}
+         * @default `false`
+         * @version 1.7.0
+         * @description
+         * Enable experimental support for [Content Collections](/en/guides/content-collections). This makes the `src/content/` directory a reserved directory for Astro to manage, and introduces the `astro:content` module for querying this content.
+         *
+         * To enable this feature, set `experimental.contentCollections` to `true` in your Astro config:
+         *
+         * ```js
+         * {
+         * 	experimental: {
+         *		contentCollections: true,
+         * 	},
+         * }
+         */
+        contentCollections?: boolean;
+    };
     /** @deprecated - Use "integrations" instead. Run Astro to learn more about migrating. */
     renderers?: never;
     /** @deprecated `projectRoot` has been renamed to `root` */

package/dist/content/consts.d.ts

@@ -0,0 +1,9 @@
+export declare const contentFileExts: string[];
+export declare const DELAYED_ASSET_FLAG = "astroAssetSsr";
+export declare const CONTENT_FLAG = "astroContent";
+export declare const VIRTUAL_MODULE_ID = "astro:content";
+export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
+export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
+export declare const CONTENT_BASE = "types.generated";
+export declare const CONTENT_FILE: string;
+export declare const CONTENT_TYPES_FILE: string;

package/dist/content/consts.js

@@ -0,0 +1,20 @@
+const contentFileExts = [".md", ".mdx"];
+const DELAYED_ASSET_FLAG = "astroAssetSsr";
+const CONTENT_FLAG = "astroContent";
+const VIRTUAL_MODULE_ID = "astro:content";
+const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
+const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
+const CONTENT_BASE = "types.generated";
+const CONTENT_FILE = CONTENT_BASE + ".mjs";
+const CONTENT_TYPES_FILE = CONTENT_BASE + ".d.ts";
+export {
+  CONTENT_BASE,
+  CONTENT_FILE,
+  CONTENT_FLAG,
+  CONTENT_TYPES_FILE,
+  DELAYED_ASSET_FLAG,
+  LINKS_PLACEHOLDER,
+  STYLES_PLACEHOLDER,
+  VIRTUAL_MODULE_ID,
+  contentFileExts
+};

package/dist/content/index.d.ts

@@ -0,0 +1,3 @@
+export { astroBundleDelayedAssetPlugin, astroDelayedAssetPlugin, } from './vite-plugin-content-assets.js';
+export { astroContentServerPlugin } from './vite-plugin-content-server.js';
+export { astroContentVirtualModPlugin } from './vite-plugin-content-virtual-mod.js';

package/dist/content/index.js

@@ -0,0 +1,12 @@
+import {
+  astroBundleDelayedAssetPlugin,
+  astroDelayedAssetPlugin
+} from "./vite-plugin-content-assets.js";
+import { astroContentServerPlugin } from "./vite-plugin-content-server.js";
+import { astroContentVirtualModPlugin } from "./vite-plugin-content-virtual-mod.js";
+export {
+  astroBundleDelayedAssetPlugin,
+  astroContentServerPlugin,
+  astroContentVirtualModPlugin,
+  astroDelayedAssetPlugin
+};

package/dist/content/internal.d.ts

@@ -0,0 +1,37 @@
+declare type GlobResult = Record<string, () => Promise<any>>;
+declare type CollectionToEntryMap = Record<string, GlobResult>;
+export declare function createCollectionToGlobResultMap({ globResult, contentDir, }: {
+    globResult: GlobResult;
+    contentDir: string;
+}): CollectionToEntryMap;
+export declare function createGetCollection({ collectionToEntryMap, collectionToRenderEntryMap, }: {
+    collectionToEntryMap: CollectionToEntryMap;
+    collectionToRenderEntryMap: CollectionToEntryMap;
+}): (collection: string, filter?: () => boolean) => Promise<{
+    id: any;
+    slug: any;
+    body: any;
+    collection: any;
+    data: any;
+    render(): Promise<{
+        Content: import("../runtime/server/index.js").AstroComponentFactory;
+        headings: any;
+        injectedFrontmatter: any;
+    }>;
+}[]>;
+export declare function createGetEntry({ collectionToEntryMap, collectionToRenderEntryMap, }: {
+    collectionToEntryMap: CollectionToEntryMap;
+    collectionToRenderEntryMap: CollectionToEntryMap;
+}): (collection: string, entryId: string) => Promise<{
+    id: any;
+    slug: any;
+    body: any;
+    collection: any;
+    data: any;
+    render(): Promise<{
+        Content: import("../runtime/server/index.js").AstroComponentFactory;
+        headings: any;
+        injectedFrontmatter: any;
+    }>;
+}>;
+export {};

package/dist/content/internal.js

@@ -0,0 +1,131 @@
+import { prependForwardSlash } from "../core/path.js";
+import {
+  createComponent,
+  createHeadAndContent,
+  renderComponent,
+  renderStyleElement,
+  renderTemplate,
+  renderUniqueStylesheet,
+  unescapeHTML
+} from "../runtime/server/index.js";
+function createCollectionToGlobResultMap({
+  globResult,
+  contentDir
+}) {
+  const collectionToGlobResultMap = {};
+  for (const key in globResult) {
+    const keyRelativeToContentDir = key.replace(new RegExp(`^${contentDir}`), "");
+    const segments = keyRelativeToContentDir.split("/");
+    if (segments.length <= 1)
+      continue;
+    const collection = segments[0];
+    const entryId = segments.slice(1).join("/");
+    collectionToGlobResultMap[collection] ?? (collectionToGlobResultMap[collection] = {});
+    collectionToGlobResultMap[collection][entryId] = globResult[key];
+  }
+  return collectionToGlobResultMap;
+}
+function createGetCollection({
+  collectionToEntryMap,
+  collectionToRenderEntryMap
+}) {
+  return async function getCollection(collection, filter) {
+    const lazyImports = Object.values(collectionToEntryMap[collection] ?? {});
+    const entries = Promise.all(
+      lazyImports.map(async (lazyImport) => {
+        const entry = await lazyImport();
+        return {
+          id: entry.id,
+          slug: entry.slug,
+          body: entry.body,
+          collection: entry.collection,
+          data: entry.data,
+          async render() {
+            return render({
+              collection: entry.collection,
+              id: entry.id,
+              collectionToRenderEntryMap
+            });
+          }
+        };
+      })
+    );
+    if (typeof filter === "function") {
+      return (await entries).filter(filter);
+    } else {
+      return entries;
+    }
+  };
+}
+function createGetEntry({
+  collectionToEntryMap,
+  collectionToRenderEntryMap
+}) {
+  return async function getEntry(collection, entryId) {
+    var _a;
+    const lazyImport = (_a = collectionToEntryMap[collection]) == null ? void 0 : _a[entryId];
+    if (!lazyImport)
+      throw new Error(`Failed to import ${JSON.stringify(entryId)}.`);
+    const entry = await lazyImport();
+    return {
+      id: entry.id,
+      slug: entry.slug,
+      body: entry.body,
+      collection: entry.collection,
+      data: entry.data,
+      async render() {
+        return render({
+          collection: entry.collection,
+          id: entry.id,
+          collectionToRenderEntryMap
+        });
+      }
+    };
+  };
+}
+async function render({
+  collection,
+  id,
+  collectionToRenderEntryMap
+}) {
+  var _a;
+  const lazyImport = (_a = collectionToRenderEntryMap[collection]) == null ? void 0 : _a[id];
+  if (!lazyImport)
+    throw new Error(`${String(collection)} \u2192 ${String(id)} does not exist.`);
+  const mod = await lazyImport();
+  const Content = createComponent({
+    factory(result, props, slots) {
+      let styles = "", links = "";
+      if (Array.isArray(mod == null ? void 0 : mod.collectedStyles)) {
+        styles = mod.collectedStyles.map((style) => renderStyleElement(style)).join("");
+      }
+      if (Array.isArray(mod == null ? void 0 : mod.collectedLinks)) {
+        links = mod.collectedLinks.map((link) => {
+          return renderUniqueStylesheet(result, {
+            href: prependForwardSlash(link)
+          });
+        }).join("");
+      }
+      return createHeadAndContent(
+        unescapeHTML(styles + links),
+        renderTemplate`${renderComponent(result, "Content", mod.Content, props, slots)}`
+      );
+    },
+    propagation: "self"
+  });
+  if (!mod._internal && id.endsWith(".mdx")) {
+    throw new Error(
+      `[Content] Failed to render MDX entry. Try installing @astrojs/mdx@next--content-schemas`
+    );
+  }
+  return {
+    Content,
+    headings: mod.getHeadings(),
+    injectedFrontmatter: mod._internal.injectedFrontmatter
+  };
+}
+export {
+  createCollectionToGlobResultMap,
+  createGetCollection,
+  createGetEntry
+};

package/dist/content/template/types.generated.d.mts

@@ -0,0 +1,3 @@
+export function defineCollection(config: any): any;
+export const getCollection: any;
+export const getEntry: any;

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

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import fsMod from 'node:fs';
+import type { AstroSettings } from '../@types/astro.js';
+import { LogOptions } from '../core/logger/core.js';
+import { ContentObservable, ContentPaths } from './utils.js';
+declare type ChokidarEvent = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
+declare type RawContentEvent = {
+    name: ChokidarEvent;
+    entry: string;
+};
+declare type EntryInfo = {
+    id: string;
+    slug: string;
+    collection: string;
+};
+export declare type GenerateContentTypes = {
+    init(): Promise<void>;
+    queueEvent(event: RawContentEvent): void;
+};
+declare type CreateContentGeneratorParams = {
+    contentPaths: ContentPaths;
+    contentConfigObserver: ContentObservable;
+    logging: LogOptions;
+    settings: AstroSettings;
+    fs: typeof fsMod;
+};
+export declare function createContentTypesGenerator({ contentPaths, contentConfigObserver, fs, logging, settings, }: CreateContentGeneratorParams): Promise<GenerateContentTypes>;
+export declare function getEntryInfo({ entry, contentDir, }: Pick<ContentPaths, 'contentDir'> & {
+    entry: URL;
+}): EntryInfo | Error;
+export declare function getEntryType(entryPath: string, paths: ContentPaths): 'content' | 'config' | 'unknown' | 'generated-types';
+export {};

package/dist/content/types-generator.js

@@ -0,0 +1,290 @@
+import glob from "fast-glob";
+import { cyan } from "kleur/colors";
+import fsMod from "node:fs";
+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 { loadContentConfig } from "./utils.js";
+class UnsupportedFileTypeError extends Error {
+}
+async function createContentTypesGenerator({
+  contentPaths,
+  contentConfigObserver,
+  fs,
+  logging,
+  settings
+}) {
+  const contentTypes = {};
+  let events = [];
+  let debounceTimeout;
+  const contentTypesBase = await fsMod.promises.readFile(
+    new URL(CONTENT_TYPES_FILE, contentPaths.generatedInputDir),
+    "utf-8"
+  );
+  async function init() {
+    await handleEvent({ name: "add", entry: contentPaths.config }, { logLevel: "warn" });
+    const globResult = await glob("./**/*.*", {
+      cwd: fileURLToPath(contentPaths.contentDir),
+      fs: {
+        readdir: fs.readdir.bind(fs),
+        readdirSync: fs.readdirSync.bind(fs)
+      }
+    });
+    const entries = globResult.map((e) => new URL(e, contentPaths.contentDir)).filter(
+      (e) => !e.href.startsWith(contentPaths.config.href)
+    );
+    for (const entry of entries) {
+      events.push(handleEvent({ name: "add", entry }, { logLevel: "warn" }));
+    }
+    await runEvents();
+  }
+  async function handleEvent(event, opts) {
+    const logLevel = (opts == null ? void 0 : opts.logLevel) ?? "info";
+    if (event.name === "addDir" || event.name === "unlinkDir") {
+      const collection2 = normalizePath(
+        path.relative(fileURLToPath(contentPaths.contentDir), fileURLToPath(event.entry))
+      );
+      const isCollectionEvent = collection2.split("/").length === 1;
+      if (!isCollectionEvent)
+        return { shouldGenerateTypes: false };
+      switch (event.name) {
+        case "addDir":
+          addCollection(contentTypes, JSON.stringify(collection2));
+          if (logLevel === "info") {
+            info(logging, "content", `${cyan(collection2)} collection added`);
+          }
+          break;
+        case "unlinkDir":
+          removeCollection(contentTypes, JSON.stringify(collection2));
+          break;
+      }
+      return { shouldGenerateTypes: true };
+    }
+    const fileType = getEntryType(fileURLToPath(event.entry), contentPaths);
+    if (fileType === "generated-types") {
+      return { shouldGenerateTypes: false };
+    }
+    if (fileType === "config") {
+      contentConfigObserver.set({ status: "loading" });
+      const config = await loadContentConfig({ fs, settings });
+      if (config instanceof Error) {
+        contentConfigObserver.set({ status: "error", error: config });
+      } else {
+        contentConfigObserver.set({ status: "loaded", config });
+      }
+      return { shouldGenerateTypes: true };
+    }
+    const entryInfo = getEntryInfo({
+      entry: event.entry,
+      contentDir: contentPaths.contentDir
+    });
+    if (entryInfo instanceof Error)
+      return { shouldGenerateTypes: false };
+    if (fileType === "unknown") {
+      if (entryInfo.id.startsWith("_") && (event.name === "add" || event.name === "change")) {
+        return { shouldGenerateTypes: false };
+      } else {
+        return {
+          shouldGenerateTypes: false,
+          error: new UnsupportedFileTypeError(entryInfo.id)
+        };
+      }
+    }
+    if (entryInfo.collection === ".") {
+      if (["info", "warn"].includes(logLevel)) {
+        warn(
+          logging,
+          "content",
+          `${cyan(
+            normalizePath(
+              path.relative(fileURLToPath(contentPaths.contentDir), fileURLToPath(event.entry))
+            )
+          )} must be nested in a collection directory. Skipping.`
+        );
+      }
+      return { shouldGenerateTypes: false };
+    }
+    const { id, slug, collection } = entryInfo;
+    const collectionKey = JSON.stringify(collection);
+    const entryKey = JSON.stringify(id);
+    switch (event.name) {
+      case "add":
+        if (!(collectionKey in contentTypes)) {
+          addCollection(contentTypes, collectionKey);
+        }
+        if (!(entryKey in contentTypes[collectionKey])) {
+          addEntry(contentTypes, collectionKey, entryKey, slug);
+        }
+        return { shouldGenerateTypes: true };
+      case "unlink":
+        if (collectionKey in contentTypes && entryKey in contentTypes[collectionKey]) {
+          removeEntry(contentTypes, collectionKey, entryKey);
+        }
+        return { shouldGenerateTypes: true };
+      case "change":
+        return { shouldGenerateTypes: false };
+    }
+  }
+  function queueEvent(rawEvent, opts) {
+    const event = {
+      entry: pathToFileURL(rawEvent.entry),
+      name: rawEvent.name
+    };
+    if (!event.entry.pathname.startsWith(contentPaths.contentDir.pathname))
+      return;
+    events.push(handleEvent(event, opts));
+    debounceTimeout && clearTimeout(debounceTimeout);
+    debounceTimeout = setTimeout(
+      async () => runEvents(opts),
+      50
+    );
+  }
+  async function runEvents(opts) {
+    const logLevel = (opts == null ? void 0 : opts.logLevel) ?? "info";
+    const eventResponses = await Promise.all(events);
+    events = [];
+    let unsupportedFiles = [];
+    for (const response of eventResponses) {
+      if (response.error instanceof UnsupportedFileTypeError) {
+        unsupportedFiles.push(response.error.message);
+      }
+    }
+    if (unsupportedFiles.length > 0 && ["info", "warn"].includes(logLevel)) {
+      warn(
+        logging,
+        "content",
+        `Unsupported file types found. Prefix with an underscore (\`_\`) to ignore:
+- ${unsupportedFiles.join(
+          "\n"
+        )}`
+      );
+    }
+    const observable = contentConfigObserver.get();
+    if (eventResponses.some((r) => r.shouldGenerateTypes)) {
+      await writeContentFiles({
+        fs,
+        contentTypes,
+        contentPaths,
+        contentTypesBase,
+        contentConfig: observable.status === "loaded" ? observable.config : void 0
+      });
+      if (observable.status === "loaded" && ["info", "warn"].includes(logLevel)) {
+        warnNonexistentCollections({
+          logging,
+          contentConfig: observable.config,
+          contentTypes
+        });
+      }
+    }
+  }
+  return { init, queueEvent };
+}
+function addCollection(contentMap, collectionKey) {
+  contentMap[collectionKey] = {};
+}
+function removeCollection(contentMap, collectionKey) {
+  delete contentMap[collectionKey];
+}
+function addEntry(contentTypes, collectionKey, entryKey, slug) {
+  contentTypes[collectionKey][entryKey] = { slug };
+}
+function removeEntry(contentTypes, collectionKey, entryKey) {
+  delete contentTypes[collectionKey][entryKey];
+}
+function getEntryInfo({
+  entry,
+  contentDir
+}) {
+  const rawRelativePath = path.relative(fileURLToPath(contentDir), fileURLToPath(entry));
+  const rawCollection = path.dirname(rawRelativePath).split(path.sep).shift();
+  if (!rawCollection)
+    return new Error();
+  const rawId = path.relative(rawCollection, rawRelativePath);
+  const rawSlug = rawId.replace(path.extname(rawId), "");
+  const res = {
+    id: normalizePath(rawId),
+    slug: normalizePath(rawSlug),
+    collection: normalizePath(rawCollection)
+  };
+  return res;
+}
+function getEntryType(entryPath, paths) {
+  const { dir: rawDir, ext, name, base } = path.parse(entryPath);
+  const dir = appendForwardSlash(pathToFileURL(rawDir).href);
+  if (contentFileExts.includes(ext)) {
+    return "content";
+  } else if (new URL(name, dir).pathname === paths.config.pathname) {
+    return "config";
+  } else if (new URL(base, dir).pathname === new URL(CONTENT_TYPES_FILE, paths.cacheDir).pathname) {
+    return "generated-types";
+  } else {
+    return "unknown";
+  }
+}
+async function writeContentFiles({
+  fs,
+  contentPaths,
+  contentTypes,
+  contentTypesBase,
+  contentConfig
+}) {
+  let contentTypesStr = "";
+  const collectionKeys = Object.keys(contentTypes).sort();
+  for (const collectionKey of collectionKeys) {
+    const collectionConfig = contentConfig == null ? void 0 : contentConfig.collections[JSON.parse(collectionKey)];
+    contentTypesStr += `${collectionKey}: {
+`;
+    const entryKeys = Object.keys(contentTypes[collectionKey]).sort();
+    for (const entryKey of entryKeys) {
+      const entryMetadata = contentTypes[collectionKey][entryKey];
+      const dataType = (collectionConfig == null ? void 0 : collectionConfig.schema) ? `InferEntrySchema<${collectionKey}>` : "any";
+      const slugType = (collectionConfig == null ? void 0 : collectionConfig.slug) ? "string" : JSON.stringify(entryMetadata.slug);
+      contentTypesStr += `${entryKey}: {
+  id: ${entryKey},
+  slug: ${slugType},
+  body: string,
+  collection: ${collectionKey},
+  data: ${dataType}
+},
+`;
+    }
+    contentTypesStr += `},
+`;
+  }
+  let configPathRelativeToCacheDir = normalizePath(
+    path.relative(contentPaths.cacheDir.pathname, contentPaths.config.pathname)
+  );
+  if (!isRelativePath(configPathRelativeToCacheDir))
+    configPathRelativeToCacheDir = "./" + configPathRelativeToCacheDir;
+  contentTypesBase = contentTypesBase.replace("// @@ENTRY_MAP@@", contentTypesStr);
+  contentTypesBase = contentTypesBase.replace(
+    "'@@CONTENT_CONFIG_TYPE@@'",
+    contentConfig ? `typeof import(${JSON.stringify(configPathRelativeToCacheDir)})` : "never"
+  );
+  await fs.promises.writeFile(new URL(CONTENT_TYPES_FILE, contentPaths.cacheDir), contentTypesBase);
+}
+function warnNonexistentCollections({
+  contentConfig,
+  contentTypes,
+  logging
+}) {
+  for (const configuredCollection in contentConfig.collections) {
+    if (!contentTypes[JSON.stringify(configuredCollection)]) {
+      warn(
+        logging,
+        "content",
+        `${JSON.stringify(
+          configuredCollection
+        )} is not a collection. Check your content config for typos.`
+      );
+    }
+  }
+}
+export {
+  createContentTypesGenerator,
+  getEntryInfo,
+  getEntryType
+};