@nuvio/vite-plugin 0.5.4 → 1.0.0

package/dist/index.js

@@ -1,17 +1,99 @@
 import {
+  __toESM,
   buildSourceIndex,
+  detectProjectLibraries,
   extractIdsFromSource,
+  handleTagElementMessage,
   pathnameFromUpgradeUrl,
   pickBestSourceIndex,
-  readRuntimeVersions
-} from "./chunk-KTNIIC2D.js";
+  readRuntimeVersions,
+  require_lib,
+  resolvePatchClassNameMode
+} from "./chunk-QAQAJG7B.js";
 
 // src/index.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 import { WebSocket } from "ws";
 import { WebSocketServer } from "ws";
 import { applyPatchToSource } from "@nuvio/ast-engine";
+
+// src/jsx-loc-transform.ts
+var t = __toESM(require_lib(), 1);
+import { createRequire } from "module";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import path from "path";
+var require2 = createRequire(import.meta.url);
+var generate = require2("@babel/generator").default;
+var LOC_ATTR = "data-nuvio-loc";
+function getTraverseFn() {
+  if (typeof traverseImport === "function") {
+    return traverseImport;
+  }
+  const d = traverseImport.default;
+  if (typeof d === "function") {
+    return d;
+  }
+  throw new Error("[Nuvio] @babel/traverse did not resolve to a callable export");
+}
+function hasNuvioId(opening) {
+  return opening.attributes.some(
+    (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && (attr.name.name === "data-nuvio-id" || attr.name.name === LOC_ATTR)
+  );
+}
+function hasLocAttr(opening) {
+  return opening.attributes.some(
+    (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name, { name: LOC_ATTR })
+  );
+}
+function injectJsxLocAttributes(code, fileAbs, projectRoot) {
+  if (!/\.(tsx|jsx)$/.test(fileAbs)) {
+    return { code, changed: false };
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"],
+      sourceFilename: fileAbs
+    });
+  } catch {
+    return { code, changed: false };
+  }
+  const rel = path.relative(projectRoot, fileAbs).split(path.sep).join("/");
+  let changed = false;
+  const traverseFn = getTraverseFn();
+  traverseFn(ast, {
+    JSXOpeningElement(p) {
+      const opening = p.node;
+      if (opening.name.type !== "JSXIdentifier") {
+        return;
+      }
+      if (hasNuvioId(opening)) {
+        return;
+      }
+      if (hasLocAttr(opening)) {
+        return;
+      }
+      const loc = opening.loc?.start;
+      if (!loc) {
+        return;
+      }
+      const value = `${rel}:${loc.line}:${loc.column}`;
+      opening.attributes.push(
+        t.jsxAttribute(t.jsxIdentifier(LOC_ATTR), t.stringLiteral(value))
+      );
+      changed = true;
+    }
+  });
+  if (!changed) {
+    return { code, changed: false };
+  }
+  return { code: generate(ast, { retainLines: true }).code, changed: true };
+}
+
+// src/index.ts
 import {
   NUVIO_WS_PATH,
   PROTOCOL_VERSION,
@@ -41,7 +123,7 @@ function supplementIndexFromAppTsx(serverRoot, built, classNameMode, emitWarn =
     return built;
   }
   for (const rel of APP_ENTRY_CANDIDATES) {
-    const appTsx = path.resolve(serverRoot, rel);
+    const appTsx = path2.resolve(serverRoot, rel);
     if (!fs.existsSync(appTsx)) {
       continue;
     }
@@ -90,9 +172,25 @@ function nuvio(options) {
   let cachedIndexPayload = null;
   let runtimeDiagnostics = { overlayCssMode: "self-contained" };
   const idToEntry = /* @__PURE__ */ new Map();
+  let lastDuplicateErrors = [];
+  let projectRoot = process.cwd();
   return {
     name: "nuvio",
     apply: "serve",
+    transform(code, id) {
+      if (!enabled) {
+        return null;
+      }
+      if (!id || id.includes("node_modules") || !/\.(tsx|jsx)$/.test(id)) {
+        return null;
+      }
+      const fileAbs = path2.isAbsolute(id) ? id : path2.resolve(projectRoot, id);
+      const { code: next, changed } = injectJsxLocAttributes(code, fileAbs, projectRoot);
+      if (!changed) {
+        return null;
+      }
+      return { code: next, map: null };
+    },
     configureServer(server) {
       if (!enabled) {
         server.config.logger.info(
@@ -101,10 +199,11 @@ function nuvio(options) {
         return;
       }
       const log = server.config.logger;
-      const fromConfigFile = typeof server.config.configFile === "string" ? path.dirname(server.config.configFile) : "";
-      const serverRoot = path.resolve(server.config.root);
+      const fromConfigFile = typeof server.config.configFile === "string" ? path2.dirname(server.config.configFile) : "";
+      const serverRoot = path2.resolve(server.config.root);
+      projectRoot = path2.resolve(fromConfigFile || serverRoot);
       const rootCandidates = [
-        path.resolve(fromConfigFile || serverRoot),
+        path2.resolve(fromConfigFile || serverRoot),
         serverRoot,
         process.cwd()
       ];
@@ -119,12 +218,12 @@ function nuvio(options) {
         }
       };
       const rebuildIndex = () => {
-        let built = pickBestSourceIndex(rootCandidates, scanGlobs, { classNameMode });
+        const detectedLibraries = detectProjectLibraries(serverRoot);
+        const indexOptions = { classNameMode, detectedLibraries };
+        let built = pickBestSourceIndex(rootCandidates, scanGlobs, indexOptions);
         built = supplementIndexFromAppTsx(serverRoot, built, classNameMode, log.warn);
         if (built.entries.length === 0) {
-          const fallback = buildSourceIndex(serverRoot, ["src/**/*.{tsx,jsx}"], {
-            classNameMode
-          });
+          const fallback = buildSourceIndex(serverRoot, ["src/**/*.{tsx,jsx}"], indexOptions);
           if (fallback.entries.length > 0) {
             log.warn(
               `[Nuvio] Multi-root scan yielded 0 ids; using serverRoot-only index (${fallback.entries.length} id(s)) from ${serverRoot}.`
@@ -137,10 +236,12 @@ function nuvio(options) {
         for (const e of built.entries) {
           idToEntry.set(e.id, e);
         }
+        lastDuplicateErrors = built.duplicateErrors;
         const versions = readRuntimeVersions(serverRoot);
         runtimeDiagnostics = {
           ...versions,
-          overlayCssMode: "self-contained"
+          overlayCssMode: "self-contained",
+          detectedLibraries: detectedLibraries.length > 0 ? detectedLibraries : void 0
         };
         cachedIndexPayload = serializeServerMessage({
           type: "indexReady",
@@ -194,14 +295,14 @@ function nuvio(options) {
         }
       };
       const debouncedRebuild = /* @__PURE__ */ (() => {
-        let t;
+        let t2;
         return () => {
-          if (t) {
-            clearTimeout(t);
+          if (t2) {
+            clearTimeout(t2);
           }
-          t = setTimeout(() => {
+          t2 = setTimeout(() => {
             rebuildIndex();
-            t = void 0;
+            t2 = void 0;
           }, 120);
         };
       })();
@@ -300,8 +401,19 @@ function nuvio(options) {
             );
             return;
           }
+          if (msg.type === "tagElement") {
+            const writeGuardRoot = path2.resolve(fromConfigFile || serverRoot);
+            await handleTagElementMessage(ws, msg, {
+              writeGuardRoot,
+              projectRoot,
+              idToEntry,
+              duplicateIds: lastDuplicateErrors,
+              onIndexRebuilt: debouncedRebuild
+            });
+            return;
+          }
           if (msg.type === "patchUndo") {
-            const writeGuardRoot = path.resolve(fromConfigFile || serverRoot);
+            const writeGuardRoot = path2.resolve(fromConfigFile || serverRoot);
             const last = undoStack.pop();
             if (!last) {
               ws.send(
@@ -348,7 +460,7 @@ function nuvio(options) {
           }
           if (msg.type === "patchApply") {
             const entry = idToEntry.get(msg.id);
-            const writeGuardRoot = path.resolve(fromConfigFile || serverRoot);
+            const writeGuardRoot = path2.resolve(fromConfigFile || serverRoot);
             const dryRun = msg.dryRun === true;
             const patchAckExtras = dryRun ? { dryRun: true } : {};
             if (!entry) {
@@ -403,7 +515,7 @@ function nuvio(options) {
               return;
             }
             const result = await applyPatchToSource(source, entry.file, msg.id, msg.ops, {
-              classNameMode,
+              classNameMode: resolvePatchClassNameMode(entry, classNameMode),
               activeBreakpoint: msg.activeBreakpoint
             });
             if (!result.ok) {

package/dist/nuvio-dev-session.js

@@ -1,461 +1,8 @@
 import {
-  buildSourceIndex,
-  extractIdsFromSource,
-  pathnameFromUpgradeUrl,
-  pickBestSourceIndex,
-  readRuntimeVersions
-} from "./chunk-KTNIIC2D.js";
-
-// src/nuvio-dev-session.ts
-import fs from "fs";
-import path from "path";
-import { watch } from "fs";
-import { WebSocket, WebSocketServer } from "ws";
-import { applyPatchToSource } from "@nuvio/ast-engine";
-import {
-  NUVIO_WS_PATH,
-  PROTOCOL_VERSION,
-  parseClientMessage,
-  serializeServerMessage
-} from "@nuvio/shared";
-import { assertPathWithinRoot } from "@nuvio/shared/secure-path";
-var APP_ENTRY_CANDIDATES = ["src/App.tsx", "src/app.tsx", "App.tsx"];
-var DEFAULT_GLOBS = [
-  "src/**/*.{tsx,jsx}",
-  "apps/**/src/**/*.{tsx,jsx}",
-  "packages/**/src/**/*.{tsx,jsx}"
-];
-function nuvioWsMessageToText(data) {
-  if (typeof data === "string") {
-    return data;
-  }
-  if (Buffer.isBuffer(data)) {
-    return data.toString("utf8");
-  }
-  if (data instanceof ArrayBuffer) {
-    return Buffer.from(data).toString("utf8");
-  }
-  if (ArrayBuffer.isView(data)) {
-    const v = data;
-    return Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("utf8");
-  }
-  return String(data);
-}
-function isAllowedOrigin(origin) {
-  if (origin === void 0 || origin === "") {
-    return true;
-  }
-  try {
-    const u = new URL(origin);
-    return (u.hostname === "localhost" || u.hostname === "127.0.0.1") && (u.protocol === "http:" || u.protocol === "https:");
-  } catch {
-    return false;
-  }
-}
-function supplementIndexFromAppTsx(serverRoot, built, classNameMode, emitWarn) {
-  if (built.entries.length > 0) {
-    return built;
-  }
-  for (const rel of APP_ENTRY_CANDIDATES) {
-    const appTsx = path.resolve(serverRoot, rel);
-    if (!fs.existsSync(appTsx)) {
-      continue;
-    }
-    try {
-      const code = fs.readFileSync(appTsx, "utf8");
-      const hits = extractIdsFromSource(appTsx, code, { classNameMode });
-      if (hits.length === 0) {
-        continue;
-      }
-      emitWarn(
-        `[Nuvio] Source index had 0 ids; supplemented from ${appTsx} (${hits.length} id(s)).`
-      );
-      return {
-        ...built,
-        entries: hits,
-        scannedFileCount: Math.max(built.scannedFileCount, 1)
-      };
-    } catch {
-    }
-  }
-  return built;
-}
-function attachNuvioDevSession(httpServer, options) {
-  const log = options.log ?? console;
-  const enabled = options.enabled ?? process.env.NUVIO !== "0";
-  const scanGlobs = options.scanGlobs ?? DEFAULT_GLOBS;
-  const verbose = options.verbose ?? false;
-  const classNameMode = options.classNameMode ?? "literal-only";
-  const serverRoot = path.resolve(options.root);
-  const fromConfigFile = options.configDir ?? "";
-  const rootCandidates = [path.resolve(fromConfigFile || serverRoot), serverRoot, process.cwd()];
-  const rootsLabel = [...new Set(rootCandidates)].join(" | ");
-  let indexVersion = 0;
-  let cachedIndexPayload = null;
-  let runtimeDiagnostics = { overlayCssMode: "self-contained" };
-  const idToEntry = /* @__PURE__ */ new Map();
-  const wss = new WebSocketServer({ noServer: true });
-  const undoStack = [];
-  const UNDO_MAX = 32;
-  const pushUndoSnapshot = (file, contents) => {
-    undoStack.push({ file, contents });
-    while (undoStack.length > UNDO_MAX) {
-      undoStack.shift();
-    }
-  };
-  const rebuildIndex = () => {
-    if (!enabled) {
-      return;
-    }
-    let built = pickBestSourceIndex(rootCandidates, scanGlobs, { classNameMode });
-    built = supplementIndexFromAppTsx(serverRoot, built, classNameMode, log.warn);
-    if (built.entries.length === 0) {
-      const fallback = buildSourceIndex(serverRoot, ["src/**/*.{tsx,jsx}"], { classNameMode });
-      if (fallback.entries.length > 0) {
-        log.warn(
-          `[Nuvio] Multi-root scan yielded 0 ids; using serverRoot-only index (${fallback.entries.length} id(s)).`
-        );
-        built = fallback;
-      }
-    }
-    indexVersion += 1;
-    idToEntry.clear();
-    for (const e of built.entries) {
-      idToEntry.set(e.id, e);
-    }
-    runtimeDiagnostics = {
-      ...readRuntimeVersions(serverRoot),
-      overlayCssMode: "self-contained"
-    };
-    cachedIndexPayload = serializeServerMessage({
-      type: "indexReady",
-      protocolVersion: PROTOCOL_VERSION,
-      indexVersion,
-      entries: built.entries,
-      duplicateErrors: built.duplicateErrors,
-      diagnostics: runtimeDiagnostics
-    });
-    if (verbose) {
-      log.info(
-        `[Nuvio] index roots=${rootsLabel} matchedFiles=${built.scannedFileCount} uniqueIds=${built.entries.length}`
-      );
-    } else {
-      log.info(`[Nuvio] index \u2014 ${built.entries.length} id(s), ${built.scannedFileCount} file(s)`);
-    }
-    if (cachedIndexPayload && wss.clients.size > 0) {
-      for (const client of wss.clients) {
-        if (client.readyState === WebSocket.OPEN) {
-          client.send(cachedIndexPayload);
-        }
-      }
-    }
-  };
-  const debouncedRebuild = /* @__PURE__ */ (() => {
-    let t;
-    return () => {
-      if (t) {
-        clearTimeout(t);
-      }
-      t = setTimeout(() => {
-        rebuildIndex();
-        t = void 0;
-      }, 120);
-    };
-  })();
-  const srcDir = path.join(serverRoot, "src");
-  let fileWatcher = null;
-  if (enabled && fs.existsSync(srcDir)) {
-    try {
-      fileWatcher = watch(srcDir, { recursive: true }, (_event, filename) => {
-        if (filename && /\.(tsx|jsx)$/.test(filename)) {
-          debouncedRebuild();
-        }
-      });
-    } catch {
-    }
-  }
-  wss.on("connection", (ws) => {
-    if (cachedIndexPayload && ws.readyState === WebSocket.OPEN) {
-      ws.send(cachedIndexPayload);
-    }
-    ws.on("message", async (data) => {
-      const text = nuvioWsMessageToText(data);
-      const msg = parseClientMessage(text);
-      if (!msg) {
-        ws.send(
-          serializeServerMessage({
-            type: "error",
-            code: "bad_message",
-            message: "Invalid client message"
-          })
-        );
-        return;
-      }
-      if (msg.protocolVersion !== PROTOCOL_VERSION) {
-        ws.send(
-          serializeServerMessage({
-            type: "error",
-            code: "bad_version",
-            message: `Expected protocolVersion ${PROTOCOL_VERSION}`,
-            requestId: "requestId" in msg ? msg.requestId : void 0
-          })
-        );
-        return;
-      }
-      if (msg.type === "ping") {
-        ws.send(
-          serializeServerMessage({
-            type: "pong",
-            protocolVersion: PROTOCOL_VERSION,
-            requestId: msg.requestId,
-            diagnostics: runtimeDiagnostics
-          })
-        );
-        if (cachedIndexPayload) {
-          ws.send(cachedIndexPayload);
-        }
-        return;
-      }
-      if (msg.type === "select") {
-        const entry = idToEntry.get(msg.id);
-        if (!entry) {
-          ws.send(
-            serializeServerMessage({
-              type: "selectAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              id: msg.id,
-              ok: false,
-              errorCode: "unknown_id",
-              errorMessage: "Id not found in dev source index"
-            })
-          );
-          return;
-        }
-        ws.send(
-          serializeServerMessage({
-            type: "selectAck",
-            protocolVersion: PROTOCOL_VERSION,
-            requestId: msg.requestId,
-            id: msg.id,
-            ok: true,
-            file: entry.file,
-            line: entry.line,
-            column: entry.column,
-            patchHostId: entry.patchHostId,
-            primaryTextTargetKey: entry.primaryTextTargetKey,
-            textTargets: entry.textTargets,
-            styleTargets: entry.styleTargets,
-            hierarchyRole: entry.hierarchyRole,
-            parentHostId: entry.parentHostId,
-            childTargetIds: entry.childTargetIds,
-            rowTargets: entry.rowTargets,
-            tableMeta: entry.tableMeta,
-            tableDataField: entry.tableDataField
-          })
-        );
-        return;
-      }
-      if (msg.type === "patchUndo") {
-        const writeGuardRoot = path.resolve(fromConfigFile || serverRoot);
-        const last = undoStack.pop();
-        if (!last) {
-          ws.send(
-            serializeServerMessage({
-              type: "patchUndoAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              ok: false,
-              errorCode: "empty_stack",
-              errorMessage: "Nothing to undo"
-            })
-          );
-          return;
-        }
-        try {
-          assertPathWithinRoot(writeGuardRoot, last.file);
-          fs.writeFileSync(last.file, last.contents, "utf8");
-        } catch (e) {
-          undoStack.push(last);
-          ws.send(
-            serializeServerMessage({
-              type: "patchUndoAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              ok: false,
-              errorCode: "undo_write_error",
-              errorMessage: String(e)
-            })
-          );
-          return;
-        }
-        ws.send(
-          serializeServerMessage({
-            type: "patchUndoAck",
-            protocolVersion: PROTOCOL_VERSION,
-            requestId: msg.requestId,
-            ok: true,
-            file: last.file,
-            undoStackDepth: undoStack.length
-          })
-        );
-        return;
-      }
-      if (msg.type === "patchApply") {
-        const entry = idToEntry.get(msg.id);
-        const writeGuardRoot = path.resolve(fromConfigFile || serverRoot);
-        const dryRun = msg.dryRun === true;
-        const patchAckExtras = dryRun ? { dryRun: true } : {};
-        if (!entry) {
-          ws.send(
-            serializeServerMessage({
-              type: "patchAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              id: msg.id,
-              ok: false,
-              errorCode: "unknown_id",
-              errorMessage: "Id not found in dev source index",
-              ...patchAckExtras
-            })
-          );
-          return;
-        }
-        try {
-          assertPathWithinRoot(writeGuardRoot, entry.file);
-        } catch (e) {
-          ws.send(
-            serializeServerMessage({
-              type: "patchAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              id: msg.id,
-              ok: false,
-              errorCode: "path_escape",
-              errorMessage: String(e),
-              ...patchAckExtras
-            })
-          );
-          return;
-        }
-        let source;
-        try {
-          source = fs.readFileSync(entry.file, "utf8");
-        } catch (e) {
-          ws.send(
-            serializeServerMessage({
-              type: "patchAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              id: msg.id,
-              ok: false,
-              errorCode: "read_error",
-              errorMessage: String(e),
-              ...patchAckExtras
-            })
-          );
-          return;
-        }
-        const result = await applyPatchToSource(source, entry.file, msg.id, msg.ops, {
-          classNameMode,
-          activeBreakpoint: msg.activeBreakpoint
-        });
-        if (!result.ok) {
-          ws.send(
-            serializeServerMessage({
-              type: "patchAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              id: msg.id,
-              ok: false,
-              errorCode: result.code,
-              errorMessage: result.message,
-              ...patchAckExtras
-            })
-          );
-          return;
-        }
-        if (dryRun) {
-          ws.send(
-            serializeServerMessage({
-              type: "patchAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              id: msg.id,
-              ok: true,
-              diffSummary: result.diffSummary,
-              dryRun: true
-            })
-          );
-          return;
-        }
-        try {
-          fs.writeFileSync(entry.file, result.source, "utf8");
-        } catch (e) {
-          ws.send(
-            serializeServerMessage({
-              type: "patchAck",
-              protocolVersion: PROTOCOL_VERSION,
-              requestId: msg.requestId,
-              id: msg.id,
-              ok: false,
-              errorCode: "write_error",
-              errorMessage: String(e)
-            })
-          );
-          return;
-        }
-        pushUndoSnapshot(entry.file, source);
-        ws.send(
-          serializeServerMessage({
-            type: "patchAck",
-            protocolVersion: PROTOCOL_VERSION,
-            requestId: msg.requestId,
-            id: msg.id,
-            ok: true,
-            diffSummary: result.diffSummary,
-            writtenFile: entry.file,
-            undoStackDepth: undoStack.length
-          })
-        );
-      }
-    });
-  });
-  const onUpgrade = (request, socket, head) => {
-    if (!enabled) {
-      return;
-    }
-    const pathname = pathnameFromUpgradeUrl(request.url);
-    if (pathname !== NUVIO_WS_PATH) {
-      return;
-    }
-    if (!isAllowedOrigin(request.headers.origin)) {
-      socket.destroy();
-      return;
-    }
-    wss.handleUpgrade(request, socket, head, (ws) => {
-      wss.emit("connection", ws, request);
-    });
-  };
-  httpServer.on("upgrade", onUpgrade);
-  if (enabled) {
-    log.info("[Nuvio] dev session attached (App Router / custom server mode)");
-    rebuildIndex();
-  } else {
-    log.info("[Nuvio] disabled (set NUVIO=1 to enable)");
-  }
-  return {
-    rebuildIndex,
-    close: () => {
-      httpServer.off("upgrade", onUpgrade);
-      fileWatcher?.close();
-      for (const client of wss.clients) {
-        client.close();
-      }
-      wss.close();
-    }
-  };
-}
+  DEFAULT_GLOBS,
+  attachNuvioDevSession
+} from "./chunk-EZGH3CUW.js";
+import "./chunk-QAQAJG7B.js";
 export {
   DEFAULT_GLOBS as NUVIO_DEFAULT_SCAN_GLOBS,
   attachNuvioDevSession