@amaster.ai/vite-plugins 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,866 @@
+import fs from 'fs';
+import path from 'path';
+import { createHash } from 'crypto';
+
+// src/browser-logs.ts
+function browserLogsPlugin() {
+  let logFilePath = "";
+  const injectedScript = `
+<script>
+(function() {
+  'use strict';
+  
+  // Log API path (provided by Vite dev server)
+  var LOG_API_PATH = '/__browser__';
+  
+  // Write queue to ensure sequential writes
+  var writeQueue = [];
+  var isWriting = false;
+  
+  // Process write queue to ensure sequential writes
+  function processWriteQueue() {
+    if (isWriting || writeQueue.length === 0) return;
+    
+    isWriting = true;
+    var entry = writeQueue.shift();
+    var logText = JSON.stringify(entry);
+    
+    fetch(LOG_API_PATH, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: logText
+    })
+    .then(function(response) {
+      isWriting = false;
+      if (!response.ok) {
+        console.warn('[BrowserLogs] Failed to write log:', response.status);
+      }
+      // Continue processing next item in queue
+      processWriteQueue();
+    })
+    .catch(function(error) {
+      console.warn('[BrowserLogs] Failed to write log:', error.message);
+      // On failure, put log back to queue head for retry
+      writeQueue.unshift(entry);
+      isWriting = false;
+      // Retry after delay
+      setTimeout(processWriteQueue, 1000);
+    });
+  }
+  
+  // Limit headers object size
+  function truncateHeaders(headers) {
+    if (!headers) return headers;
+    var jsonStr = JSON.stringify(headers);
+    if (jsonStr.length <= MAX_HEADER_SIZE) return headers;
+    return '[Headers truncated, size: ' + jsonStr.length + ']';
+  }
+  
+  // Truncate oversized log entries
+  function truncateLogEntry(entry) {
+    var jsonStr = JSON.stringify(entry);
+    if (jsonStr.length <= MAX_LOG_ENTRY_SIZE) {
+      return entry;
+    }
+    
+    // If oversized, progressively truncate non-critical fields
+    var truncated = Object.assign({}, entry);
+    
+    // 1. Truncate response body first
+    if (truncated.responseBody && typeof truncated.responseBody === 'string') {
+      truncated.responseBody = truncated.responseBody.substring(0, 500) + '... [truncated]';
+    }
+    
+    // 2. Truncate request body
+    if (truncated.requestBody && typeof truncated.requestBody === 'string') {
+      truncated.requestBody = truncated.requestBody.substring(0, 500) + '... [truncated]';
+    }
+    
+    // 3. Truncate message
+    if (truncated.message && typeof truncated.message === 'string' && truncated.message.length > 1000) {
+      truncated.message = truncated.message.substring(0, 1000) + '... [truncated]';
+    }
+    
+    // 4. Truncate stack
+    if (truncated.stack && Array.isArray(truncated.stack) && truncated.stack.length > 3) {
+      truncated.stack = truncated.stack.slice(0, 3);
+    }
+    
+    // Add truncation marker
+    truncated._truncated = true;
+    truncated._originalSize = jsonStr.length;
+    
+    return truncated;
+  }
+  
+  // Add log and send immediately (ensure order)
+  function addLog(entry) {
+    var truncatedEntry = truncateLogEntry(entry);
+    writeQueue.push(truncatedEntry);
+    processWriteQueue();
+  }
+  
+  // ============================================
+  // Console log collection
+  // ============================================
+  var originalConsole = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug
+  };
+  
+  function getStackTrace() {
+    var stack = new Error().stack || '';
+    var lines = stack.split('\\n').slice(3);
+    // Limit stack lines
+    return lines.slice(0, MAX_STACK_LINES).map(function(line) { return line.trim(); });
+  }
+  
+  function formatMessage(args) {
+    return Array.from(args).map(function(arg) {
+      if (arg === null) return 'null';
+      if (arg === undefined) return 'undefined';
+      if (typeof arg === 'object') {
+        try {
+          return JSON.stringify(arg);
+        } catch (e) {
+          return String(arg);
+        }
+      }
+      return String(arg);
+    }).join(' ');
+  }
+  
+  function createLogEntry(level, args) {
+    return {
+      type: 'console',
+      timestamp: new Date().toISOString(),
+      level: level,
+      message: formatMessage(args),
+      stack: getStackTrace()
+    };
+  }
+  
+  // Check if message should be filtered (contains [vite] text)
+  function shouldFilterConsoleLog(args) {
+    for (var i = 0; i < args.length; i++) {
+      var arg = args[i];
+      if (typeof arg === 'string' && arg.indexOf('[vite]') !== -1) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  function wrapConsoleMethod(method, level) {
+    return function() {
+      var args = arguments;
+      // Filter out logs containing [vite]
+      if (shouldFilterConsoleLog(args)) {
+        return originalConsole[method].apply(console, args);
+      }
+      var entry = createLogEntry(level, args);
+      addLog(entry);
+      return originalConsole[method].apply(console, args);
+    };
+  }
+  
+  console.log = wrapConsoleMethod('log', 'log');
+  console.info = wrapConsoleMethod('info', 'info');
+  console.warn = wrapConsoleMethod('warn', 'warn');
+  console.error = wrapConsoleMethod('error', 'error');
+  console.debug = wrapConsoleMethod('debug', 'debug');
+  
+  // ============================================
+  // Network request collection (exclude SSE and log API requests)
+  // ============================================
+  
+  var MAX_BODY_SIZE = 2000;
+  var MAX_LOG_ENTRY_SIZE = 3000; // Max single log entry length
+  var MAX_HEADER_SIZE = 500; // Max single header object length
+  var MAX_STACK_LINES = 5; // Max stack lines to keep
+  const FILTERED_URLS = ['/__browser__', '/builtin']; // Filter out log API and Vite built-in requests
+  
+  function isSSERequest(url, headers) {
+    var sseUrlPatterns = ['/events', '/sse', '/stream', 'text/event-stream'];
+    var urlStr = String(url).toLowerCase();
+    for (var i = 0; i < sseUrlPatterns.length; i++) {
+      if (urlStr.indexOf(sseUrlPatterns[i]) !== -1) {
+        return true;
+      }
+    }
+    
+    if (headers) {
+      if (typeof headers.get === 'function') {
+        var accept = headers.get('Accept') || headers.get('accept');
+        if (accept && accept.indexOf('text/event-stream') !== -1) {
+          return true;
+        }
+      } else if (typeof headers === 'object') {
+        for (var key in headers) {
+          if (key.toLowerCase() === 'accept' && headers[key].indexOf('text/event-stream') !== -1) {
+            return true;
+          }
+        }
+      }
+    }
+    
+    return false;
+  }
+  
+  function shouldFilterRequest(url) {
+    return FILTERED_URLS.some(function(filteredUrl) {
+      return String(url).indexOf(filteredUrl) !== -1;
+    });
+  }
+  
+  function formatRequestBody(body) {
+    if (!body) return null;
+    
+    try {
+      if (typeof body === 'string') {
+        return body.substring(0, MAX_BODY_SIZE);
+      }
+      if (body instanceof FormData) {
+        var formDataObj = {};
+        body.forEach(function(value, key) {
+          if (value instanceof File) {
+            formDataObj[key] = '[File: ' + value.name + ', size: ' + value.size + ']';
+          } else {
+            formDataObj[key] = String(value).substring(0, 1000);
+          }
+        });
+        return JSON.stringify(formDataObj);
+      }
+      if (body instanceof Blob) {
+        return '[Blob: size=' + body.size + ', type=' + body.type + ']';
+      }
+      if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+        return '[Binary: size=' + body.byteLength + ']';
+      }
+      if (body instanceof URLSearchParams) {
+        return body.toString().substring(0, MAX_BODY_SIZE);
+      }
+      return String(body).substring(0, MAX_BODY_SIZE);
+    } catch (e) {
+      return '[Error reading body: ' + e.message + ']';
+    }
+  }
+  
+  function formatResponseBody(response, responseType) {
+    if (!response) return null;
+    
+    try {
+      if (responseType === '' || responseType === 'text') {
+        return String(response).substring(0, MAX_BODY_SIZE);
+      }
+      if (responseType === 'json') {
+        return JSON.stringify(response).substring(0, MAX_BODY_SIZE);
+      }
+      if (responseType === 'document') {
+        return '[Document]';
+      }
+      if (responseType === 'blob') {
+        return '[Blob: size=' + response.size + ']';
+      }
+      if (responseType === 'arraybuffer') {
+        return '[ArrayBuffer: size=' + response.byteLength + ']';
+      }
+      return String(response).substring(0, MAX_BODY_SIZE);
+    } catch (e) {
+      return '[Error reading response: ' + e.message + ']';
+    }
+  }
+  
+  // Intercept XMLHttpRequest
+  var originalXHROpen = XMLHttpRequest.prototype.open;
+  var originalXHRSend = XMLHttpRequest.prototype.send;
+  var originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+  
+  XMLHttpRequest.prototype.open = function(method, url, async, user, password) {
+    this.__requestInfo__ = {
+      method: method,
+      url: url,
+      startTime: null,
+      headers: {}
+    };
+    return originalXHROpen.apply(this, arguments);
+  };
+  
+  XMLHttpRequest.prototype.setRequestHeader = function(name, value) {
+    if (this.__requestInfo__ && this.__requestInfo__.headers) {
+      this.__requestInfo__.headers[name] = value;
+    }
+    return originalXHRSetRequestHeader.apply(this, arguments);
+  };
+  
+  XMLHttpRequest.prototype.send = function(body) {
+    var xhr = this;
+    var requestInfo = xhr.__requestInfo__;
+    
+    if (requestInfo) {
+      // Skip SSE requests and filtered requests
+      if (isSSERequest(requestInfo.url, requestInfo.headers) || shouldFilterRequest(requestInfo.url)) {
+        return originalXHRSend.apply(this, arguments);
+      }
+      
+      requestInfo.startTime = Date.now();
+      requestInfo.requestBody = formatRequestBody(body);
+      
+      xhr.addEventListener('loadend', function() {
+        var contentType = xhr.getResponseHeader('Content-Type') || '';
+        if (contentType.indexOf('text/event-stream') !== -1) {
+          return;
+        }
+        
+        var responseHeaders = {};
+        var allHeaders = xhr.getAllResponseHeaders();
+        if (allHeaders) {
+          allHeaders.split('\\r\\n').forEach(function(line) {
+            var parts = line.split(': ');
+            if (parts.length === 2) {
+              responseHeaders[parts[0]] = parts[1];
+            }
+          });
+        }
+        
+        var entry = {
+          type: 'request',
+          timestamp: new Date().toISOString(),
+          requestType: 'xhr',
+          method: requestInfo.method,
+          url: requestInfo.url,
+          status: xhr.status,
+          statusText: xhr.statusText,
+          duration: Date.now() - requestInfo.startTime,
+          requestHeaders: truncateHeaders(requestInfo.headers),
+          requestBody: requestInfo.requestBody,
+          responseHeaders: truncateHeaders(responseHeaders),
+          responseType: xhr.responseType,
+          responseBody: formatResponseBody(xhr.response, xhr.responseType),
+          responseSize: xhr.response ? (typeof xhr.response === 'string' ? xhr.response.length : (xhr.response.byteLength || xhr.response.size || null)) : null
+        };
+        
+        addLog(entry);
+      });
+    }
+    
+    return originalXHRSend.apply(this, arguments);
+  };
+  
+  // Intercept Fetch API
+  var originalFetch = window.fetch;
+  
+  function headersToObject(headers) {
+    var obj = {};
+    if (!headers) return obj;
+    
+    if (typeof headers.forEach === 'function') {
+      headers.forEach(function(value, key) {
+        obj[key] = value;
+      });
+    } else if (typeof headers === 'object') {
+      for (var key in headers) {
+        obj[key] = headers[key];
+      }
+    }
+    return obj;
+  }
+  
+  window.fetch = function(input, init) {
+    var startTime = Date.now();
+    var method = (init && init.method) || 'GET';
+    var url = typeof input === 'string' ? input : input.url;
+    var headers = init && init.headers;
+    
+    // Skip SSE requests and filtered requests
+    if (isSSERequest(url, headers) || shouldFilterRequest(url)) {
+      return originalFetch.apply(this, arguments);
+    }
+    
+    var requestHeaders = headersToObject(headers);
+    var requestBody = formatRequestBody(init && init.body);
+    
+    return originalFetch.apply(this, arguments)
+      .then(function(response) {
+        var contentType = response.headers.get('Content-Type') || '';
+        if (contentType.indexOf('text/event-stream') !== -1) {
+          return response;
+        }
+        
+        var clonedResponse = response.clone();
+        var responseHeaders = headersToObject(response.headers);
+        
+        clonedResponse.text().then(function(bodyText) {
+          var entry = {
+            type: 'request',
+            timestamp: new Date().toISOString(),
+            requestType: 'fetch',
+            method: method,
+            url: url,
+            status: response.status,
+            statusText: response.statusText,
+            duration: Date.now() - startTime,
+            requestHeaders: truncateHeaders(requestHeaders),
+            requestBody: requestBody,
+            responseHeaders: truncateHeaders(responseHeaders),
+            responseBody: bodyText ? bodyText.substring(0, MAX_BODY_SIZE) : null,
+            responseSize: bodyText ? bodyText.length : null,
+            ok: response.ok
+          };
+          
+          addLog(entry);
+        }).catch(function(e) {
+          var entry = {
+            type: 'request',
+            timestamp: new Date().toISOString(),
+            requestType: 'fetch',
+            method: method,
+            url: url,
+            status: response.status,
+            statusText: response.statusText,
+            duration: Date.now() - startTime,
+            requestHeaders: truncateHeaders(requestHeaders),
+            requestBody: requestBody,
+            responseHeaders: truncateHeaders(responseHeaders),
+            responseBody: '[Unable to read: ' + e.message + ']',
+            responseSize: null,
+            ok: response.ok
+          };
+          
+          addLog(entry);
+        });
+        
+        return response;
+      })
+      .catch(function(error) {
+        var entry = {
+          type: 'request',
+          timestamp: new Date().toISOString(),
+          requestType: 'fetch',
+          method: method,
+          url: url,
+          status: 0,
+          statusText: 'Network Error',
+          duration: Date.now() - startTime,
+          requestHeaders: truncateHeaders(requestHeaders),
+          requestBody: requestBody,
+          responseHeaders: null,
+          responseBody: null,
+          error: error.message
+        };
+        
+        addLog(entry);
+        throw error;
+      });
+  };
+  
+  // ============================================
+  // Global error capture
+  // ============================================
+  window.addEventListener('error', function(event) {
+    var entry = {
+      type: 'error',
+      timestamp: new Date().toISOString(),
+      level: 'error',
+      message: event.message,
+      stack: event.error ? event.error.stack : 'at ' + event.filename + ':' + event.lineno + ':' + event.colno
+    };
+    addLog(entry);
+  });
+  
+  window.addEventListener('unhandledrejection', function(event) {
+    var entry = {
+      type: 'error',
+      timestamp: new Date().toISOString(),
+      level: 'error',
+      message: 'Unhandled Promise Rejection: ' + (event.reason ? (event.reason.message || String(event.reason)) : 'Unknown'),
+      stack: event.reason && event.reason.stack ? event.reason.stack : ''
+    };
+    addLog(entry);
+  });
+  
+  // ============================================
+  // Send remaining logs on page unload
+  // ============================================
+  window.addEventListener('beforeunload', function() {
+    if (writeQueue.length > 0) {
+      // Use sendBeacon to ensure logs are sent
+      writeQueue.forEach(function(entry) {
+        navigator.sendBeacon(LOG_API_PATH, JSON.stringify(entry));
+      });
+      writeQueue = [];
+    }
+  });
+  
+  // ============================================
+  // Provide manual flush method
+  // ============================================
+  window.__flushBrowserLogs__ = function() {
+    return new Promise(function(resolve) {
+      // Wait for queue to finish processing
+      function checkQueue() {
+        if (writeQueue.length === 0 && !isWriting) {
+          resolve();
+        } else {
+          setTimeout(checkQueue, 100);
+        }
+      }
+      checkQueue();
+    });
+  };
+  
+  // Provide method to get queue status
+  window.__getBrowserLogsStatus__ = function() {
+    return {
+      queueLength: writeQueue.length,
+      isWriting: isWriting
+    };
+  };
+  
+  originalConsole.log('[BrowserLogs] Log collection started');
+})();
+</script>`;
+  return {
+    name: "vite-plugin-browser-logs",
+    configResolved(config) {
+      const root = config.root || process.cwd();
+      logFilePath = path.join(root, "browser.log");
+    },
+    configureServer(devServer) {
+      devServer.middlewares.use((req, res, next) => {
+        if (req.url === "/__browser__" && req.method === "POST") {
+          const origin = req.headers.origin || "*";
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const logDir = path.dirname(logFilePath);
+              if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+              }
+              fs.appendFileSync(logFilePath, `${body}
+`, "utf-8");
+              res.writeHead(200, {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": origin,
+                "Access-Control-Allow-Methods": "POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type"
+              });
+              res.end(JSON.stringify({ success: true }));
+            } catch (error) {
+              console.error("[BrowserLogs] Write error:", error);
+              res.writeHead(500, {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Origin": origin,
+                "Access-Control-Allow-Methods": "POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type"
+              });
+              res.end(JSON.stringify({ success: false, error: String(error) }));
+            }
+          });
+        } else if (req.url === "/__browser__" && req.method === "OPTIONS") {
+          const origin = req.headers.origin || "*";
+          res.writeHead(204, {
+            "Access-Control-Allow-Origin": origin,
+            "Access-Control-Allow-Methods": "POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type",
+            "Access-Control-Max-Age": "86400"
+          });
+          res.end();
+        } else if (req.url === "/__browser__") {
+          const origin = req.headers.origin || "*";
+          res.writeHead(405, {
+            "Content-Type": "application/json",
+            "Access-Control-Allow-Origin": origin
+          });
+          res.end(JSON.stringify({ error: "Method not allowed" }));
+        } else {
+          next();
+        }
+      });
+      console.log("[BrowserLogs] Logs will be written to:", logFilePath);
+    },
+    transformIndexHtml(html) {
+      return html.replace(/<head([^>]*)>/i, `<head$1>${injectedScript}`);
+    }
+  };
+}
+function generateUniqueId(filePath, position) {
+  const key = `${filePath}:${position}`;
+  return createHash("md5").update(key).digest("hex").substring(0, 12);
+}
+var HTML_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rp",
+  "rt",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+]);
+function componentIdPlugin() {
+  let isDev = false;
+  return {
+    name: "vite-plugin-component-id",
+    enforce: "pre",
+    configResolved(config) {
+      isDev = config.command === "serve";
+    },
+    transform(code, id) {
+      if (!isDev) {
+        return null;
+      }
+      if (!/\.(tsx|jsx)$/.test(id)) {
+        return null;
+      }
+      if (id.includes("node_modules")) {
+        return null;
+      }
+      if (!/<[a-z]/.test(code)) {
+        return null;
+      }
+      try {
+        let transformedCode = code;
+        const jsxOpenTagRegex = /<([a-z][\da-z]*)(?=[\s/>])/g;
+        let match;
+        const matches = [];
+        while ((match = jsxOpenTagRegex.exec(code)) !== null) {
+          const tag = match[1];
+          if (!tag) continue;
+          const tagStartIndex = match.index;
+          const tagEndIndex = match.index + match[0].length;
+          if (!HTML_TAGS.has(tag)) {
+            continue;
+          }
+          let checkIndex = tagEndIndex;
+          let foundClosing = false;
+          let hasComponentId = false;
+          while (checkIndex < code.length && !foundClosing) {
+            const char = code[checkIndex];
+            if (char === ">") {
+              foundClosing = true;
+              const tagContent = code.substring(tagStartIndex, checkIndex);
+              if (tagContent.includes("data-node-component-id")) {
+                hasComponentId = true;
+              }
+            }
+            checkIndex++;
+          }
+          if (hasComponentId) {
+            continue;
+          }
+          matches.push({
+            index: tagStartIndex,
+            tag,
+            tagEndIndex
+          });
+        }
+        let currentCode = code;
+        for (let i = matches.length - 1; i >= 0; i--) {
+          const item = matches[i];
+          if (!item) continue;
+          const { index, tagEndIndex } = item;
+          const uniqueId = generateUniqueId(id, index);
+          const before = currentCode.substring(0, tagEndIndex);
+          const after = currentCode.substring(tagEndIndex);
+          transformedCode = `${before} data-node-component-id="${uniqueId}"${after}`;
+          currentCode = transformedCode;
+        }
+        return {
+          code: transformedCode,
+          map: null
+        };
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// src/editor-bridge.ts
+var clickHandlerScript = `<script>
+document.addEventListener("click", (e) => {
+  const element = e.target;
+  const noJumpOut = document.body.classList.contains("forbid-jump-out")
+  if (element.hasAttribute("data-link-href") && !noJumpOut) {
+    const href = element.getAttribute("data-link-href");
+    const target = element.getAttribute("data-link-target");
+    if (href) {
+      if (target === "_blank") {
+        window.open(href, "_blank");
+      } else {
+        window.location.href = href;
+      }
+    }
+  } else if(noJumpOut && element.tagName === "A") {
+    e.preventDefault();
+  }
+});
+</script>`;
+function editorBridgePlugin(options) {
+  let isDev = false;
+  const bridgePath = options?.bridgeScriptPath || "/scripts/bridge.js";
+  return {
+    name: "vite-plugin-editor-bridge",
+    configResolved(config) {
+      isDev = config.command === "serve";
+    },
+    transformIndexHtml(html) {
+      const devScript = isDev ? `<script type="module" src="${bridgePath}"></script>` : "";
+      const scriptsToInject = `${clickHandlerScript + devScript}</body>`;
+      return html.replace("</body>", scriptsToInject);
+    }
+  };
+}
+
+// src/routes-expose.ts
+function routesExposePlugin(options) {
+  let isDev = false;
+  const routesPath = options?.routesFilePath || "src/routes.tsx";
+  return {
+    name: "vite-plugin-routes-expose",
+    enforce: "post",
+    configResolved(config) {
+      isDev = config.command === "serve";
+    },
+    transform(code, id) {
+      if (!isDev) {
+        return null;
+      }
+      if (!id.endsWith(routesPath)) {
+        return null;
+      }
+      try {
+        if (code.includes("window.__APP_ROUTES__")) {
+          return null;
+        }
+        const transformedCode = `${code}
+
+// Development mode: Expose routes to window.__APP_ROUTES__
+if (typeof window !== 'undefined') {
+  window.__APP_ROUTES__ = typeof routes !== 'undefined' && Array.isArray(routes) ? routes : [];
+}
+`;
+        return {
+          code: transformedCode,
+          map: null
+        };
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+export { browserLogsPlugin, componentIdPlugin, editorBridgePlugin, routesExposePlugin };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map