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/module-loader/index.d.ts

@@ -0,0 +1,3 @@
+export { createLoader } from './loader.js';
+export type { LoaderEvents, ModuleInfo, ModuleLoader, ModuleNode } from './loader.js';
+export { createViteLoader } from './vite.js';

node_modules/astro/dist/core/module-loader/index.js

@@ -0,0 +1,6 @@
+import { createLoader } from "./loader.js";
+import { createViteLoader } from "./vite.js";
+export {
+  createLoader,
+  createViteLoader
+};

node_modules/astro/dist/core/module-loader/loader.d.ts

@@ -0,0 +1,47 @@
+import type * as fs from 'node:fs';
+import type { TypedEventEmitter } from '../../@types/typed-emitter.js';
+export type LoaderEvents = {
+    'file-add': (msg: [path: string, stats?: fs.Stats | undefined]) => void;
+    'file-change': (msg: [path: string, stats?: fs.Stats | undefined]) => void;
+    'file-unlink': (msg: [path: string, stats?: fs.Stats | undefined]) => void;
+    'hmr-error': (msg: {
+        type: 'error';
+        err: {
+            message: string;
+            stack: string;
+        };
+    }) => void;
+};
+export type ModuleLoaderEventEmitter = TypedEventEmitter<LoaderEvents>;
+export interface ModuleLoader {
+    import: (src: string) => Promise<Record<string, any>>;
+    resolveId: (specifier: string, parentId: string | undefined) => Promise<string | undefined>;
+    getModuleById: (id: string) => ModuleNode | undefined;
+    getModulesByFile: (file: string) => Set<ModuleNode> | undefined;
+    getModuleInfo: (id: string) => ModuleInfo | null;
+    eachModule(callbackfn: (value: ModuleNode, key: string) => void): void;
+    invalidateModule(mod: ModuleNode): void;
+    fixStacktrace: (error: Error) => void;
+    clientReload: () => void;
+    webSocketSend: (msg: any) => void;
+    isHttps: () => boolean;
+    events: TypedEventEmitter<LoaderEvents>;
+}
+export interface ModuleNode {
+    id: string | null;
+    url: string;
+    file: string | null;
+    ssrModule: Record<string, any> | null;
+    ssrTransformResult: {
+        deps?: string[];
+        dynamicDeps?: string[];
+    } | null;
+    ssrError: Error | null;
+    importedModules: Set<ModuleNode>;
+    importers: Set<ModuleNode>;
+}
+export interface ModuleInfo {
+    id: string;
+    meta?: Record<string, any>;
+}
+export declare function createLoader(overrides: Partial<ModuleLoader>): ModuleLoader;

node_modules/astro/dist/core/module-loader/loader.js

@@ -0,0 +1,39 @@
+import { EventEmitter } from "node:events";
+function createLoader(overrides) {
+  return {
+    import() {
+      throw new Error(`Not implemented`);
+    },
+    resolveId(id) {
+      return Promise.resolve(id);
+    },
+    getModuleById() {
+      return void 0;
+    },
+    getModulesByFile() {
+      return void 0;
+    },
+    getModuleInfo() {
+      return null;
+    },
+    eachModule() {
+      throw new Error(`Not implemented`);
+    },
+    invalidateModule() {
+    },
+    fixStacktrace() {
+    },
+    clientReload() {
+    },
+    webSocketSend() {
+    },
+    isHttps() {
+      return true;
+    },
+    events: new EventEmitter(),
+    ...overrides
+  };
+}
+export {
+  createLoader
+};

node_modules/astro/dist/core/module-loader/vite.d.ts

@@ -0,0 +1,3 @@
+import type * as vite from 'vite';
+import type { ModuleLoader } from './loader.js';
+export declare function createViteLoader(viteServer: vite.ViteDevServer): ModuleLoader;

node_modules/astro/dist/core/module-loader/vite.js

@@ -0,0 +1,99 @@
+import { EventEmitter } from "node:events";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { collectErrorMetadata } from "../errors/dev/utils.js";
+import { getViteErrorPayload } from "../errors/dev/vite.js";
+function createViteLoader(viteServer) {
+  const events = new EventEmitter();
+  let isTsconfigUpdated = false;
+  function isTsconfigUpdate(filePath) {
+    const result = path.basename(filePath) === "tsconfig.json";
+    if (result) isTsconfigUpdated = true;
+    return result;
+  }
+  viteServer.watcher.on("add", (...args) => {
+    if (!isTsconfigUpdate(args[0])) {
+      events.emit("file-add", args);
+    }
+  });
+  viteServer.watcher.on("unlink", (...args) => {
+    if (!isTsconfigUpdate(args[0])) {
+      events.emit("file-unlink", args);
+    }
+  });
+  viteServer.watcher.on("change", (...args) => {
+    if (!isTsconfigUpdate(args[0])) {
+      events.emit("file-change", args);
+    }
+  });
+  const _wsSend = viteServer.hot.send;
+  viteServer.hot.send = function(...args) {
+    if (isTsconfigUpdated) {
+      isTsconfigUpdated = false;
+      return;
+    }
+    const msg = args[0];
+    if (msg?.type === "error") {
+      if (!msg["__isEnhancedAstroErrorPayload"]) {
+        const err = collectErrorMetadata(msg.err, pathToFileURL(viteServer.config.root));
+        getViteErrorPayload(err).then((payload) => {
+          events.emit("hmr-error", {
+            type: "error",
+            err: {
+              message: payload.err.message,
+              stack: payload.err.stack
+            }
+          });
+          args[0] = payload;
+          _wsSend.apply(this, args);
+        });
+        return;
+      }
+      events.emit("hmr-error", msg);
+    }
+    _wsSend.apply(this, args);
+  };
+  return {
+    import(src) {
+      return viteServer.ssrLoadModule(src);
+    },
+    async resolveId(spec, parent) {
+      const ret = await viteServer.pluginContainer.resolveId(spec, parent);
+      return ret?.id;
+    },
+    getModuleById(id) {
+      return viteServer.moduleGraph.getModuleById(id);
+    },
+    getModulesByFile(file) {
+      return viteServer.moduleGraph.getModulesByFile(file);
+    },
+    getModuleInfo(id) {
+      return viteServer.pluginContainer.getModuleInfo(id);
+    },
+    eachModule(cb) {
+      return viteServer.moduleGraph.idToModuleMap.forEach(cb);
+    },
+    invalidateModule(mod) {
+      viteServer.moduleGraph.invalidateModule(mod);
+    },
+    fixStacktrace(err) {
+      return viteServer.ssrFixStacktrace(err);
+    },
+    clientReload() {
+      viteServer.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
+    },
+    webSocketSend(msg) {
+      return viteServer.hot.send(msg);
+    },
+    isHttps() {
+      return !!viteServer.config.server.https;
+    },
+    events
+  };
+}
+export {
+  createViteLoader
+};