@nasti-toolchain/nasti 1.1.0

package/dist/index.js

@@ -0,0 +1,1204 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/plugins/html.ts
+import path5 from "path";
+import fs4 from "fs";
+function htmlPlugin(config) {
+  return {
+    name: "nasti:html",
+    enforce: "post",
+    transformIndexHtml(html) {
+      const tags = [];
+      if (config.command === "serve") {
+        tags.push({
+          tag: "script",
+          attrs: { type: "module", src: "/@nasti/client" },
+          injectTo: "head-prepend"
+        });
+      }
+      return { html, tags };
+    }
+  };
+}
+function processHtml(html, tags) {
+  const headPrepend = tags.filter((t) => t.injectTo === "head-prepend");
+  const head = tags.filter((t) => t.injectTo === "head" || !t.injectTo);
+  const bodyPrepend = tags.filter((t) => t.injectTo === "body-prepend");
+  const body = tags.filter((t) => t.injectTo === "body");
+  if (headPrepend.length) {
+    html = html.replace(/<head([^>]*)>/i, `<head$1>
+${serializeTags(headPrepend)}`);
+  }
+  if (head.length) {
+    html = html.replace(/<\/head>/i, `${serializeTags(head)}
+</head>`);
+  }
+  if (bodyPrepend.length) {
+    html = html.replace(/<body([^>]*)>/i, `<body$1>
+${serializeTags(bodyPrepend)}`);
+  }
+  if (body.length) {
+    html = html.replace(/<\/body>/i, `${serializeTags(body)}
+</body>`);
+  }
+  return html;
+}
+function serializeTags(tags) {
+  return tags.map(serializeTag).join("\n");
+}
+function serializeTag(tag) {
+  const attrs = tag.attrs ? " " + Object.entries(tag.attrs).map(([k, v]) => v === true ? k : `${k}="${v}"`).join(" ") : "";
+  const children = typeof tag.children === "string" ? tag.children : tag.children ? serializeTags(tag.children) : "";
+  const selfClosing = ["link", "meta", "br", "hr", "img", "input"].includes(tag.tag);
+  if (selfClosing && !children) {
+    return `  <${tag.tag}${attrs} />`;
+  }
+  return `  <${tag.tag}${attrs}>${children}</${tag.tag}>`;
+}
+async function readHtmlFile(root) {
+  const htmlPath = path5.resolve(root, "index.html");
+  if (!fs4.existsSync(htmlPath)) return null;
+  return fs4.readFileSync(htmlPath, "utf-8");
+}
+var init_html = __esm({
+  "src/plugins/html.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/transformer.ts
+import { transformSync } from "oxc-transform";
+function shouldTransform(id) {
+  return TS_EXTENSIONS.test(id) || JSX_EXTENSIONS.test(id) || JS_EXTENSIONS.test(id) && false;
+}
+function transformCode(filename, code, options = {}) {
+  const isTS = TS_EXTENSIONS.test(filename) || /\.tsx$/.test(filename);
+  const isJSX = JSX_EXTENSIONS.test(filename);
+  const result = transformSync(filename, code, {
+    typescript: isTS ? {} : void 0,
+    jsx: isJSX || /\.tsx$/.test(filename) ? {
+      runtime: options.jsxRuntime ?? "automatic",
+      importSource: options.jsxImportSource ?? "react",
+      refresh: options.reactRefresh ?? false
+    } : void 0,
+    sourcemap: options.sourcemap ?? true
+  });
+  return {
+    code: result.code,
+    map: result.map ? JSON.stringify(result.map) : null
+  };
+}
+var JS_EXTENSIONS, TS_EXTENSIONS, JSX_EXTENSIONS;
+var init_transformer = __esm({
+  "src/core/transformer.ts"() {
+    "use strict";
+    JS_EXTENSIONS = /\.(js|mjs|cjs)$/;
+    TS_EXTENSIONS = /\.(ts|mts|cts)$/;
+    JSX_EXTENSIONS = /\.(jsx|tsx)$/;
+  }
+});
+
+// src/server/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  transformMiddleware: () => transformMiddleware,
+  transformRequest: () => transformRequest
+});
+import path7 from "path";
+import fs6 from "fs";
+function transformMiddleware(ctx) {
+  return async (req, res, next) => {
+    const url = req.url ?? "/";
+    if (req.method !== "GET") return next();
+    if (url === "/@nasti/client") {
+      res.setHeader("Content-Type", "application/javascript");
+      res.end(getHmrClientCode());
+      return;
+    }
+    if (url === "/" || url.endsWith(".html")) {
+      const html = await readHtmlFile(ctx.config.root);
+      if (html) {
+        let processedHtml = html;
+        for (const plugin of ctx.config.plugins) {
+          if (plugin.transformIndexHtml) {
+            const result = await plugin.transformIndexHtml(processedHtml);
+            if (typeof result === "string") {
+              processedHtml = result;
+            } else if (result && "html" in result) {
+              processedHtml = processHtml(result.html, result.tags);
+            } else if (Array.isArray(result)) {
+              processedHtml = processHtml(processedHtml, result);
+            }
+          }
+        }
+        processedHtml = processedHtml.replace(
+          "<head>",
+          '<head>\n  <script type="module" src="/@nasti/client"></script>'
+        );
+        res.setHeader("Content-Type", "text/html");
+        res.end(processedHtml);
+        return;
+      }
+    }
+    if (isModuleRequest(url)) {
+      try {
+        const result = await transformRequest(url, ctx);
+        if (result) {
+          const contentType = url.endsWith(".css") ? "application/javascript" : "application/javascript";
+          res.setHeader("Content-Type", contentType);
+          res.setHeader("Cache-Control", "no-cache");
+          res.end(typeof result === "string" ? result : result.code);
+          return;
+        }
+      } catch (err) {
+        console.error(`[nasti] Transform error: ${url}`, err.message);
+        res.statusCode = 500;
+        res.end(`Transform error: ${err.message}`);
+        return;
+      }
+    }
+    next();
+  };
+}
+async function transformRequest(url, ctx) {
+  const { config, pluginContainer, moduleGraph } = ctx;
+  const cached = moduleGraph.getModuleByUrl(url);
+  if (cached?.transformResult) {
+    return cached.transformResult;
+  }
+  const filePath = resolveUrlToFile(url, config.root);
+  if (!filePath || !fs6.existsSync(filePath)) return null;
+  const mod = await moduleGraph.ensureEntryFromUrl(url);
+  moduleGraph.registerModule(mod, filePath);
+  let code = fs6.readFileSync(filePath, "utf-8");
+  const pluginResult = await pluginContainer.transform(code, filePath);
+  if (pluginResult) {
+    code = typeof pluginResult === "string" ? pluginResult : pluginResult.code;
+  }
+  if (shouldTransform(filePath)) {
+    const result = transformCode(filePath, code, {
+      sourcemap: true,
+      jsxRuntime: "automatic",
+      jsxImportSource: config.framework === "vue" ? "vue" : "react",
+      reactRefresh: config.framework !== "vue"
+    });
+    code = result.code;
+  }
+  code = rewriteImports(code, config);
+  const transformResult = { code };
+  mod.transformResult = transformResult;
+  return transformResult;
+}
+function rewriteImports(code, config) {
+  return code.replace(
+    /from\s+['"]([^'"./][^'"]*)['"]/g,
+    (match, specifier) => {
+      if (specifier.startsWith("/") || specifier.startsWith(".")) return match;
+      return `from "/@modules/${specifier}"`;
+    }
+  ).replace(
+    /import\s+['"]([^'"./][^'"]*)['"]/g,
+    (match, specifier) => {
+      if (specifier.startsWith("/") || specifier.startsWith(".")) return match;
+      return `import "/@modules/${specifier}"`;
+    }
+  );
+}
+function resolveUrlToFile(url, root) {
+  const cleanUrl = url.split("?")[0];
+  if (cleanUrl.startsWith("/@modules/")) {
+    const moduleName = cleanUrl.slice("/@modules/".length);
+    try {
+      const { createRequire: createRequire2 } = __require("module");
+      const req = createRequire2(path7.resolve(root, "package.json"));
+      return req.resolve(moduleName);
+    } catch {
+      return null;
+    }
+  }
+  return path7.resolve(root, cleanUrl.replace(/^\//, ""));
+}
+function isModuleRequest(url) {
+  const cleanUrl = url.split("?")[0];
+  return /\.(ts|tsx|jsx|js|mjs|vue|css|json)$/.test(cleanUrl) || cleanUrl.startsWith("/@modules/");
+}
+function getHmrClientCode() {
+  return `
+// Nasti HMR Client
+const socket = new WebSocket(\`ws://\${location.host}\`, 'nasti-hmr');
+const hotModulesMap = new Map();
+
+socket.addEventListener('message', ({ data }) => {
+  const payload = JSON.parse(data);
+  switch (payload.type) {
+    case 'connected':
+      console.log('[nasti] connected.');
+      break;
+    case 'update':
+      payload.updates.forEach((update) => {
+        if (update.type === 'js-update') {
+          fetchUpdate(update);
+        } else if (update.type === 'css-update') {
+          updateCss(update.path);
+        }
+      });
+      break;
+    case 'full-reload':
+      console.log('[nasti] full reload');
+      location.reload();
+      break;
+    case 'error':
+      console.error('[nasti] error:', payload.err.message);
+      showErrorOverlay(payload.err);
+      break;
+  }
+});
+
+async function fetchUpdate(update) {
+  const mod = hotModulesMap.get(update.path);
+  if (mod) {
+    const newMod = await import(update.acceptedPath + '?t=' + update.timestamp);
+    mod.callbacks.forEach((cb) => cb(newMod));
+  } else {
+    // \u6CA1\u6709\u6CE8\u518C hot \u56DE\u8C03\uFF0C\u5C1D\u8BD5\u91CD\u65B0 import
+    await import(update.path + '?t=' + update.timestamp);
+  }
+}
+
+function updateCss(path) {
+  const el = document.querySelector(\`style[data-nasti-css="\${path}"]\`);
+  if (el) {
+    fetch(path + '?t=' + Date.now())
+      .then(r => r.text())
+      .then(css => { el.textContent = css; });
+  }
+}
+
+function showErrorOverlay(err) {
+  const overlay = document.createElement('div');
+  overlay.id = 'nasti-error-overlay';
+  overlay.style.cssText = 'position:fixed;inset:0;z-index:99999;background:rgba(0,0,0,0.85);color:#fff;font-family:monospace;padding:2rem;overflow:auto;';
+  overlay.innerHTML = \`<h2 style="color:#ff5555">Build Error</h2><pre>\${err.message}\\n\${err.stack || ''}</pre><button onclick="this.parentElement.remove()" style="margin-top:1rem;padding:0.5rem 1rem;cursor:pointer">Close</button>\`;
+  document.body.appendChild(overlay);
+}
+
+// import.meta.hot API
+const createHotContext = (ownerPath) => ({
+  accept(deps, callback) {
+    if (typeof deps === 'function' || !deps) {
+      // self-accepting
+      const callbacks = hotModulesMap.get(ownerPath)?.callbacks || [];
+      callbacks.push(deps || (() => {}));
+      hotModulesMap.set(ownerPath, { callbacks });
+    }
+  },
+  prune(callback) {
+    // \u6A21\u5757\u88AB\u79FB\u9664\u65F6\u6267\u884C
+  },
+  dispose(callback) {
+    // \u6A21\u5757\u66F4\u65B0\u524D\u6267\u884C\u6E05\u7406
+  },
+  invalidate() {
+    location.reload();
+  },
+  data: {},
+});
+
+// \u66B4\u9732\u7ED9\u6A21\u5757\u4F7F\u7528
+if (!window.__nasti_hot_map) window.__nasti_hot_map = new Map();
+window.__NASTI_HMR__ = { createHotContext };
+`;
+}
+var init_middleware = __esm({
+  "src/server/middleware.ts"() {
+    "use strict";
+    init_transformer();
+    init_html();
+  }
+});
+
+// src/config/index.ts
+import { pathToFileURL } from "url";
+import path from "path";
+import fs from "fs";
+
+// src/config/defaults.ts
+var defaultResolve = {
+  alias: {},
+  extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".vue"],
+  conditions: ["import", "module", "browser", "default"],
+  mainFields: ["module", "jsnext:main", "jsnext", "main"]
+};
+var defaultServer = {
+  port: 3e3,
+  host: "localhost",
+  https: false,
+  open: false,
+  proxy: {},
+  cors: true,
+  hmr: true
+};
+var defaultBuild = {
+  outDir: "dist",
+  assetsDir: "assets",
+  minify: true,
+  sourcemap: false,
+  target: "es2022",
+  rolldownOptions: {},
+  emptyOutDir: true
+};
+var defaults = {
+  root: ".",
+  base: "/",
+  mode: "development",
+  framework: "auto",
+  resolve: defaultResolve,
+  server: defaultServer,
+  build: defaultBuild,
+  plugins: [],
+  envPrefix: ["NASTI_", "VITE_"],
+  logLevel: "info"
+};
+
+// src/config/index.ts
+function defineConfig(config) {
+  return config;
+}
+var CONFIG_FILES = [
+  "nasti.config.ts",
+  "nasti.config.js",
+  "nasti.config.mjs",
+  "nasti.config.mts"
+];
+async function loadConfigFromFile(root) {
+  for (const file of CONFIG_FILES) {
+    const filePath = path.resolve(root, file);
+    if (!fs.existsSync(filePath)) continue;
+    if (file.endsWith(".ts") || file.endsWith(".mts")) {
+      return await loadTsConfig(filePath);
+    }
+    const mod = await import(pathToFileURL(filePath).href);
+    return mod.default ?? mod;
+  }
+  return {};
+}
+async function loadTsConfig(filePath) {
+  const { transformSync: transformSync2 } = await import("oxc-transform");
+  const code = fs.readFileSync(filePath, "utf-8");
+  const result = transformSync2(filePath, code, {
+    typescript: {}
+  });
+  const tmpFile = filePath + ".timestamp-" + Date.now() + ".mjs";
+  try {
+    fs.writeFileSync(tmpFile, result.code);
+    const mod = await import(pathToFileURL(tmpFile).href);
+    return mod.default ?? mod;
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+}
+async function resolveConfig(inlineConfig = {}, command) {
+  const root = path.resolve(inlineConfig.root ?? defaults.root);
+  const fileConfig = await loadConfigFromFile(root);
+  const merged = deepMerge(deepMerge({}, fileConfig), inlineConfig);
+  const rawPlugins = [
+    ...fileConfig.plugins ?? [],
+    ...inlineConfig.plugins ?? []
+  ];
+  const env = { mode: merged.mode ?? defaults.mode, command };
+  for (const plugin of rawPlugins) {
+    if (plugin.config) {
+      const result = await plugin.config(merged, env);
+      if (result) Object.assign(merged, result);
+    }
+  }
+  const filteredPlugins = rawPlugins.filter((p) => {
+    if (!p.apply) return true;
+    if (typeof p.apply === "function") return p.apply(resolved, env);
+    return p.apply === command;
+  });
+  const resolved = {
+    root,
+    base: merged.base ?? defaults.base,
+    mode: command === "build" ? "production" : "development",
+    framework: merged.framework ?? defaults.framework,
+    command,
+    resolve: {
+      alias: { ...defaults.resolve.alias, ...merged.resolve?.alias },
+      extensions: merged.resolve?.extensions ?? defaults.resolve.extensions,
+      conditions: merged.resolve?.conditions ?? defaults.resolve.conditions,
+      mainFields: merged.resolve?.mainFields ?? defaults.resolve.mainFields
+    },
+    plugins: filteredPlugins,
+    server: { ...defaults.server, ...merged.server },
+    build: { ...defaults.build, ...merged.build },
+    envPrefix: Array.isArray(merged.envPrefix) ? merged.envPrefix : merged.envPrefix ? [merged.envPrefix] : [...defaults.envPrefix],
+    logLevel: merged.logLevel ?? defaults.logLevel
+  };
+  for (const plugin of resolved.plugins) {
+    if (plugin.configResolved) {
+      await plugin.configResolved(resolved);
+    }
+  }
+  return resolved;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const val = source[key];
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      result[key] = deepMerge(
+        result[key] ?? {},
+        val
+      );
+    } else if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+// src/build/index.ts
+import path6 from "path";
+import fs5 from "fs";
+import { rolldown } from "rolldown";
+
+// src/plugins/resolve.ts
+import path2 from "path";
+import fs2 from "fs";
+import { createRequire } from "module";
+function resolvePlugin(config) {
+  const { alias, extensions } = config.resolve;
+  const require2 = createRequire(path2.resolve(config.root, "package.json"));
+  return {
+    name: "nasti:resolve",
+    enforce: "pre",
+    resolveId(source, importer) {
+      for (const [key, value] of Object.entries(alias)) {
+        if (source === key || source.startsWith(key + "/")) {
+          source = source.replace(key, value);
+          if (!path2.isAbsolute(source)) {
+            source = path2.resolve(config.root, source);
+          }
+          break;
+        }
+      }
+      if (path2.isAbsolute(source)) {
+        const resolved = tryResolveFile(source, extensions);
+        if (resolved) return resolved;
+      }
+      if (source.startsWith(".")) {
+        const dir = importer ? path2.dirname(importer) : config.root;
+        const absolute = path2.resolve(dir, source);
+        const resolved = tryResolveFile(absolute, extensions);
+        if (resolved) return resolved;
+      }
+      if (!source.startsWith("/") && !source.startsWith(".")) {
+        try {
+          const resolved = require2.resolve(source, {
+            paths: [importer ? path2.dirname(importer) : config.root]
+          });
+          return resolved;
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    },
+    load(id) {
+      if (fs2.existsSync(id)) {
+        return fs2.readFileSync(id, "utf-8");
+      }
+      return null;
+    }
+  };
+}
+function tryResolveFile(file, extensions) {
+  if (fs2.existsSync(file) && fs2.statSync(file).isFile()) {
+    return file;
+  }
+  for (const ext of extensions) {
+    const withExt = file + ext;
+    if (fs2.existsSync(withExt) && fs2.statSync(withExt).isFile()) {
+      return withExt;
+    }
+  }
+  if (fs2.existsSync(file) && fs2.statSync(file).isDirectory()) {
+    for (const ext of extensions) {
+      const indexFile = path2.join(file, "index" + ext);
+      if (fs2.existsSync(indexFile)) {
+        return indexFile;
+      }
+    }
+  }
+  return null;
+}
+
+// src/plugins/css.ts
+import path3 from "path";
+function cssPlugin(config) {
+  return {
+    name: "nasti:css",
+    resolveId(source) {
+      if (source.endsWith(".css")) return null;
+      return null;
+    },
+    transform(code, id) {
+      if (!id.endsWith(".css")) return null;
+      if (config.command === "serve") {
+        const escaped = JSON.stringify(code);
+        return {
+          code: `
+const css = ${escaped};
+const style = document.createElement('style');
+style.setAttribute('data-nasti-css', ${JSON.stringify(id)});
+style.textContent = css;
+document.head.appendChild(style);
+
+// HMR
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.prune(() => {
+    style.remove();
+  });
+}
+
+export default css;
+`
+        };
+      }
+      return null;
+    }
+  };
+}
+
+// src/plugins/assets.ts
+import path4 from "path";
+import fs3 from "fs";
+import crypto from "crypto";
+var ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".avif",
+  ".mp4",
+  ".webm",
+  ".ogg",
+  ".mp3",
+  ".wav",
+  ".flac",
+  ".aac",
+  ".woff",
+  ".woff2",
+  ".eot",
+  ".ttf",
+  ".otf",
+  ".pdf",
+  ".txt"
+]);
+function assetsPlugin(config) {
+  return {
+    name: "nasti:assets",
+    resolveId(source) {
+      if (source.endsWith("?url") || source.endsWith("?raw")) {
+        return source;
+      }
+      return null;
+    },
+    load(id) {
+      const ext = path4.extname(id.replace(/\?.*$/, ""));
+      if (id.endsWith("?raw")) {
+        const file = id.slice(0, -4);
+        if (fs3.existsSync(file)) {
+          const content = fs3.readFileSync(file, "utf-8");
+          return `export default ${JSON.stringify(content)}`;
+        }
+      }
+      if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
+        const file = id.replace(/\?.*$/, "");
+        if (!fs3.existsSync(file)) return null;
+        if (config.command === "serve") {
+          const url = "/" + path4.relative(config.root, file);
+          return `export default ${JSON.stringify(url)}`;
+        }
+        const content = fs3.readFileSync(file);
+        const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
+        const basename = path4.basename(file, ext);
+        const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
+        return `export default ${JSON.stringify(config.base + hashedName)}`;
+      }
+      return null;
+    }
+  };
+}
+
+// src/build/index.ts
+init_html();
+init_transformer();
+import pc from "picocolors";
+async function build(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig, "build");
+  const startTime = performance.now();
+  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${process.env.npm_package_version ?? "0.0.1"}`));
+  console.log(pc.dim(`  root: ${config.root}`));
+  console.log(pc.dim(`  mode: ${config.mode}`));
+  const outDir = path6.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && fs5.existsSync(outDir)) {
+    fs5.rmSync(outDir, { recursive: true, force: true });
+  }
+  fs5.mkdirSync(outDir, { recursive: true });
+  const html = await readHtmlFile(config.root);
+  let entryPoints = [];
+  if (html) {
+    const scriptMatches = html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi);
+    for (const match of scriptMatches) {
+      const src = match[1];
+      if (src && !src.startsWith("http")) {
+        entryPoints.push(path6.resolve(config.root, src.replace(/^\//, "")));
+      }
+    }
+  }
+  if (entryPoints.length === 0) {
+    const fallbackEntries = ["src/main.ts", "src/main.tsx", "src/main.js", "src/index.ts", "src/index.tsx", "src/index.js"];
+    for (const entry of fallbackEntries) {
+      const fullPath = path6.resolve(config.root, entry);
+      if (fs5.existsSync(fullPath)) {
+        entryPoints.push(fullPath);
+        break;
+      }
+    }
+  }
+  if (entryPoints.length === 0) {
+    throw new Error("No entry point found. Add a <script> tag to index.html or create src/main.ts");
+  }
+  const builtinPlugins = [
+    resolvePlugin(config),
+    cssPlugin(config),
+    assetsPlugin(config)
+  ];
+  const allPlugins = [...builtinPlugins, ...config.plugins];
+  const oxcTransformPlugin = {
+    name: "nasti:oxc-transform",
+    transform(code, id) {
+      if (!shouldTransform(id)) return null;
+      const result = transformCode(id, code, {
+        sourcemap: !!config.build.sourcemap,
+        jsxRuntime: "automatic",
+        jsxImportSource: config.framework === "vue" ? "vue" : "react"
+      });
+      return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
+    }
+  };
+  const bundle = await rolldown({
+    input: entryPoints,
+    plugins: [
+      oxcTransformPlugin,
+      // 转换 Nasti 插件为 Rolldown 插件格式
+      ...allPlugins.map((p) => ({
+        name: p.name,
+        resolveId: p.resolveId,
+        load: p.load,
+        transform: p.transform,
+        buildStart: p.buildStart,
+        buildEnd: p.buildEnd
+      }))
+    ],
+    ...config.build.rolldownOptions
+  });
+  const { output } = await bundle.write({
+    dir: outDir,
+    format: "esm",
+    sourcemap: !!config.build.sourcemap,
+    entryFileNames: "assets/[name].[hash].js",
+    chunkFileNames: "assets/[name].[hash].js",
+    assetFileNames: "assets/[name].[hash][extname]"
+  });
+  await bundle.close();
+  if (html) {
+    let processedHtml = html;
+    const htmlPlugin_ = htmlPlugin(config);
+    if (htmlPlugin_.transformIndexHtml) {
+      const result = await htmlPlugin_.transformIndexHtml(processedHtml);
+      if (typeof result === "string") {
+        processedHtml = result;
+      } else if (result && "html" in result) {
+        processedHtml = processHtml(result.html, result.tags);
+      } else if (Array.isArray(result)) {
+        processedHtml = processHtml(processedHtml, result);
+      }
+    }
+    for (const chunk of output) {
+      if (chunk.type === "chunk" && chunk.isEntry) {
+        const originalEntry = path6.relative(config.root, entryPoints[0]);
+        processedHtml = processedHtml.replace(
+          new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
+          `$1${config.base}${chunk.fileName}$3`
+        );
+      }
+    }
+    fs5.writeFileSync(path6.resolve(outDir, "index.html"), processedHtml);
+  }
+  const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
+  const totalSize = output.reduce((sum, chunk) => {
+    if (chunk.type === "chunk" && chunk.code) return sum + chunk.code.length;
+    return sum;
+  }, 0);
+  console.log(pc.green(`
+\u2713 Built in ${elapsed}s`));
+  console.log(pc.dim(`  ${output.length} files, ${formatSize(totalSize)} total`));
+  console.log(pc.dim(`  output: ${config.build.outDir}/
+`));
+  return { output };
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} kB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/server/index.ts
+import http from "http";
+import path9 from "path";
+import connect from "connect";
+import sirv from "sirv";
+import { watch } from "chokidar";
+import pc2 from "picocolors";
+
+// src/core/plugin-container.ts
+var PluginContainer = class {
+  plugins;
+  config;
+  ctx;
+  constructor(config) {
+    this.config = config;
+    this.plugins = sortPlugins(config.plugins);
+    this.ctx = this.createContext();
+  }
+  createContext() {
+    const container = this;
+    return {
+      async resolve(source, importer) {
+        return container.resolveId(source, importer);
+      },
+      emitFile(_file) {
+        return "";
+      },
+      getModuleInfo(_id) {
+        return null;
+      }
+    };
+  }
+  async buildStart() {
+    for (const plugin of this.plugins) {
+      if (plugin.buildStart) {
+        await plugin.buildStart.call(this.ctx);
+      }
+    }
+  }
+  async buildEnd(error) {
+    for (const plugin of this.plugins) {
+      if (plugin.buildEnd) {
+        await plugin.buildEnd.call(this.ctx, error);
+      }
+    }
+  }
+  async resolveId(source, importer, options = {}) {
+    for (const plugin of this.plugins) {
+      if (!plugin.resolveId) continue;
+      const result = await plugin.resolveId.call(
+        this.ctx,
+        source,
+        importer ?? void 0,
+        { isEntry: options.isEntry ?? false, ssr: false }
+      );
+      if (result != null) return result;
+    }
+    return null;
+  }
+  async load(id) {
+    for (const plugin of this.plugins) {
+      if (!plugin.load) continue;
+      const result = await plugin.load.call(this.ctx, id);
+      if (result != null) return result;
+    }
+    return null;
+  }
+  async transform(code, id) {
+    let currentCode = code;
+    for (const plugin of this.plugins) {
+      if (!plugin.transform) continue;
+      const result = await plugin.transform.call(this.ctx, currentCode, id);
+      if (result == null) continue;
+      if (typeof result === "string") {
+        currentCode = result;
+      } else {
+        currentCode = result.code;
+      }
+    }
+    return currentCode === code ? null : { code: currentCode };
+  }
+  /** 完整的模块处理管道: resolveId → load → transform */
+  async processModule(source, importer) {
+    const resolveResult = await this.resolveId(source, importer, {
+      isEntry: !importer
+    });
+    if (resolveResult == null) return null;
+    const id = typeof resolveResult === "string" ? resolveResult : resolveResult.id;
+    const loadResult = await this.load(id);
+    if (loadResult == null) return null;
+    const loadedCode = typeof loadResult === "string" ? loadResult : loadResult.code;
+    const transformResult = await this.transform(loadedCode, id);
+    const finalCode = transformResult == null ? loadedCode : typeof transformResult === "string" ? transformResult : transformResult.code;
+    return { id, code: finalCode };
+  }
+  getPlugins() {
+    return this.plugins;
+  }
+};
+function sortPlugins(plugins) {
+  const pre = [];
+  const normal = [];
+  const post = [];
+  for (const plugin of plugins) {
+    if (plugin.enforce === "pre") pre.push(plugin);
+    else if (plugin.enforce === "post") post.push(plugin);
+    else normal.push(plugin);
+  }
+  return [...pre, ...normal, ...post];
+}
+
+// src/core/module-graph.ts
+var ModuleGraph = class {
+  urlToModuleMap = /* @__PURE__ */ new Map();
+  idToModuleMap = /* @__PURE__ */ new Map();
+  fileToModulesMap = /* @__PURE__ */ new Map();
+  getModuleByUrl(url) {
+    return this.urlToModuleMap.get(url);
+  }
+  getModuleById(id) {
+    return this.idToModuleMap.get(id);
+  }
+  getModulesByFile(file) {
+    return this.fileToModulesMap.get(file);
+  }
+  async ensureEntryFromUrl(url) {
+    let mod = this.urlToModuleMap.get(url);
+    if (mod) return mod;
+    mod = this.createModule(url);
+    this.urlToModuleMap.set(url, mod);
+    return mod;
+  }
+  createModule(url, id) {
+    const mod = {
+      id: id ?? url,
+      file: null,
+      url,
+      type: url.endsWith(".css") ? "css" : "js",
+      importers: /* @__PURE__ */ new Set(),
+      importedModules: /* @__PURE__ */ new Set(),
+      acceptedHmrDeps: /* @__PURE__ */ new Set(),
+      transformResult: null,
+      lastHMRTimestamp: 0,
+      isSelfAccepting: false
+    };
+    this.idToModuleMap.set(mod.id, mod);
+    return mod;
+  }
+  /** 注册文件路径到模块的映射 */
+  registerModule(mod, file) {
+    mod.file = file;
+    let mods = this.fileToModulesMap.get(file);
+    if (!mods) {
+      mods = /* @__PURE__ */ new Set();
+      this.fileToModulesMap.set(file, mods);
+    }
+    mods.add(mod);
+  }
+  /** 更新模块依赖关系 */
+  updateModuleImports(mod, importedIds) {
+    for (const imported of mod.importedModules) {
+      imported.importers.delete(mod);
+    }
+    mod.importedModules.clear();
+    for (const id of importedIds) {
+      const importedMod = this.idToModuleMap.get(id);
+      if (importedMod) {
+        mod.importedModules.add(importedMod);
+        importedMod.importers.add(mod);
+      }
+    }
+  }
+  /** 使模块的转换缓存失效 */
+  invalidateModule(mod) {
+    mod.transformResult = null;
+    mod.lastHMRTimestamp = Date.now();
+  }
+  /** 使所有模块缓存失效 */
+  invalidateAll() {
+    for (const mod of this.idToModuleMap.values()) {
+      this.invalidateModule(mod);
+    }
+  }
+  /** 获取 HMR 传播边界 - 从变更模块向上遍历找到接受更新的边界 */
+  getHmrBoundaries(mod) {
+    const boundaries = [];
+    const visited = /* @__PURE__ */ new Set();
+    const propagate = (node, via) => {
+      if (visited.has(node)) return true;
+      visited.add(node);
+      if (node.isSelfAccepting) {
+        boundaries.push({ boundary: node, acceptedVia: via });
+        return true;
+      }
+      if (node.acceptedHmrDeps.has(via)) {
+        boundaries.push({ boundary: node, acceptedVia: via });
+        return true;
+      }
+      if (node.importers.size === 0) return false;
+      for (const importer of node.importers) {
+        if (!propagate(importer, node)) return false;
+      }
+      return true;
+    };
+    if (mod.isSelfAccepting) {
+      boundaries.push({ boundary: mod, acceptedVia: mod });
+      return boundaries;
+    }
+    for (const importer of mod.importers) {
+      if (!propagate(importer, mod)) {
+        return [];
+      }
+    }
+    return boundaries;
+  }
+};
+
+// src/server/ws.ts
+import { WebSocketServer as WsServer } from "ws";
+function createWebSocketServer(server) {
+  const wss = new WsServer({ noServer: true });
+  const clients = /* @__PURE__ */ new Set();
+  server.on("upgrade", (req, socket, head) => {
+    if (req.headers["sec-websocket-protocol"] === "nasti-hmr") {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    }
+  });
+  wss.on("connection", (ws) => {
+    clients.add(ws);
+    ws.send(JSON.stringify({ type: "connected" }));
+    ws.on("close", () => {
+      clients.delete(ws);
+    });
+    ws.on("error", (err) => {
+      console.error("[nasti] WebSocket error:", err);
+      clients.delete(ws);
+    });
+  });
+  return {
+    send(payload) {
+      const data = JSON.stringify(payload);
+      for (const client of clients) {
+        if (client.readyState === 1) {
+          client.send(data);
+        }
+      }
+    },
+    close() {
+      clients.clear();
+      wss.close();
+    }
+  };
+}
+
+// src/server/index.ts
+init_middleware();
+
+// src/server/hmr.ts
+import path8 from "path";
+import fs7 from "fs";
+async function handleFileChange(file, server) {
+  const { moduleGraph, ws, config } = server;
+  const relativePath = "/" + path8.relative(config.root, file);
+  const mods = moduleGraph.getModulesByFile(file);
+  if (!mods || mods.size === 0) {
+    return;
+  }
+  const updates = [];
+  const timestamp = Date.now();
+  for (const mod of mods) {
+    moduleGraph.invalidateModule(mod);
+    const ctx = {
+      file,
+      timestamp,
+      modules: [mod],
+      read: () => fs7.readFileSync(file, "utf-8"),
+      server
+    };
+    let affectedModules = [mod];
+    for (const plugin of config.plugins) {
+      if (plugin.handleHotUpdate) {
+        const result = await plugin.handleHotUpdate(ctx);
+        if (result) {
+          affectedModules = result;
+        }
+      }
+    }
+    for (const affected of affectedModules) {
+      const boundaries = moduleGraph.getHmrBoundaries(affected);
+      if (boundaries.length === 0) {
+        ws.send({ type: "full-reload", path: relativePath });
+        return;
+      }
+      for (const { boundary } of boundaries) {
+        updates.push({
+          type: boundary.type === "css" ? "css-update" : "js-update",
+          path: boundary.url,
+          acceptedPath: affected.url,
+          timestamp
+        });
+      }
+    }
+  }
+  if (updates.length > 0) {
+    ws.send({ type: "update", updates });
+  }
+}
+
+// src/server/index.ts
+init_html();
+async function createServer(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig, "serve");
+  const allPlugins = [
+    resolvePlugin(config),
+    cssPlugin(config),
+    assetsPlugin(config),
+    htmlPlugin(config),
+    ...config.plugins
+  ];
+  const configWithPlugins = { ...config, plugins: allPlugins };
+  const moduleGraph = new ModuleGraph();
+  const pluginContainer = new PluginContainer(configWithPlugins);
+  const app = connect();
+  app.use(transformMiddleware({
+    config: configWithPlugins,
+    pluginContainer,
+    moduleGraph
+  }));
+  const publicDir = path9.resolve(config.root, "public");
+  app.use(sirv(publicDir, { dev: true, etag: true }));
+  app.use(sirv(config.root, { dev: true, etag: true }));
+  const httpServer = http.createServer(app);
+  const ws = createWebSocketServer(httpServer);
+  const watcher = watch(config.root, {
+    ignored: [
+      "**/node_modules/**",
+      "**/.git/**",
+      `**/${config.build.outDir}/**`
+    ],
+    ignoreInitial: true
+  });
+  let server;
+  watcher.on("change", (file) => {
+    handleFileChange(file, server);
+  });
+  watcher.on("add", (file) => {
+    handleFileChange(file, server);
+  });
+  const postMiddlewares = [];
+  for (const plugin of allPlugins) {
+    if (plugin.configureServer) {
+      const result = await plugin.configureServer(server);
+      if (typeof result === "function") {
+        postMiddlewares.push(result);
+      }
+    }
+  }
+  server = {
+    config: configWithPlugins,
+    middlewares: app,
+    moduleGraph,
+    watcher,
+    ws,
+    async listen(port) {
+      const finalPort = port ?? config.server.port;
+      const host = config.server.host === true ? "0.0.0.0" : config.server.host;
+      await pluginContainer.buildStart();
+      return new Promise((resolve, reject) => {
+        httpServer.listen(finalPort, host, () => {
+          const localUrl = `http://localhost:${finalPort}`;
+          const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${finalPort}` : null;
+          console.log();
+          console.log(pc2.cyan("  nasti dev server") + pc2.dim(` v0.0.1`));
+          console.log();
+          console.log(`  ${pc2.green(">")} Local:   ${pc2.cyan(localUrl)}`);
+          if (networkUrl) {
+            console.log(`  ${pc2.green(">")} Network: ${pc2.cyan(networkUrl)}`);
+          }
+          console.log();
+          resolve(server);
+        });
+        httpServer.on("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            console.log(pc2.yellow(`Port ${finalPort} is in use, trying ${finalPort + 1}...`));
+            httpServer.listen(finalPort + 1, host);
+          } else {
+            reject(err);
+          }
+        });
+      });
+    },
+    async transformRequest(url) {
+      const { transformRequest: transformRequest2 } = await Promise.resolve().then(() => (init_middleware(), middleware_exports));
+      return transformRequest2(url, { config: configWithPlugins, pluginContainer, moduleGraph });
+    },
+    async close() {
+      await pluginContainer.buildEnd();
+      watcher.close();
+      ws.close();
+      httpServer.close();
+    }
+  };
+  return server;
+}
+function getNetworkAddress() {
+  const os = __require("os");
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] ?? []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "localhost";
+}
+export {
+  build,
+  createServer,
+  defineConfig,
+  resolveConfig
+};
+//# sourceMappingURL=index.js.map