Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

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

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

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

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

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

@@ -0,0 +1,30 @@
+import fsMod from 'node:fs';
+import type { AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
+import type { Logger } from '../logger/core.js';
+export type SyncOptions = {
+    logger: Logger;
+    settings: AstroSettings;
+    force?: boolean;
+    skip?: {
+        content?: boolean;
+    };
+};
+export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _telemetry }?: {
+    fs?: typeof fsMod;
+    telemetry?: boolean;
+}): Promise<void>;
+/**
+ * Clears the content layer and content collection cache, forcing a full rebuild.
+ */
+export declare function clearContentLayerCache({ settings, logger, fs, }: {
+    settings: AstroSettings;
+    logger: Logger;
+    fs?: typeof fsMod;
+}): Promise<void>;
+/**
+ * Generates TypeScript types for all Astro modules. This sets up a `src/env.d.ts` file for type inferencing,
+ * and defines the `astro:content` module for the Content Collections API.
+ *
+ * @experimental The JavaScript API is experimental
+ */
+export declare function syncInternal({ logger, fs, settings, skip, force, }: SyncOptions): Promise<void>;

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

@@ -0,0 +1,164 @@
+import fsMod, { existsSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+import { fileURLToPath } from "node:url";
+import { dim } from "kleur/colors";
+import { createServer } from "vite";
+import { CONTENT_TYPES_FILE } from "../../content/consts.js";
+import { getDataStoreFile, globalContentLayer } from "../../content/content-layer.js";
+import { createContentTypesGenerator } from "../../content/index.js";
+import { MutableDataStore } from "../../content/mutable-data-store.js";
+import { getContentPaths, globalContentConfigObserver } from "../../content/utils.js";
+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 { 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,
+  AstroUserError,
+  createSafeError,
+  isAstroError
+} from "../errors/index.js";
+import { formatErrorMessage } from "../messages.js";
+import { ensureProcessNodeEnv } from "../util.js";
+import { writeFiles } from "./write-files.js";
+async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
+  ensureProcessNodeEnv("production");
+  const logger = createNodeLogger(inlineConfig);
+  const { astroConfig, userConfig } = await resolveConfig(inlineConfig ?? {}, "sync");
+  if (_telemetry) {
+    telemetry.record(eventCliSession("sync", userConfig));
+  }
+  let settings = await createSettings(astroConfig, inlineConfig.root);
+  settings = await runHookConfigSetup({
+    command: "sync",
+    settings,
+    logger
+  });
+  await runHookConfigDone({ settings, logger });
+  return await syncInternal({ settings, logger, fs, force: inlineConfig.force });
+}
+async function clearContentLayerCache({
+  settings,
+  logger,
+  fs = fsMod
+}) {
+  const dataStore = getDataStoreFile(settings);
+  if (fs.existsSync(dataStore)) {
+    logger.debug("content", "clearing data store");
+    await fs.promises.rm(dataStore, { force: true });
+    logger.warn("content", "data store cleared (force)");
+  }
+}
+async function syncInternal({
+  logger,
+  fs = fsMod,
+  settings,
+  skip,
+  force
+}) {
+  if (force) {
+    await clearContentLayerCache({ settings, logger, fs });
+  }
+  const timerStart = performance.now();
+  if (!skip?.content) {
+    await syncContentCollections(settings, { fs, logger });
+    settings.timer.start("Sync content layer");
+    let store;
+    try {
+      const dataStoreFile = getDataStoreFile(settings);
+      if (existsSync(dataStoreFile)) {
+        store = await MutableDataStore.fromFile(dataStoreFile);
+      }
+    } catch (err) {
+      logger.error("content", err.message);
+    }
+    if (!store) {
+      store = new MutableDataStore();
+    }
+    const contentLayer = globalContentLayer.init({
+      settings,
+      logger,
+      store
+    });
+    await contentLayer.sync();
+    settings.timer.end("Sync content layer");
+  } else if (fs.existsSync(fileURLToPath(getContentPaths(settings.config, fs).contentDir))) {
+    settings.injectedTypes.push({
+      filename: CONTENT_TYPES_FILE,
+      content: ""
+    });
+  }
+  syncAstroEnv(settings, fs);
+  await writeFiles(settings, fs, logger);
+  logger.info("types", `Generated ${dim(getTimeStat(timerStart, performance.now()))}`);
+}
+async function syncContentCollections(settings, { logger, fs }) {
+  const tempViteServer = await createServer(
+    await createVite(
+      {
+        server: { middlewareMode: true, hmr: false, watch: null, ws: false },
+        optimizeDeps: { noDiscovery: true },
+        ssr: { external: [] },
+        logLevel: "silent"
+      },
+      { settings, logger, mode: "build", command: "build", fs, sync: true }
+    )
+  );
+  const hotSend = tempViteServer.hot.send;
+  tempViteServer.hot.send = (payload) => {
+    if (payload.type === "error") {
+      throw payload.err;
+    }
+    return hotSend(payload);
+  };
+  try {
+    const contentTypesGenerator = await createContentTypesGenerator({
+      contentConfigObserver: globalContentConfigObserver,
+      logger,
+      fs,
+      settings,
+      viteServer: tempViteServer
+    });
+    const typesResult = await contentTypesGenerator.init();
+    const contentConfig = globalContentConfigObserver.get();
+    if (contentConfig.status === "error") {
+      throw contentConfig.error;
+    }
+    if (typesResult.typesGenerated === false) {
+      switch (typesResult.reason) {
+        case "no-content-dir":
+        default:
+          logger.debug("types", "No content directory found. Skipping type generation.");
+      }
+    }
+  } catch (e) {
+    const safeError = createSafeError(e);
+    if (isAstroError(e)) {
+      throw e;
+    }
+    const hint = AstroUserError.is(e) ? e.hint : AstroErrorData.GenerateContentTypesError.hint;
+    throw new AstroError(
+      {
+        ...AstroErrorData.GenerateContentTypesError,
+        hint,
+        message: AstroErrorData.GenerateContentTypesError.message(safeError.message),
+        location: safeError.loc
+      },
+      { cause: e }
+    );
+  } finally {
+    await tempViteServer.close();
+  }
+}
+export {
+  clearContentLayerCache,
+  sync as default,
+  syncInternal
+};

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,67 @@
+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
+};