feat: scaffold Astro + Tailwind project

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

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

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

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

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

@@ -0,0 +1,36 @@
+import type * as fs from 'node:fs';
+import type { EnvironmentModuleNode, RunnableDevEnvironment } from 'vite';
+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) => EnvironmentModuleNode | undefined;
+    getModulesByFile: (file: string) => Set<EnvironmentModuleNode> | undefined;
+    getModuleInfo: (id: string) => ModuleInfo | null;
+    eachModule(callbackfn: (value: EnvironmentModuleNode, key: string, map: Map<string, EnvironmentModuleNode>) => void): void;
+    invalidateModule(mod: EnvironmentModuleNode): void;
+    fixStacktrace: (error: Error) => void;
+    clientReload: () => void;
+    webSocketSend: (msg: any) => void;
+    isHttps: () => boolean;
+    events: TypedEventEmitter<LoaderEvents>;
+    getSSREnvironment: () => RunnableDevEnvironment;
+}
+export interface ModuleInfo {
+    id: string;
+    meta?: Record<string, any>;
+}
+export declare function createLoader(overrides: Partial<ModuleLoader>): ModuleLoader;

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

@@ -0,0 +1,42 @@
+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;
+    },
+    getSSREnvironment() {
+      throw new Error("Not implemented");
+    },
+    events: new EventEmitter(),
+    ...overrides
+  };
+}
+export {
+  createLoader
+};

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

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

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

@@ -0,0 +1,103 @@
+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";
+import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../constants.js";
+function createViteLoader(viteServer, ssrEnvironment) {
+  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.environments.client.hot.send;
+  viteServer.environments.client.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 ssrEnvironment.runner.import(src);
+    },
+    async resolveId(spec, parent) {
+      const ret = await ssrEnvironment.pluginContainer.resolveId(spec, parent);
+      return ret?.id;
+    },
+    getModuleById(id) {
+      return ssrEnvironment.moduleGraph.getModuleById(id);
+    },
+    getModulesByFile(file) {
+      return ssrEnvironment.moduleGraph.getModulesByFile(file);
+    },
+    getModuleInfo(id) {
+      return ssrEnvironment.pluginContainer.getModuleInfo(id);
+    },
+    eachModule(cb) {
+      return ssrEnvironment.moduleGraph.idToModuleMap.forEach(cb);
+    },
+    invalidateModule(mod) {
+      ssrEnvironment.moduleGraph.invalidateModule(mod);
+    },
+    fixStacktrace(err) {
+      return viteServer.ssrFixStacktrace(err);
+    },
+    clientReload() {
+      viteServer.environments.client.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
+    },
+    webSocketSend(msg) {
+      return viteServer.environments.client.hot.send(msg);
+    },
+    getSSREnvironment() {
+      return viteServer.environments[ASTRO_VITE_ENVIRONMENT_NAMES.ssr];
+    },
+    isHttps() {
+      return !!ssrEnvironment.config.server.https;
+    },
+    events
+  };
+}
+export {
+  createViteLoader
+};