🎉 initiate project *astro_rewrite*

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

@@ -0,0 +1,10 @@
+import type { Arguments } from 'yargs-parser';
+import type { AstroSettings, PreviewServer } from '../../@types/astro';
+import type { LogOptions } from '../logger/core';
+interface PreviewOptions {
+    logging: LogOptions;
+    flags?: Arguments;
+}
+/** The primary dev action */
+export default function preview(_settings: AstroSettings, { logging, flags }: PreviewOptions): Promise<PreviewServer | undefined>;
+export {};

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

@@ -0,0 +1,63 @@
+import { cyan } from "kleur/colors";
+import { createRequire } from "module";
+import { pathToFileURL } from "node:url";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/index.js";
+import { printHelp } from "../messages.js";
+import createStaticPreviewServer from "./static-preview-server.js";
+import { getResolvedHostForHttpServer } from "./util.js";
+async function preview(_settings, { logging, flags }) {
+  if ((flags == null ? void 0 : flags.help) || (flags == null ? void 0 : flags.h)) {
+    printHelp({
+      commandName: "astro preview",
+      usage: "[...flags]",
+      tables: {
+        Flags: [
+          ["--open", "Automatically open the app in the browser on server start"],
+          ["--help (-h)", "See all available flags."]
+        ]
+      },
+      description: `Starts a local server to serve your static dist/ directory. Check ${cyan(
+        "https://docs.astro.build/en/reference/cli-reference/#astro-preview"
+      )} for more information.`
+    });
+    return;
+  }
+  const settings = await runHookConfigSetup({
+    settings: _settings,
+    command: "preview",
+    logging
+  });
+  await runHookConfigDone({ settings, logging });
+  if (settings.config.output === "static") {
+    const server2 = await createStaticPreviewServer(settings, logging);
+    return server2;
+  }
+  if (!settings.adapter) {
+    throw new Error(`[preview] No adapter found.`);
+  }
+  if (!settings.adapter.previewEntrypoint) {
+    throw new Error(
+      `[preview] The ${settings.adapter.name} adapter does not support the preview command.`
+    );
+  }
+  const require2 = createRequire(settings.config.root);
+  const previewEntrypointUrl = pathToFileURL(
+    require2.resolve(settings.adapter.previewEntrypoint)
+  ).href;
+  const previewModule = await import(previewEntrypointUrl);
+  if (typeof previewModule.default !== "function") {
+    throw new Error(`[preview] ${settings.adapter.name} cannot preview your app.`);
+  }
+  const server = await previewModule.default({
+    outDir: settings.config.outDir,
+    client: settings.config.build.client,
+    serverEntrypoint: new URL(settings.config.build.serverEntry, settings.config.build.server),
+    host: getResolvedHostForHttpServer(settings.config.server.host),
+    port: settings.config.server.port,
+    base: settings.config.base
+  });
+  return server;
+}
+export {
+  preview as default
+};

node_modules/astro/dist/core/preview/static-preview-server.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import type http from 'node:http';
+import type { AstroSettings } from '../../@types/astro';
+import type { LogOptions } from '../logger/core';
+export interface PreviewServer {
+    host?: string;
+    port: number;
+    server: http.Server;
+    closed(): Promise<void>;
+    stop(): Promise<void>;
+}
+export default function createStaticPreviewServer(settings: AstroSettings, logging: LogOptions): Promise<PreviewServer>;

node_modules/astro/dist/core/preview/static-preview-server.js

@@ -0,0 +1,65 @@
+import { fileURLToPath } from "node:url";
+import { performance } from "perf_hooks";
+import enableDestroy from "server-destroy";
+import { preview } from "vite";
+import { error, info } from "../logger/core.js";
+import * as msg from "../messages.js";
+import { getResolvedHostForHttpServer } from "./util.js";
+import { vitePluginAstroPreview } from "./vite-plugin-astro-preview.js";
+async function createStaticPreviewServer(settings, logging) {
+  const startServerTime = performance.now();
+  let previewServer;
+  try {
+    previewServer = await preview({
+      configFile: false,
+      base: settings.config.base,
+      appType: "mpa",
+      build: {
+        outDir: fileURLToPath(settings.config.outDir)
+      },
+      preview: {
+        host: settings.config.server.host,
+        port: settings.config.server.port,
+        headers: settings.config.server.headers,
+        open: settings.config.server.open
+      },
+      plugins: [vitePluginAstroPreview(settings)]
+    });
+  } catch (err) {
+    if (err instanceof Error) {
+      error(logging, "astro", err.stack || err.message);
+    }
+    throw err;
+  }
+  enableDestroy(previewServer.httpServer);
+  info(
+    logging,
+    null,
+    msg.serverStart({
+      startupTime: performance.now() - startServerTime,
+      resolvedUrls: previewServer.resolvedUrls,
+      host: settings.config.server.host,
+      base: settings.config.base
+    })
+  );
+  function closed() {
+    return new Promise((resolve, reject) => {
+      previewServer.httpServer.addListener("close", resolve);
+      previewServer.httpServer.addListener("error", reject);
+    });
+  }
+  return {
+    host: getResolvedHostForHttpServer(settings.config.server.host),
+    port: settings.config.server.port,
+    closed,
+    server: previewServer.httpServer,
+    stop: async () => {
+      await new Promise((resolve, reject) => {
+        previewServer.httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
+      });
+    }
+  };
+}
+export {
+  createStaticPreviewServer as default
+};

node_modules/astro/dist/core/preview/util.d.ts

@@ -0,0 +1,2 @@
+export declare function getResolvedHostForHttpServer(host: string | boolean): string | undefined;
+export declare function stripBase(path: string, base: string): string;

node_modules/astro/dist/core/preview/util.js

@@ -0,0 +1,20 @@
+function getResolvedHostForHttpServer(host) {
+  if (host === false) {
+    return "localhost";
+  } else if (host === true) {
+    return void 0;
+  } else {
+    return host;
+  }
+}
+function stripBase(path, base) {
+  if (path === base) {
+    return "/";
+  }
+  const baseWithSlash = base.endsWith("/") ? base : base + "/";
+  return path.replace(RegExp("^" + baseWithSlash), "/");
+}
+export {
+  getResolvedHostForHttpServer,
+  stripBase
+};

node_modules/astro/dist/core/preview/vite-plugin-astro-preview.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+import type { AstroSettings } from '../../@types/astro.js';
+export declare function vitePluginAstroPreview(settings: AstroSettings): Plugin;

node_modules/astro/dist/core/preview/vite-plugin-astro-preview.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { notFoundTemplate, subpathNotUsedTemplate } from "../../template/4xx.js";
+import { stripBase } from "./util.js";
+const HAS_FILE_EXTENSION_REGEXP = /^.*\.[^\\]+$/;
+function vitePluginAstroPreview(settings) {
+  const { base, outDir, trailingSlash } = settings.config;
+  return {
+    name: "astro:preview",
+    apply: "serve",
+    configurePreviewServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (!req.url.startsWith(base)) {
+          res.statusCode = 404;
+          res.end(subpathNotUsedTemplate(base, req.url));
+          return;
+        }
+        const pathname = stripBase(req.url, base);
+        const isRoot = pathname === "/";
+        if (!isRoot) {
+          const hasTrailingSlash = pathname.endsWith("/");
+          if (hasTrailingSlash && trailingSlash == "never") {
+            res.statusCode = 404;
+            res.end(notFoundTemplate(pathname, 'Not Found (trailingSlash is set to "never")'));
+            return;
+          }
+          if (!hasTrailingSlash && trailingSlash == "always" && !HAS_FILE_EXTENSION_REGEXP.test(pathname)) {
+            res.statusCode = 404;
+            res.end(notFoundTemplate(pathname, 'Not Found (trailingSlash is set to "always")'));
+            return;
+          }
+        }
+        next();
+      });
+      return () => {
+        server.middlewares.use((req, res) => {
+          const errorPagePath = fileURLToPath(outDir + "/404.html");
+          if (fs.existsSync(errorPagePath)) {
+            res.statusCode = 404;
+            res.setHeader("Content-Type", "text/html;charset=utf-8");
+            res.end(fs.readFileSync(errorPagePath));
+          } else {
+            const pathname = stripBase(req.url, base);
+            res.statusCode = 404;
+            res.end(notFoundTemplate(pathname, "Not Found"));
+          }
+        });
+      };
+    }
+  };
+}
+export {
+  vitePluginAstroPreview
+};