feat: scaffold Astro + Tailwind project

node_modules/astro/dist/core/dev/adapter-validation.d.ts

@@ -0,0 +1,5 @@
+import type { AstroSettings } from '../../types/astro.js';
+import type { AstroAdapter } from '../../types/public/integrations.js';
+import type { AstroLogger } from '../logger/core.js';
+export declare function warnMissingAdapter(logger: AstroLogger, settings: AstroSettings): void;
+export declare function validateSetAdapter(logger: AstroLogger, settings: AstroSettings, adapter: AstroAdapter, maybeConflictingIntegration: string, command?: 'dev' | 'build' | string): void;

node_modules/astro/dist/core/dev/adapter-validation.js

@@ -0,0 +1,49 @@
+import { getAdapterStaticRecommendation } from "../../integrations/features-validation.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+let hasWarnedMissingAdapter = false;
+function warnMissingAdapter(logger, settings) {
+  if (hasWarnedMissingAdapter) return;
+  if (settings.buildOutput === "server" && !settings.config.adapter) {
+    logger.warn(
+      "config",
+      "This project contains server-rendered routes, but no adapter is installed. This is fine for development, but an adapter will be required to build your site for production."
+    );
+    hasWarnedMissingAdapter = true;
+  }
+}
+function validateSetAdapter(logger, settings, adapter, maybeConflictingIntegration, command) {
+  if (settings.adapter && settings.adapter.name !== adapter.name) {
+    throw new Error(
+      `Integration "${maybeConflictingIntegration}" conflicts with "${settings.adapter.name}". You can only configure one deployment integration.`
+    );
+  }
+  if (settings.buildOutput === "server" && adapter.adapterFeatures?.buildOutput === "static") {
+    if (command === "build") {
+      const adapterRecommendation = getAdapterStaticRecommendation(adapter.name);
+      throw new AstroError({
+        ...AstroErrorData.AdapterSupportOutputMismatch,
+        message: AstroErrorData.AdapterSupportOutputMismatch.message(adapter.name),
+        hint: adapterRecommendation ? adapterRecommendation : void 0
+      });
+    } else if (command === "dev") {
+      logger.warn(
+        null,
+        `The adapter ${adapter.name} does not support emitting a server output, but the project contain server-rendered pages. Your project will not build correctly.`
+      );
+    }
+  }
+  if (adapter.entrypointResolution === void 0) {
+    logger.warn(
+      null,
+      `The adapter ${adapter.name} uses \`entrypointResolution: "explicit"\` by default, which is deprecated and will be removed in a future major version.`
+    );
+    logger.warn(
+      null,
+      'Update your adapter to use `entrypointResolution: "auto"` or contact the maintainers to update.'
+    );
+  }
+}
+export {
+  validateSetAdapter,
+  warnMissingAdapter
+};

node_modules/astro/dist/core/dev/container.d.ts

@@ -0,0 +1,27 @@
+import nodeFs from 'node:fs';
+import type * as http from 'node:http';
+import type { AddressInfo } from 'node:net';
+import * as vite from 'vite';
+import type { AstroSettings } from '../../types/astro.js';
+import type { AstroInlineConfig } from '../../types/public/config.js';
+import type { AstroLogger } from '../logger/core.js';
+export interface Container {
+    fs: typeof nodeFs;
+    logger: AstroLogger;
+    settings: AstroSettings;
+    viteServer: vite.ViteDevServer;
+    inlineConfig: AstroInlineConfig;
+    restartInFlight: boolean;
+    handle: (req: http.IncomingMessage, res: http.ServerResponse) => void;
+    close: () => Promise<void>;
+}
+interface CreateContainerParams {
+    logger: AstroLogger;
+    settings: AstroSettings;
+    inlineConfig?: AstroInlineConfig;
+    isRestart?: boolean;
+    fs?: typeof nodeFs;
+}
+export declare function createContainer({ isRestart, logger, inlineConfig, settings, fs, }: CreateContainerParams): Promise<Container>;
+export declare function startContainer({ settings, viteServer, logger, }: Container): Promise<AddressInfo>;
+export {};

node_modules/astro/dist/core/dev/container.js

@@ -0,0 +1,122 @@
+import nodeFs from "node:fs";
+import * as vite from "vite";
+import {
+  runHookConfigDone,
+  runHookConfigSetup,
+  runHookServerDone,
+  runHookServerStart
+} from "../../integrations/hooks.js";
+import { createVite } from "../create-vite.js";
+import { createRoutesList } from "../routing/create-manifest.js";
+import { getPrerenderDefault } from "../../prerender/utils.js";
+import { syncInternal } from "../sync/index.js";
+import { warnMissingAdapter } from "./adapter-validation.js";
+async function createContainer({
+  isRestart = false,
+  logger,
+  inlineConfig,
+  settings,
+  fs = nodeFs
+}) {
+  settings = await runHookConfigSetup({
+    settings,
+    command: "dev",
+    logger,
+    isRestart
+  });
+  const {
+    base,
+    server: { host, headers, open: serverOpen, allowedHosts, port }
+  } = settings.config;
+  const isServerOpenURL = typeof serverOpen === "string" && !isRestart;
+  const isServerOpenBoolean = serverOpen && !isRestart;
+  const open = isServerOpenURL ? serverOpen : isServerOpenBoolean ? base : false;
+  const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
+  if (!settings.adapter?.adapterFeatures?.buildOutput) {
+    settings.buildOutput = getPrerenderDefault(settings.config) ? "static" : "server";
+  }
+  await runHookConfigDone({ settings, logger, command: "dev" });
+  warnMissingAdapter(logger, settings);
+  const mode = inlineConfig?.mode ?? "development";
+  const initialRoutesList = await createRoutesList(
+    {
+      settings,
+      fsMod: nodeFs
+    },
+    logger,
+    {
+      dev: true
+    }
+  );
+  const viteConfig = await createVite(
+    {
+      server: { host, headers, open, allowedHosts, port },
+      optimizeDeps: {
+        include: rendererClientEntries
+      }
+    },
+    {
+      settings,
+      logger,
+      mode,
+      command: "dev",
+      fs,
+      sync: false,
+      routesList: initialRoutesList
+    }
+  );
+  const viteServer = await vite.createServer(viteConfig);
+  await syncInternal({
+    settings,
+    mode,
+    logger,
+    skip: {
+      content: !isRestart,
+      cleanup: true
+    },
+    force: inlineConfig?.force,
+    command: "dev",
+    watcher: viteServer.watcher
+  });
+  const container = {
+    inlineConfig: inlineConfig ?? {},
+    fs,
+    logger,
+    restartInFlight: false,
+    settings,
+    viteServer,
+    handle(req, res) {
+      viteServer.middlewares.handle(req, res, Function.prototype);
+    },
+    close() {
+      return closeContainer(container);
+    }
+  };
+  return container;
+}
+async function closeContainer({ viteServer, settings, logger }) {
+  await viteServer.close();
+  await runHookServerDone({
+    config: settings.config,
+    logger
+  });
+}
+async function startContainer({
+  settings,
+  viteServer,
+  logger
+}) {
+  const { port } = settings.config.server;
+  await viteServer.listen(port);
+  const devServerAddressInfo = viteServer.httpServer.address();
+  await runHookServerStart({
+    config: settings.config,
+    address: devServerAddressInfo,
+    logger
+  });
+  return devServerAddressInfo;
+}
+export {
+  createContainer,
+  startContainer
+};

node_modules/astro/dist/core/dev/dev.d.ts

@@ -0,0 +1,17 @@
+import type http from 'node:http';
+import type { AddressInfo } from 'node:net';
+import type * as vite from 'vite';
+import type { AstroInlineConfig } from '../../types/public/config.js';
+export interface DevServer {
+    address: AddressInfo;
+    handle: (req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>) => void;
+    watcher: vite.FSWatcher;
+    stop(): Promise<void>;
+}
+/**
+ * Runs Astro’s development server. This is a local HTTP server that doesn’t bundle assets.
+ * It uses Hot Module Replacement (HMR) to update your browser as you save changes in your editor.
+ *
+ * @experimental The JavaScript API is experimental
+ */
+export default function dev(inlineConfig: AstroInlineConfig): Promise<DevServer>;

node_modules/astro/dist/core/dev/dev.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import { performance } from "node:perf_hooks";
+import colors from "piccolore";
+import { gt, major, minor, patch } from "semver";
+import { getDataStoreFile } from "../../content/content-layer.js";
+import { globalContentLayer } from "../../content/instance.js";
+import { attachContentServerListeners } from "../../content/index.js";
+import { MutableDataStore } from "../../content/mutable-data-store.js";
+import { globalContentConfigObserver } from "../../content/utils.js";
+import { telemetry } from "../../events/index.js";
+import * as msg from "../messages/runtime.js";
+import { newVersionAvailable } from "../messages/node.js";
+import { ensureProcessNodeEnv } from "../util.js";
+import { startContainer } from "./container.js";
+import { createContainerWithAutomaticRestart } from "./restart.js";
+import {
+  fetchLatestAstroVersion,
+  MAX_PATCH_DISTANCE,
+  shouldCheckForUpdates
+} from "./update-check.js";
+import { BuildTimeAstroVersionProvider } from "../../cli/infra/build-time-astro-version-provider.js";
+import { piccoloreTextStyler } from "../../cli/infra/piccolore-text-styler.js";
+function warnIfVite8({ root, logger }) {
+  try {
+    const require2 = createRequire(root);
+    const { version } = require2("vite/package.json");
+    if (major(version) >= 8) {
+      logger.warn("SKIP_FORMAT", msg.vite8Warning({ viteVersion: version }));
+    }
+  } catch {
+  }
+}
+async function dev(inlineConfig) {
+  ensureProcessNodeEnv("development");
+  const devStart = performance.now();
+  await telemetry.record([]);
+  const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
+  const logger = restart.container.logger;
+  const currentVersion = "6.3.1";
+  const isPrerelease = currentVersion.includes("-");
+  if (!isPrerelease) {
+    try {
+      shouldCheckForUpdates(restart.container.settings.preferences).then(async (shouldCheck) => {
+        if (shouldCheck) {
+          const version = await fetchLatestAstroVersion(restart.container.settings.preferences);
+          if (gt(version, currentVersion)) {
+            restart.container.settings.latestAstroVersion = version;
+            const sameMajor = major(version) === major(currentVersion);
+            const sameMinor = minor(version) === minor(currentVersion);
+            const patchDistance = patch(version) - patch(currentVersion);
+            if (sameMajor && sameMinor && patchDistance < MAX_PATCH_DISTANCE) {
+              return;
+            }
+            logger.warn(
+              "SKIP_FORMAT",
+              await newVersionAvailable({
+                latestVersion: version
+              })
+            );
+          }
+        }
+      }).catch(() => {
+      });
+    } catch {
+    }
+  }
+  let store;
+  try {
+    const dataStoreFile = getDataStoreFile(restart.container.settings, true);
+    store = await MutableDataStore.fromFile(dataStoreFile);
+  } catch (err) {
+    logger.error("content", err.message);
+  }
+  if (!store) {
+    logger.error("content", "Failed to create data store");
+  }
+  await attachContentServerListeners(restart.container);
+  const config = globalContentConfigObserver.get();
+  if (config.status === "error") {
+    logger.error("content", config.error.message);
+  }
+  if (config.status === "loaded" && store) {
+    const contentLayer = globalContentLayer.init({
+      settings: restart.container.settings,
+      logger,
+      watcher: restart.container.viteServer.watcher,
+      store
+    });
+    contentLayer.watchContentConfig();
+    await contentLayer.sync();
+  } else if (config.status !== "does-not-exist") {
+    logger.warn("content", "Content config not loaded");
+  }
+  const devServerAddressInfo = await startContainer(restart.container);
+  restart.bindCLIShortcuts();
+  logger.info(
+    "SKIP_FORMAT",
+    msg.serverStart({
+      startupTime: performance.now() - devStart,
+      resolvedUrls: restart.container.viteServer.resolvedUrls || { local: [], network: [] },
+      host: restart.container.settings.config.server.host,
+      base: restart.container.settings.config.base,
+      astroVersionProvider: new BuildTimeAstroVersionProvider(),
+      textStyler: piccoloreTextStyler
+    })
+  );
+  if (isPrerelease) {
+    logger.warn("SKIP_FORMAT", msg.prerelease({ currentVersion }));
+  }
+  if (restart.container.viteServer.config.server?.fs?.strict === false) {
+    logger.warn("SKIP_FORMAT", msg.fsStrictWarning());
+  }
+  setImmediate(() => warnIfVite8({ root: restart.container.settings.config.root, logger }));
+  logger.info(null, colors.green("watching for file changes..."));
+  return {
+    address: devServerAddressInfo,
+    get watcher() {
+      return restart.container.viteServer.watcher;
+    },
+    handle(req, res) {
+      return restart.container.handle(req, res);
+    },
+    async stop() {
+      await restart.container.close();
+    }
+  };
+}
+export {
+  dev as default
+};

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

@@ -0,0 +1,3 @@
+export { startContainer } from './container.js';
+export { default } from './dev.js';
+export { createContainerWithAutomaticRestart } from './restart.js';

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

@@ -0,0 +1,8 @@
+import { startContainer } from "./container.js";
+import { default as default2 } from "./dev.js";
+import { createContainerWithAutomaticRestart } from "./restart.js";
+export {
+  createContainerWithAutomaticRestart,
+  default2 as default,
+  startContainer
+};

node_modules/astro/dist/core/dev/restart.d.ts

@@ -0,0 +1,14 @@
+import type nodeFs from 'node:fs';
+import type { AstroInlineConfig } from '../../types/public/config.js';
+import type { Container } from './container.js';
+interface CreateContainerWithAutomaticRestart {
+    inlineConfig?: AstroInlineConfig;
+    fs?: typeof nodeFs;
+}
+interface Restart {
+    container: Container;
+    bindCLIShortcuts: () => void;
+    restarted: () => Promise<Error | null>;
+}
+export declare function createContainerWithAutomaticRestart({ inlineConfig, fs, }: CreateContainerWithAutomaticRestart): Promise<Restart>;
+export {};

node_modules/astro/dist/core/dev/restart.js

@@ -0,0 +1,180 @@
+import { fileURLToPath } from "node:url";
+import * as vite from "vite";
+import { globalContentLayer } from "../../content/instance.js";
+import { attachContentServerListeners } from "../../content/server-listeners.js";
+import { eventCliSession, telemetry } from "../../events/index.js";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
+import { SETTINGS_FILE } from "../../preferences/constants.js";
+import { getPrerenderDefault } from "../../prerender/utils.js";
+import { createSettings, resolveConfig } from "../config/index.js";
+import { clearCrawlCache, createVite } from "../create-vite.js";
+import { collectErrorMetadata } from "../errors/dev/utils.js";
+import { isAstroConfigZodError } from "../errors/errors.js";
+import { createSafeError } from "../errors/index.js";
+import { loadOrCreateNodeLogger } from "../logger/load.js";
+import { formatErrorMessage, warnIfCspWithShiki } from "../messages/runtime.js";
+import { createRoutesList } from "../routing/create-manifest.js";
+import { createContainer } from "./container.js";
+const configRE = /.*astro.config.(?:mjs|mts|cjs|cts|js|ts)$/;
+function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, changedFile) {
+  if (restartInFlight) return false;
+  let shouldRestart = false;
+  const normalizedChangedFile = vite.normalizePath(changedFile);
+  if (inlineConfig.configFile) {
+    shouldRestart = vite.normalizePath(inlineConfig.configFile) === normalizedChangedFile;
+  } else {
+    shouldRestart = configRE.test(normalizedChangedFile);
+    const settingsPath = vite.normalizePath(
+      fileURLToPath(new URL(SETTINGS_FILE, settings.dotAstroDir))
+    );
+    if (settingsPath.endsWith(normalizedChangedFile)) {
+      shouldRestart = settings.preferences.ignoreNextPreferenceReload ? false : true;
+      settings.preferences.ignoreNextPreferenceReload = false;
+    }
+  }
+  if (!shouldRestart && settings.watchFiles.length > 0) {
+    shouldRestart = settings.watchFiles.some(
+      (path) => vite.normalizePath(path) === vite.normalizePath(changedFile)
+    );
+  }
+  return shouldRestart;
+}
+async function restartContainerInPlace(container) {
+  const { logger, settings: existingSettings, inlineConfig, fs } = container;
+  container.restartInFlight = true;
+  clearCrawlCache();
+  try {
+    const { astroConfig } = await resolveConfig(inlineConfig, "dev", fs);
+    warnIfCspWithShiki(astroConfig, logger);
+    let settings = await createSettings(
+      astroConfig,
+      inlineConfig.logLevel,
+      fileURLToPath(existingSettings.config.root)
+    );
+    settings = await runHookConfigSetup({ settings, command: "dev", logger, isRestart: true });
+    if (!settings.adapter?.adapterFeatures?.buildOutput) {
+      settings.buildOutput = getPrerenderDefault(settings.config) ? "static" : "server";
+    }
+    await runHookConfigDone({ settings, logger, command: "dev" });
+    const mode = inlineConfig?.mode ?? "development";
+    const {
+      server: { host, headers, allowedHosts }
+    } = settings.config;
+    const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
+    const routesList = await createRoutesList({ settings, fsMod: fs }, logger, { dev: true });
+    const address = container.viteServer.httpServer?.address();
+    const port = address !== null && typeof address === "object" ? address.port : void 0;
+    const newViteConfig = await createVite(
+      {
+        server: { host, headers, allowedHosts, port },
+        optimizeDeps: { include: rendererClientEntries }
+      },
+      { settings, logger, mode, command: "dev", fs, sync: false, routesList }
+    );
+    container.viteServer.config = await vite.resolveConfig(newViteConfig, "serve");
+    await container.viteServer.restart();
+    container.settings = settings;
+    return settings;
+  } catch (_err) {
+    const error = createSafeError(_err);
+    if (!isAstroConfigZodError(_err)) {
+      logger.error(
+        "config",
+        formatErrorMessage(collectErrorMetadata(error), logger.level() === "debug") + "\n"
+      );
+    }
+    container.viteServer.environments?.client?.hot?.send({
+      type: "error",
+      err: { message: error.message, stack: error.stack || "" }
+    });
+    logger.error(null, "Continuing with previous valid configuration\n");
+    return error;
+  } finally {
+    container.restartInFlight = false;
+  }
+}
+async function createContainerWithAutomaticRestart({
+  inlineConfig,
+  fs
+}) {
+  const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "dev", fs);
+  const logger = await loadOrCreateNodeLogger(astroConfig, inlineConfig ?? {});
+  warnIfCspWithShiki(astroConfig, logger);
+  telemetry.record(eventCliSession("dev", userConfig));
+  const settings = await createSettings(
+    astroConfig,
+    inlineConfig?.logLevel,
+    fileURLToPath(astroConfig.root)
+  );
+  const initialContainer = await createContainer({
+    settings,
+    logger,
+    inlineConfig,
+    fs
+  });
+  let resolveRestart;
+  let restartComplete = new Promise((resolve) => {
+    resolveRestart = resolve;
+  });
+  let restart = {
+    container: initialContainer,
+    bindCLIShortcuts() {
+      const customShortcuts = [
+        { key: "r", description: "" },
+        { key: "u", description: "" },
+        { key: "c", description: "" }
+      ];
+      customShortcuts.push({
+        key: "s",
+        description: "sync content layer",
+        action: () => {
+          globalContentLayer.get()?.sync();
+        }
+      });
+      restart.container.viteServer.bindCLIShortcuts({
+        customShortcuts
+      });
+    },
+    restarted() {
+      return restartComplete;
+    }
+  };
+  function handleChangeRestart(logMsg) {
+    return async function(changedFile) {
+      if (shouldRestartContainer(restart.container, changedFile)) {
+        logger.info(null, (logMsg + " Restarting...").trim());
+        const result = await restartContainerInPlace(restart.container);
+        if (result instanceof Error) {
+          resolveRestart(result);
+        } else {
+          setupContainer();
+          await attachContentServerListeners(restart.container);
+          resolveRestart(null);
+        }
+        restartComplete = new Promise((resolve) => {
+          resolveRestart = resolve;
+        });
+      }
+    };
+  }
+  let changeHandler;
+  let unlinkHandler;
+  let addHandler;
+  function setupContainer() {
+    const watcher = restart.container.viteServer.watcher;
+    if (changeHandler) watcher.off("change", changeHandler);
+    if (unlinkHandler) watcher.off("unlink", unlinkHandler);
+    if (addHandler) watcher.off("add", addHandler);
+    changeHandler = handleChangeRestart("Configuration file updated.");
+    unlinkHandler = handleChangeRestart("Configuration file removed.");
+    addHandler = handleChangeRestart("Configuration file added.");
+    watcher.on("change", changeHandler);
+    watcher.on("unlink", unlinkHandler);
+    watcher.on("add", addHandler);
+  }
+  setupContainer();
+  return restart;
+}
+export {
+  createContainerWithAutomaticRestart
+};

node_modules/astro/dist/core/dev/update-check.d.ts

@@ -0,0 +1,4 @@
+import type { AstroPreferences } from '../../preferences/index.js';
+export declare const MAX_PATCH_DISTANCE = 5;
+export declare function fetchLatestAstroVersion(preferences: AstroPreferences | undefined): Promise<string>;
+export declare function shouldCheckForUpdates(preferences: AstroPreferences): Promise<boolean>;

node_modules/astro/dist/core/dev/update-check.js

@@ -0,0 +1,36 @@
+import ci from "ci-info";
+import { fetchPackageJson } from "../../cli/install-package.js";
+const MAX_PATCH_DISTANCE = 5;
+const CHECK_MS_INTERVAL = 10368e5;
+let _latestVersion = void 0;
+async function fetchLatestAstroVersion(preferences) {
+  if (_latestVersion) {
+    return _latestVersion;
+  }
+  const packageJson = await fetchPackageJson(void 0, "astro", "latest");
+  if (packageJson instanceof Error) {
+    throw packageJson;
+  }
+  const version = packageJson?.version;
+  if (!version) {
+    throw new Error("Failed to fetch latest Astro version");
+  }
+  if (preferences) {
+    await preferences.set("_variables.lastUpdateCheck", Date.now(), { reloadServer: false });
+  }
+  _latestVersion = version;
+  return version;
+}
+async function shouldCheckForUpdates(preferences) {
+  if (ci.isCI) {
+    return false;
+  }
+  const timeSinceLastCheck = Date.now() - await preferences.get("_variables.lastUpdateCheck");
+  const hasCheckUpdatesEnabled = await preferences.get("checkUpdates.enabled");
+  return timeSinceLastCheck > CHECK_MS_INTERVAL && process.env.ASTRO_DISABLE_UPDATE_CHECK !== "true" && hasCheckUpdatesEnabled;
+}
+export {
+  MAX_PATCH_DISTANCE,
+  fetchLatestAstroVersion,
+  shouldCheckForUpdates
+};