blank project

node_modules/astro/dist/core/server-islands/endpoint.d.ts

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

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

@@ -0,0 +1,130 @@
+import {
+  renderComponent,
+  renderTemplate
+} from "../../runtime/server/index.js";
+import { isAstroComponentFactory } from "../../runtime/server/render/astro/factory.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";
+const SERVER_ISLAND_BASE_PREFIX = "_server-islands";
+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,
+    origin: "internal"
+  };
+  return route;
+}
+function injectServerIslandRoute(config, routeManifest) {
+  routeManifest.routes.unshift(getServerIslandRouteData(config));
+}
+function badRequest(reason) {
+  return new Response(null, {
+    status: 400,
+    statusText: "Bad request: " + reason
+  });
+}
+async function getRequestData(request) {
+  switch (request.method) {
+    case "GET": {
+      const url = new URL(request.url);
+      const params = url.searchParams;
+      if (!params.has("s") || !params.has("e") || !params.has("p")) {
+        return badRequest("Missing required query parameters.");
+      }
+      const rawSlots = params.get("s");
+      try {
+        return {
+          componentExport: params.get("e"),
+          encryptedProps: params.get("p"),
+          slots: JSON.parse(rawSlots)
+        };
+      } catch {
+        return badRequest("Invalid slots format.");
+      }
+    }
+    case "POST": {
+      try {
+        const raw = await request.text();
+        const data = JSON.parse(raw);
+        return data;
+      } catch {
+        return badRequest("Request format is invalid.");
+      }
+    }
+    default: {
+      return new Response(null, { status: 405 });
+    }
+  }
+}
+function createEndpoint(manifest) {
+  const page = async (result) => {
+    const params = result.params;
+    if (!params.name) {
+      return new Response(null, {
+        status: 400,
+        statusText: "Bad request"
+      });
+    }
+    const componentId = params.name;
+    const data = await getRequestData(result.request);
+    if (data instanceof Response) {
+      return data;
+    }
+    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 = encryptedProps === "" ? "{}" : await decryptString(key, encryptedProps);
+    const props = JSON.parse(propString);
+    const componentModule = await imp();
+    let Component = componentModule[data.componentExport];
+    const slots = {};
+    for (const prop in data.slots) {
+      slots[prop] = createSlotValueFromString(data.slots[prop]);
+    }
+    result.response.headers.set("X-Robots-Tag", "noindex");
+    if (isAstroComponentFactory(Component)) {
+      const ServerIsland = Component;
+      Component = function(...args) {
+        return ServerIsland.apply(this, args);
+      };
+      Object.assign(Component, ServerIsland);
+      Component.propagation = "self";
+    }
+    return renderTemplate`${renderComponent(result, "Component", Component, props, slots)}`;
+  };
+  page.isAstroComponentFactory = true;
+  const instance = {
+    default: page,
+    partial: true
+  };
+  return instance;
+}
+export {
+  SERVER_ISLAND_BASE_PREFIX,
+  SERVER_ISLAND_COMPONENT,
+  SERVER_ISLAND_ROUTE,
+  createEndpoint,
+  getServerIslandRouteData,
+  injectServerIslandRoute
+};

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

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

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

@@ -0,0 +1,92 @@
+import MagicString from "magic-string";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+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 { code: `export const serverIslandMap = ${serverIslandPlaceholder};` };
+      }
+    },
+    transform(_code, id) {
+      const info = this.getModuleInfo(id);
+      if (!info?.meta?.astro) return;
+      const astro = info.meta.astro;
+      for (const comp of astro.serverComponents) {
+        if (!settings.serverIslandNameMap.has(comp.resolvedPath)) {
+          if (!settings.adapter) {
+            throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
+          }
+          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)) {
+        if (referenceIdMap.size === 0) {
+          return {
+            code: code.replace(serverIslandPlaceholder, "new Map();"),
+            map: null
+          };
+        }
+        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();
+        const ms = new MagicString(code);
+        ms.replace(serverIslandPlaceholder, mapSource);
+        return {
+          code: ms.toString(),
+          map: ms.generateMap({ hires: "boundary" })
+        };
+      }
+    }
+  };
+}
+export {
+  VIRTUAL_ISLAND_MAP_ID,
+  vitePluginServerIslands
+};