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/server-islands/endpoint.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentInstance, ManifestData, RouteData, SSRManifest } from '../../@types/astro.js';
+export declare const SERVER_ISLAND_ROUTE = "/_server-islands/[name]";
+export declare const SERVER_ISLAND_COMPONENT = "_server-islands.astro";
+type ConfigFields = Pick<SSRManifest, 'base' | 'trailingSlash'>;
+export declare function getServerIslandRouteData(config: ConfigFields): RouteData;
+export declare function ensureServerIslandRoute(config: ConfigFields, routeManifest: ManifestData): void;
+export declare function createEndpoint(manifest: SSRManifest): ComponentInstance;
+export {};

node_modules/astro/dist/core/server-islands/endpoint.js

@@ -0,0 +1,80 @@
+import {
+  renderComponent,
+  renderTemplate
+} from "../../runtime/server/index.js";
+import { createSlotValueFromString } from "../../runtime/server/render/slot.js";
+import { decryptString } from "../encryption.js";
+import { getPattern } from "../routing/manifest/pattern.js";
+const SERVER_ISLAND_ROUTE = "/_server-islands/[name]";
+const SERVER_ISLAND_COMPONENT = "_server-islands.astro";
+function getServerIslandRouteData(config) {
+  const segments = [
+    [{ content: "_server-islands", dynamic: false, spread: false }],
+    [{ content: "name", dynamic: true, spread: false }]
+  ];
+  const route = {
+    type: "page",
+    component: SERVER_ISLAND_COMPONENT,
+    generate: () => "",
+    params: ["name"],
+    segments,
+    pattern: getPattern(segments, config.base, config.trailingSlash),
+    prerender: false,
+    isIndex: false,
+    fallbackRoutes: [],
+    route: SERVER_ISLAND_ROUTE
+  };
+  return route;
+}
+function ensureServerIslandRoute(config, routeManifest) {
+  if (routeManifest.routes.some((route) => route.route === "/_server-islands/[name]")) {
+    return;
+  }
+  routeManifest.routes.unshift(getServerIslandRouteData(config));
+}
+function createEndpoint(manifest) {
+  const page = async (result) => {
+    const params = result.params;
+    const request = result.request;
+    const raw = await request.text();
+    const data = JSON.parse(raw);
+    if (!params.name) {
+      return new Response(null, {
+        status: 400,
+        statusText: "Bad request"
+      });
+    }
+    const componentId = params.name;
+    const imp = manifest.serverIslandMap?.get(componentId);
+    if (!imp) {
+      return new Response(null, {
+        status: 404,
+        statusText: "Not found"
+      });
+    }
+    const key = await manifest.key;
+    const encryptedProps = data.encryptedProps;
+    const propString = await decryptString(key, encryptedProps);
+    const props = JSON.parse(propString);
+    const componentModule = await imp();
+    const Component = componentModule[data.componentExport];
+    const slots = {};
+    for (const prop in data.slots) {
+      slots[prop] = createSlotValueFromString(data.slots[prop]);
+    }
+    return renderTemplate`${renderComponent(result, "Component", Component, props, slots)}`;
+  };
+  page.isAstroComponentFactory = true;
+  const instance = {
+    default: page,
+    partial: true
+  };
+  return instance;
+}
+export {
+  SERVER_ISLAND_COMPONENT,
+  SERVER_ISLAND_ROUTE,
+  createEndpoint,
+  ensureServerIslandRoute,
+  getServerIslandRouteData
+};

node_modules/astro/dist/core/server-islands/vite-plugin-server-islands.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../@types/astro.js';
+export declare const VIRTUAL_ISLAND_MAP_ID = "@astro-server-islands";
+export declare const RESOLVED_VIRTUAL_ISLAND_MAP_ID: string;
+export declare function vitePluginServerIslands({ settings }: {
+    settings: AstroSettings;
+}): VitePlugin;

node_modules/astro/dist/core/server-islands/vite-plugin-server-islands.js

@@ -0,0 +1,82 @@
+const VIRTUAL_ISLAND_MAP_ID = "@astro-server-islands";
+const RESOLVED_VIRTUAL_ISLAND_MAP_ID = "\0" + VIRTUAL_ISLAND_MAP_ID;
+const serverIslandPlaceholder = "'$$server-islands$$'";
+function vitePluginServerIslands({ settings }) {
+  let command = "serve";
+  let viteServer = null;
+  const referenceIdMap = /* @__PURE__ */ new Map();
+  return {
+    name: "astro:server-islands",
+    enforce: "post",
+    config(_config, { command: _command }) {
+      command = _command;
+    },
+    configureServer(_server) {
+      viteServer = _server;
+    },
+    resolveId(name) {
+      if (name === VIRTUAL_ISLAND_MAP_ID) {
+        return RESOLVED_VIRTUAL_ISLAND_MAP_ID;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_ISLAND_MAP_ID) {
+        return `export const serverIslandMap = ${serverIslandPlaceholder};`;
+      }
+    },
+    transform(_code, id) {
+      if (id.endsWith(".astro")) {
+        const info = this.getModuleInfo(id);
+        if (info?.meta) {
+          const astro = info.meta.astro;
+          if (astro?.serverComponents.length) {
+            for (const comp of astro.serverComponents) {
+              if (!settings.serverIslandNameMap.has(comp.resolvedPath)) {
+                let name = comp.localName;
+                let idx = 1;
+                while (true) {
+                  if (!settings.serverIslandMap.has(name)) {
+                    break;
+                  }
+                  name += idx++;
+                }
+                settings.serverIslandNameMap.set(comp.resolvedPath, name);
+                settings.serverIslandMap.set(name, () => {
+                  return viteServer?.ssrLoadModule(comp.resolvedPath);
+                });
+                if (command === "build") {
+                  let referenceId = this.emitFile({
+                    type: "chunk",
+                    id: comp.specifier,
+                    importer: id,
+                    name: comp.localName
+                  });
+                  referenceIdMap.set(comp.resolvedPath, referenceId);
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    renderChunk(code) {
+      if (code.includes(serverIslandPlaceholder)) {
+        let mapSource = "new Map([";
+        for (let [resolvedPath, referenceId] of referenceIdMap) {
+          const fileName = this.getFileName(referenceId);
+          const islandName = settings.serverIslandNameMap.get(resolvedPath);
+          mapSource += `
+	['${islandName}', () => import('./${fileName}')],`;
+        }
+        mapSource += "\n]);";
+        referenceIdMap.clear();
+        return code.replace(serverIslandPlaceholder, mapSource);
+      }
+    }
+  };
+}
+export {
+  RESOLVED_VIRTUAL_ISLAND_MAP_ID,
+  VIRTUAL_ISLAND_MAP_ID,
+  vitePluginServerIslands
+};