full site update

node_modules/astro/dist/core/sync/constants.d.ts

@@ -1 +0,0 @@
-export declare const REFERENCE_FILE = "./types.d.ts";

node_modules/astro/dist/core/sync/constants.js

@@ -1,4 +0,0 @@
-const REFERENCE_FILE = "./types.d.ts";
-export {
-  REFERENCE_FILE
-};

node_modules/astro/dist/core/sync/index.d.ts

@@ -1,13 +1,22 @@
 import fsMod from 'node:fs';
-import type { AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
+import { type FSWatcher } from 'vite';
+import type { AstroSettings, RoutesList } from '../../types/astro.js';
+import type { AstroInlineConfig } from '../../types/public/config.js';
+import type { SSRManifest } from '../app/types.js';
 import type { Logger } from '../logger/core.js';
-export type SyncOptions = {
+type SyncOptions = {
+    mode: string;
     logger: Logger;
     settings: AstroSettings;
     force?: boolean;
     skip?: {
         content?: boolean;
+        cleanup?: boolean;
     };
+    routesList: RoutesList;
+    manifest: SSRManifest;
+    command: 'build' | 'dev' | 'sync';
+    watcher?: FSWatcher;
 };
 export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _telemetry }?: {
     fs?: typeof fsMod;
@@ -16,10 +25,11 @@ export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _
 /**
  * Clears the content layer and content collection cache, forcing a full rebuild.
  */
-export declare function clearContentLayerCache({ settings, logger, fs, }: {
+export declare function clearContentLayerCache({ settings, logger, fs, isDev, }: {
     settings: AstroSettings;
     logger: Logger;
     fs?: typeof fsMod;
+    isDev: boolean;
 }): Promise<void>;
 /**
  * Generates TypeScript types for all Astro modules. This sets up a `src/env.d.ts` file for type inferencing,
@@ -27,4 +37,5 @@ export declare function clearContentLayerCache({ settings, logger, fs, }: {
  *
  * @experimental The JavaScript API is experimental
  */
-export declare function syncInternal({ logger, fs, settings, skip, force, }: SyncOptions): Promise<void>;
+export declare function syncInternal({ mode, logger, fs, settings, skip, force, routesList, command, watcher, manifest, }: SyncOptions): Promise<void>;
+export {};

node_modules/astro/dist/core/sync/index.js

@@ -1,8 +1,10 @@
-import fsMod, { existsSync } from "node:fs";
+import fsMod from "node:fs";
+import { dirname, relative } from "node:path";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
 import { dim } from "kleur/colors";
 import { createServer } from "vite";
+import { syncFonts } from "../../assets/fonts/sync.js";
 import { CONTENT_TYPES_FILE } from "../../content/consts.js";
 import { getDataStoreFile, globalContentLayer } from "../../content/content-layer.js";
 import { createContentTypesGenerator } from "../../content/index.js";
@@ -12,12 +14,12 @@ import { syncAstroEnv } from "../../env/sync.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
 import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
+import { createDevelopmentManifest } from "../../vite-plugin-astro-server/plugin.js";
 import { getTimeStat } from "../build/util.js";
 import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
 import { createSettings } from "../config/settings.js";
 import { createVite } from "../create-vite.js";
-import { collectErrorMetadata } from "../errors/dev/utils.js";
 import {
   AstroError,
   AstroErrorData,
@@ -25,9 +27,9 @@ import {
   createSafeError,
   isAstroError
 } from "../errors/index.js";
-import { formatErrorMessage } from "../messages.js";
+import { createRoutesList } from "../routing/index.js";
 import { ensureProcessNodeEnv } from "../util.js";
-import { writeFiles } from "./write-files.js";
+import { normalizePath } from "../viteUtils.js";
 async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
@@ -41,15 +43,27 @@ async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
     settings,
     logger
   });
+  const routesList = await createRoutesList({ settings, fsMod: fs }, logger);
+  const manifest = createDevelopmentManifest(settings);
   await runHookConfigDone({ settings, logger });
-  return await syncInternal({ settings, logger, fs, force: inlineConfig.force });
+  return await syncInternal({
+    settings,
+    logger,
+    mode: "production",
+    fs,
+    force: inlineConfig.force,
+    routesList,
+    command: "sync",
+    manifest
+  });
 }
 async function clearContentLayerCache({
   settings,
   logger,
-  fs = fsMod
+  fs = fsMod,
+  isDev
 }) {
-  const dataStore = getDataStoreFile(settings);
+  const dataStore = getDataStoreFile(settings, isDev);
   if (fs.existsSync(dataStore)) {
     logger.debug("content", "clearing data store");
     await fs.promises.rm(dataStore, { force: true });
@@ -57,49 +71,96 @@ async function clearContentLayerCache({
   }
 }
 async function syncInternal({
+  mode,
   logger,
   fs = fsMod,
   settings,
   skip,
-  force
+  force,
+  routesList,
+  command,
+  watcher,
+  manifest
 }) {
+  const isDev = command === "dev";
   if (force) {
-    await clearContentLayerCache({ settings, logger, fs });
+    await clearContentLayerCache({ settings, logger, fs, isDev });
   }
   const timerStart = performance.now();
   if (!skip?.content) {
-    await syncContentCollections(settings, { fs, logger });
+    await syncContentCollections(settings, { mode, fs, logger, routesList, manifest });
     settings.timer.start("Sync content layer");
     let store;
     try {
-      const dataStoreFile = getDataStoreFile(settings);
-      if (existsSync(dataStoreFile)) {
-        store = await MutableDataStore.fromFile(dataStoreFile);
-      }
+      const dataStoreFile = getDataStoreFile(settings, isDev);
+      store = await MutableDataStore.fromFile(dataStoreFile);
     } catch (err) {
       logger.error("content", err.message);
     }
     if (!store) {
-      store = new MutableDataStore();
+      logger.error("content", "Failed to load content store");
+      return;
     }
     const contentLayer = globalContentLayer.init({
       settings,
       logger,
-      store
+      store,
+      watcher
     });
+    if (watcher) {
+      contentLayer.watchContentConfig();
+    }
     await contentLayer.sync();
+    if (!skip?.cleanup) {
+      contentLayer.dispose();
+    }
     settings.timer.end("Sync content layer");
-  } else if (fs.existsSync(fileURLToPath(getContentPaths(settings.config, fs).contentDir))) {
-    settings.injectedTypes.push({
-      filename: CONTENT_TYPES_FILE,
-      content: ""
-    });
+  } else {
+    const paths = getContentPaths(settings.config, fs);
+    if (paths.config.exists || // Legacy collections don't require a config file
+    settings.config.legacy?.collections && fs.existsSync(paths.contentDir)) {
+      settings.injectedTypes.push({
+        filename: CONTENT_TYPES_FILE
+      });
+    }
   }
-  syncAstroEnv(settings, fs);
-  await writeFiles(settings, fs, logger);
+  syncAstroEnv(settings);
+  syncFonts(settings);
+  writeInjectedTypes(settings, fs);
   logger.info("types", `Generated ${dim(getTimeStat(timerStart, performance.now()))}`);
 }
-async function syncContentCollections(settings, { logger, fs }) {
+function getTsReference(type, value) {
+  return `/// <reference ${type}=${JSON.stringify(value)} />`;
+}
+const CLIENT_TYPES_REFERENCE = getTsReference("types", "astro/client");
+function writeInjectedTypes(settings, fs) {
+  const references = [];
+  for (const { filename, content } of settings.injectedTypes) {
+    const filepath = fileURLToPath(new URL(filename, settings.dotAstroDir));
+    fs.mkdirSync(dirname(filepath), { recursive: true });
+    if (content) {
+      fs.writeFileSync(filepath, content, "utf-8");
+    }
+    references.push(normalizePath(relative(fileURLToPath(settings.dotAstroDir), filepath)));
+  }
+  const astroDtsContent = `${CLIENT_TYPES_REFERENCE}
+${references.map((reference) => getTsReference("path", reference)).join("\n")}`;
+  if (references.length === 0) {
+    fs.mkdirSync(settings.dotAstroDir, { recursive: true });
+  }
+  fs.writeFileSync(
+    fileURLToPath(new URL("./types.d.ts", settings.dotAstroDir)),
+    astroDtsContent,
+    "utf-8"
+  );
+}
+async function syncContentCollections(settings, {
+  mode,
+  logger,
+  fs,
+  routesList,
+  manifest
+}) {
   const tempViteServer = await createServer(
     await createVite(
       {
@@ -108,7 +169,7 @@ async function syncContentCollections(settings, { logger, fs }) {
         ssr: { external: [] },
         logLevel: "silent"
       },
-      { settings, logger, mode: "build", command: "build", fs, sync: true }
+      { settings, logger, mode, command: "build", fs, sync: true, routesList, manifest }
     )
   );
   const hotSend = tempViteServer.hot.send;
@@ -143,7 +204,18 @@ async function syncContentCollections(settings, { logger, fs }) {
     if (isAstroError(e)) {
       throw e;
     }
-    const hint = AstroUserError.is(e) ? e.hint : AstroErrorData.GenerateContentTypesError.hint;
+    let configFile;
+    try {
+      const contentPaths = getContentPaths(settings.config, fs);
+      if (contentPaths.config.exists) {
+        const matches = /\/(src\/.+)/.exec(contentPaths.config.url.href);
+        if (matches) {
+          configFile = matches[1];
+        }
+      }
+    } catch {
+    }
+    const hint = AstroUserError.is(e) ? e.hint : AstroErrorData.GenerateContentTypesError.hint(configFile);
     throw new AstroError(
       {
         ...AstroErrorData.GenerateContentTypesError,

node_modules/astro/dist/core/sync/write-files.d.ts

@@ -1,4 +0,0 @@
-import type fsMod from 'node:fs';
-import type { AstroSettings } from '../../@types/astro.js';
-import type { Logger } from '../logger/core.js';
-export declare function writeFiles(settings: AstroSettings, fs: typeof fsMod, logger: Logger): Promise<void>;

node_modules/astro/dist/core/sync/write-files.js

@@ -1,67 +0,0 @@
-import { dirname, relative } from "node:path";
-import { fileURLToPath } from "node:url";
-import { bold } from "kleur/colors";
-import { normalizePath } from "vite";
-import { AstroError, AstroErrorData } from "../errors/index.js";
-import { REFERENCE_FILE } from "./constants.js";
-async function writeFiles(settings, fs, logger) {
-  try {
-    writeInjectedTypes(settings, fs);
-    await setUpEnvTs(settings, fs, logger);
-  } catch (e) {
-    throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: e });
-  }
-}
-function getTsReference(type, value) {
-  return `/// <reference ${type}=${JSON.stringify(value)} />`;
-}
-const CLIENT_TYPES_REFERENCE = getTsReference("types", "astro/client");
-function writeInjectedTypes(settings, fs) {
-  const references = [];
-  for (const { filename, content } of settings.injectedTypes) {
-    const filepath = fileURLToPath(new URL(filename, settings.dotAstroDir));
-    fs.mkdirSync(dirname(filepath), { recursive: true });
-    fs.writeFileSync(filepath, content, "utf-8");
-    references.push(normalizePath(relative(fileURLToPath(settings.dotAstroDir), filepath)));
-  }
-  const astroDtsContent = `${CLIENT_TYPES_REFERENCE}
-${references.map((reference) => getTsReference("path", reference)).join("\n")}`;
-  if (references.length === 0) {
-    fs.mkdirSync(settings.dotAstroDir, { recursive: true });
-  }
-  fs.writeFileSync(
-    fileURLToPath(new URL(REFERENCE_FILE, settings.dotAstroDir)),
-    astroDtsContent,
-    "utf-8"
-  );
-}
-async function setUpEnvTs(settings, fs, logger) {
-  const envTsPath = fileURLToPath(new URL("env.d.ts", settings.config.srcDir));
-  const envTsPathRelativetoRoot = relative(fileURLToPath(settings.config.root), envTsPath);
-  const relativePath = normalizePath(
-    relative(
-      fileURLToPath(settings.config.srcDir),
-      fileURLToPath(new URL(REFERENCE_FILE, settings.dotAstroDir))
-    )
-  );
-  const expectedTypeReference = getTsReference("path", relativePath);
-  if (fs.existsSync(envTsPath)) {
-    const initialEnvContents = await fs.promises.readFile(envTsPath, "utf-8");
-    let typesEnvContents = initialEnvContents;
-    if (!typesEnvContents.includes(expectedTypeReference)) {
-      typesEnvContents = `${expectedTypeReference}
-${typesEnvContents}`;
-    }
-    if (initialEnvContents !== typesEnvContents) {
-      logger.info("types", `Updated ${bold(envTsPathRelativetoRoot)} type declarations.`);
-      await fs.promises.writeFile(envTsPath, typesEnvContents, "utf-8");
-    }
-  } else {
-    await fs.promises.mkdir(settings.config.srcDir, { recursive: true });
-    await fs.promises.writeFile(envTsPath, expectedTypeReference, "utf-8");
-    logger.info("types", `Added ${bold(envTsPathRelativetoRoot)} type declarations`);
-  }
-}
-export {
-  writeFiles
-};