🎉 initiate project *astro_rewrite*

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

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

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

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

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

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import type * as fs from 'node:fs';
+import type { TypedEventEmitter } from '../../@types/typed-emitter';
+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) => ModuleNode | undefined;
+    getModulesByFile: (file: string) => Set<ModuleNode> | undefined;
+    getModuleInfo: (id: string) => ModuleInfo | null;
+    eachModule(callbackfn: (value: ModuleNode, key: string) => void): void;
+    invalidateModule(mod: ModuleNode): void;
+    fixStacktrace: (error: Error) => void;
+    clientReload: () => void;
+    webSocketSend: (msg: any) => void;
+    isHttps: () => boolean;
+    events: TypedEventEmitter<LoaderEvents>;
+}
+export interface ModuleNode {
+    id: string | null;
+    url: string;
+    ssrModule: Record<string, any> | null;
+    ssrTransformResult: {
+        deps?: string[];
+        dynamicDeps?: string[];
+    } | null;
+    ssrError: Error | null;
+    importedModules: Set<ModuleNode>;
+    importers: Set<ModuleNode>;
+}
+export interface ModuleInfo {
+    id: string;
+    meta?: Record<string, any>;
+}
+export declare function createLoader(overrides: Partial<ModuleLoader>): ModuleLoader;

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

@@ -0,0 +1,39 @@
+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;
+    },
+    events: new EventEmitter(),
+    ...overrides
+  };
+}
+export {
+  createLoader
+};

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

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

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

@@ -0,0 +1,62 @@
+import { EventEmitter } from "node:events";
+function createViteLoader(viteServer) {
+  const events = new EventEmitter();
+  viteServer.watcher.on("add", (...args) => events.emit("file-add", args));
+  viteServer.watcher.on("unlink", (...args) => events.emit("file-unlink", args));
+  viteServer.watcher.on("change", (...args) => events.emit("file-change", args));
+  wrapMethod(viteServer.ws, "send", (msg) => {
+    if ((msg == null ? void 0 : msg.type) === "error") {
+      events.emit("hmr-error", msg);
+    }
+  });
+  return {
+    import(src) {
+      return viteServer.ssrLoadModule(src);
+    },
+    async resolveId(spec, parent) {
+      const ret = await viteServer.pluginContainer.resolveId(spec, parent);
+      return ret == null ? void 0 : ret.id;
+    },
+    getModuleById(id) {
+      return viteServer.moduleGraph.getModuleById(id);
+    },
+    getModulesByFile(file) {
+      return viteServer.moduleGraph.getModulesByFile(file);
+    },
+    getModuleInfo(id) {
+      return viteServer.pluginContainer.getModuleInfo(id);
+    },
+    eachModule(cb) {
+      return viteServer.moduleGraph.idToModuleMap.forEach(cb);
+    },
+    invalidateModule(mod) {
+      viteServer.moduleGraph.invalidateModule(mod);
+    },
+    fixStacktrace(err) {
+      return viteServer.ssrFixStacktrace(err);
+    },
+    clientReload() {
+      viteServer.ws.send({
+        type: "full-reload",
+        path: "*"
+      });
+    },
+    webSocketSend(msg) {
+      return viteServer.ws.send(msg);
+    },
+    isHttps() {
+      return !!viteServer.config.server.https;
+    },
+    events
+  };
+}
+function wrapMethod(object, method, newFn) {
+  const orig = object[method];
+  object[method] = function(...args) {
+    newFn.apply(this, args);
+    return orig.apply(this, args);
+  };
+}
+export {
+  createViteLoader
+};