uilint-react 0.2.0 → 0.2.3

package/dist/chunk-552GIJIQ.js

@@ -1,1109 +0,0 @@
-"use client";
-
-// src/components/ui-lint/dom-utils.ts
-var DATA_ATTR = "data-ui-lint-id";
-var COLORS = [
-  "#3B82F6",
-  "#8B5CF6",
-  "#EC4899",
-  "#10B981",
-  "#F59E0B",
-  "#06B6D4",
-  "#EF4444",
-  "#84CC16",
-  "#6366F1",
-  "#F97316",
-  "#14B8A6",
-  "#A855F7"
-];
-var SKIP_TAGS = /* @__PURE__ */ new Set([
-  "SCRIPT",
-  "STYLE",
-  "SVG",
-  "NOSCRIPT",
-  "TEMPLATE",
-  "HEAD",
-  "META",
-  "LINK"
-]);
-var elementCounter = 0;
-function getSourceFromDataLoc(element) {
-  const loc = element.getAttribute("data-loc");
-  if (!loc) return null;
-  const parts = loc.split(":");
-  if (parts.length < 2) return null;
-  const lastPart = parts[parts.length - 1];
-  const secondLastPart = parts[parts.length - 2];
-  const lastIsNumber = /^\d+$/.test(lastPart);
-  const secondLastIsNumber = /^\d+$/.test(secondLastPart);
-  if (lastIsNumber && secondLastIsNumber) {
-    const columnNumber = parseInt(lastPart, 10);
-    const lineNumber = parseInt(secondLastPart, 10);
-    const fileName = parts.slice(0, -2).join(":");
-    if (isNaN(lineNumber) || isNaN(columnNumber) || !fileName) return null;
-    return { fileName, lineNumber, columnNumber };
-  } else if (lastIsNumber) {
-    const lineNumber = parseInt(lastPart, 10);
-    const fileName = parts.slice(0, -1).join(":");
-    if (isNaN(lineNumber) || !fileName) return null;
-    return { fileName, lineNumber };
-  }
-  return null;
-}
-function isNodeModulesPath(path) {
-  return path.includes("node_modules");
-}
-function getDisplayName(path) {
-  const parts = path.split("/");
-  return parts[parts.length - 1] || path;
-}
-function shouldSkipElement(element) {
-  if (SKIP_TAGS.has(element.tagName.toUpperCase())) return true;
-  if (element.hasAttribute("data-ui-lint")) return true;
-  if (element.getAttribute("aria-hidden") === "true") return true;
-  const styles = window.getComputedStyle(element);
-  if (styles.display === "none" || styles.visibility === "hidden") return true;
-  const rect = element.getBoundingClientRect();
-  if (rect.width === 0 || rect.height === 0) return true;
-  return false;
-}
-function scanDOMForSources(root = document.body, hideNodeModules = true) {
-  const elements = [];
-  elementCounter = 0;
-  const occurrenceByDataLoc = /* @__PURE__ */ new Map();
-  cleanupDataAttributes();
-  const locElements = root.querySelectorAll("[data-loc]");
-  for (const el of locElements) {
-    if (shouldSkipElement(el)) continue;
-    const source = getSourceFromDataLoc(el);
-    if (!source) continue;
-    if (hideNodeModules && isNodeModulesPath(source.fileName)) {
-      continue;
-    }
-    const dataLoc = el.getAttribute("data-loc");
-    const occurrence = (occurrenceByDataLoc.get(dataLoc) ?? 0) + 1;
-    occurrenceByDataLoc.set(dataLoc, occurrence);
-    const id = `loc:${dataLoc}#${occurrence}`;
-    el.setAttribute(DATA_ATTR, id);
-    elements.push({
-      id,
-      element: el,
-      tagName: el.tagName.toLowerCase(),
-      className: typeof el.className === "string" ? el.className : "",
-      source,
-      rect: el.getBoundingClientRect()
-    });
-  }
-  return elements;
-}
-function groupBySourceFile(elements) {
-  const fileMap = /* @__PURE__ */ new Map();
-  for (const element of elements) {
-    if (!element.source) continue;
-    const path = element.source.fileName;
-    const existing = fileMap.get(path) || [];
-    existing.push(element);
-    fileMap.set(path, existing);
-  }
-  const sourceFiles = [];
-  let colorIndex = 0;
-  for (const [path, fileElements] of fileMap) {
-    sourceFiles.push({
-      path,
-      displayName: getDisplayName(path),
-      color: COLORS[colorIndex % COLORS.length],
-      elements: fileElements
-    });
-    colorIndex++;
-  }
-  sourceFiles.sort((a, b) => b.elements.length - a.elements.length);
-  return sourceFiles;
-}
-function cleanupDataAttributes() {
-  const elements = document.querySelectorAll(`[${DATA_ATTR}]`);
-  elements.forEach((el) => el.removeAttribute(DATA_ATTR));
-  elementCounter = 0;
-}
-function getElementById(id) {
-  return document.querySelector(`[${DATA_ATTR}="${id}"]`);
-}
-function updateElementRects(elements) {
-  return elements.map((el) => ({
-    ...el,
-    rect: el.element.getBoundingClientRect()
-  }));
-}
-function buildEditorUrl(source, editor = "cursor", workspaceRoot) {
-  const { fileName, lineNumber, columnNumber } = source;
-  const column = columnNumber ?? 1;
-  let absolutePath = fileName;
-  if (workspaceRoot && !fileName.startsWith("/")) {
-    const root = workspaceRoot.endsWith("/") ? workspaceRoot.slice(0, -1) : workspaceRoot;
-    absolutePath = `${root}/${fileName}`;
-  }
-  if (editor === "cursor") {
-    return `cursor://file/${encodeURIComponent(
-      absolutePath
-    )}:${lineNumber}:${column}`;
-  }
-  return `vscode://file/${encodeURIComponent(
-    absolutePath
-  )}:${lineNumber}:${column}`;
-}
-
-// src/components/ui-lint/types.ts
-var FILE_COLORS = [
-  "#3B82F6",
-  // blue
-  "#8B5CF6",
-  // violet
-  "#EC4899",
-  // pink
-  "#10B981",
-  // emerald
-  "#F59E0B",
-  // amber
-  "#06B6D4",
-  // cyan
-  "#EF4444",
-  // red
-  "#84CC16",
-  // lime
-  "#6366F1",
-  // indigo
-  "#F97316",
-  // orange
-  "#14B8A6",
-  // teal
-  "#A855F7"
-  // purple
-];
-var DEFAULT_SETTINGS = {
-  hideNodeModules: true,
-  autoScanEnabled: false
-};
-var DEFAULT_AUTO_SCAN_STATE = {
-  status: "idle",
-  currentIndex: 0,
-  totalElements: 0,
-  elements: []
-};
-var DATA_UILINT_ID = "data-ui-lint-id";
-
-// src/components/ui-lint/store.ts
-import { create } from "zustand";
-function getDataLocFromId(id) {
-  if (id.startsWith("loc:")) {
-    const raw = id.slice(4);
-    return raw.split("#")[0] || null;
-  }
-  return null;
-}
-async function scanFileForIssues(sourceFile, store) {
-  if (sourceFile.elements.length === 0) {
-    return { issues: [] };
-  }
-  const filePath = sourceFile.path;
-  let issues = [];
-  if (store.wsConnected && store.wsConnection) {
-    try {
-      issues = await store.requestFileLint(filePath);
-      console.log("[UILint] ESLint issues:", issues);
-    } catch (err) {
-      console.warn("[UILint] WebSocket lint failed:", err);
-      return { issues: [], error: true };
-    }
-  } else {
-    console.warn("[UILint] WebSocket not connected");
-    return { issues: [], error: true };
-  }
-  return { issues };
-}
-function distributeIssuesToElements(issues, elements, filePath, updateElementIssue, updateFileIssues, hasError) {
-  const dataLocToElementIds = /* @__PURE__ */ new Map();
-  for (const el of elements) {
-    const dataLoc = getDataLocFromId(el.id);
-    if (dataLoc) {
-      const existing = dataLocToElementIds.get(dataLoc);
-      if (existing) existing.push(el.id);
-      else dataLocToElementIds.set(dataLoc, [el.id]);
-    }
-  }
-  const issuesByElement = /* @__PURE__ */ new Map();
-  const unmappedIssues = [];
-  for (const issue of issues) {
-    if (issue.dataLoc) {
-      const elementIds = dataLocToElementIds.get(issue.dataLoc);
-      if (elementIds && elementIds.length > 0) {
-        for (const elementId of elementIds) {
-          const existing = issuesByElement.get(elementId) || [];
-          existing.push(issue);
-          issuesByElement.set(elementId, existing);
-        }
-      } else {
-        unmappedIssues.push(issue);
-      }
-    } else {
-      unmappedIssues.push(issue);
-    }
-  }
-  for (const el of elements) {
-    const elementIssues = issuesByElement.get(el.id) || [];
-    updateElementIssue(el.id, {
-      elementId: el.id,
-      issues: elementIssues,
-      status: hasError ? "error" : "complete"
-    });
-  }
-  if (unmappedIssues.length > 0) {
-    updateFileIssues(filePath, unmappedIssues);
-  } else {
-    updateFileIssues(filePath, []);
-  }
-}
-var DEFAULT_WS_URL = "ws://localhost:9234";
-var MAX_RECONNECT_ATTEMPTS = 5;
-var RECONNECT_BASE_DELAY = 1e3;
-var pendingRequests = /* @__PURE__ */ new Map();
-var WS_REQUEST_TIMEOUT_MS = 12e4;
-function makeRequestId() {
-  try {
-    const c = globalThis.crypto;
-    if (c?.randomUUID) return c.randomUUID();
-  } catch {
-  }
-  return `req_${Date.now()}_${Math.random().toString(16).slice(2)}`;
-}
-var useUILintStore = create()((set, get) => ({
-  // ============ Settings ============
-  settings: DEFAULT_SETTINGS,
-  updateSettings: (partial) => set((state) => ({
-    settings: { ...state.settings, ...partial }
-  })),
-  // ============ Locator Mode ============
-  altKeyHeld: false,
-  setAltKeyHeld: (held) => set({ altKeyHeld: held }),
-  locatorTarget: null,
-  setLocatorTarget: (target) => set({ locatorTarget: target }),
-  // ============ Inspection ============
-  inspectedElement: null,
-  setInspectedElement: (el) => set({ inspectedElement: el }),
-  // ============ Live Scanning ============
-  liveScanEnabled: false,
-  autoScanState: DEFAULT_AUTO_SCAN_STATE,
-  elementIssuesCache: /* @__PURE__ */ new Map(),
-  fileIssuesCache: /* @__PURE__ */ new Map(),
-  scanLock: false,
-  _setScanState: (partial) => set((state) => ({
-    autoScanState: { ...state.autoScanState, ...partial }
-  })),
-  updateElementIssue: (id, issue) => set((state) => {
-    const newCache = new Map(state.elementIssuesCache);
-    newCache.set(id, issue);
-    return { elementIssuesCache: newCache };
-  }),
-  updateFileIssues: (filePath, issues) => set((state) => {
-    const newCache = new Map(state.fileIssuesCache);
-    if (issues.length > 0) {
-      newCache.set(filePath, issues);
-    } else {
-      newCache.delete(filePath);
-    }
-    return { fileIssuesCache: newCache };
-  }),
-  enableLiveScan: async (hideNodeModules) => {
-    const state = get();
-    if (state.scanLock) {
-      console.warn("UILint: Scan already in progress");
-      return;
-    }
-    set({
-      liveScanEnabled: true,
-      scanLock: true
-    });
-    const elements = scanDOMForSources(document.body, hideNodeModules);
-    const initialCache = /* @__PURE__ */ new Map();
-    for (const el of elements) {
-      initialCache.set(el.id, {
-        elementId: el.id,
-        issues: [],
-        status: "pending"
-      });
-    }
-    set({
-      elementIssuesCache: initialCache,
-      autoScanState: {
-        status: "scanning",
-        currentIndex: 0,
-        totalElements: elements.length,
-        elements
-      }
-    });
-    await get()._runScanLoop(elements);
-  },
-  disableLiveScan: () => {
-    set({
-      liveScanEnabled: false,
-      scanLock: false,
-      autoScanState: DEFAULT_AUTO_SCAN_STATE,
-      elementIssuesCache: /* @__PURE__ */ new Map(),
-      fileIssuesCache: /* @__PURE__ */ new Map()
-    });
-  },
-  scanNewElements: async (newElements) => {
-    const state = get();
-    if (!state.liveScanEnabled) return;
-    if (newElements.length === 0) return;
-    set((s) => {
-      const newCache = new Map(s.elementIssuesCache);
-      for (const el of newElements) {
-        newCache.set(el.id, {
-          elementId: el.id,
-          issues: [],
-          status: "pending"
-        });
-      }
-      return {
-        elementIssuesCache: newCache,
-        autoScanState: {
-          ...s.autoScanState,
-          elements: [...s.autoScanState.elements, ...newElements],
-          totalElements: s.autoScanState.totalElements + newElements.length
-        }
-      };
-    });
-    const sourceFiles = groupBySourceFile(newElements);
-    for (const sourceFile of sourceFiles) {
-      for (const el of sourceFile.elements) {
-        get().updateElementIssue(el.id, {
-          elementId: el.id,
-          issues: [],
-          status: "scanning"
-        });
-      }
-      await new Promise((resolve) => requestAnimationFrame(resolve));
-      const { issues, error } = await scanFileForIssues(sourceFile, get());
-      distributeIssuesToElements(
-        issues,
-        sourceFile.elements,
-        sourceFile.path,
-        get().updateElementIssue,
-        get().updateFileIssues,
-        error ?? false
-      );
-      if (get().wsConnected && get().wsConnection) {
-        get().subscribeToFile(sourceFile.path);
-      }
-      await new Promise((resolve) => requestAnimationFrame(resolve));
-    }
-  },
-  _runScanLoop: async (elements) => {
-    const sourceFiles = groupBySourceFile(elements);
-    let processedElements = 0;
-    for (const sourceFile of sourceFiles) {
-      if (!get().liveScanEnabled) {
-        set({
-          scanLock: false,
-          autoScanState: DEFAULT_AUTO_SCAN_STATE
-        });
-        return;
-      }
-      get()._setScanState({ currentIndex: processedElements });
-      for (const el of sourceFile.elements) {
-        get().updateElementIssue(el.id, {
-          elementId: el.id,
-          issues: [],
-          status: "scanning"
-        });
-      }
-      await new Promise((resolve) => requestAnimationFrame(resolve));
-      const { issues, error } = await scanFileForIssues(sourceFile, get());
-      distributeIssuesToElements(
-        issues,
-        sourceFile.elements,
-        sourceFile.path,
-        get().updateElementIssue,
-        get().updateFileIssues,
-        error ?? false
-      );
-      if (get().wsConnected && get().wsConnection) {
-        get().subscribeToFile(sourceFile.path);
-      }
-      processedElements += sourceFile.elements.length;
-      await new Promise((resolve) => requestAnimationFrame(resolve));
-    }
-    set({
-      scanLock: false,
-      autoScanState: {
-        ...get().autoScanState,
-        status: "complete",
-        currentIndex: elements.length
-      }
-    });
-  },
-  // ============ DOM Observer ============
-  removeStaleResults: (elementIds) => set((state) => {
-    const newCache = new Map(state.elementIssuesCache);
-    const newElements = state.autoScanState.elements.filter(
-      (el) => !elementIds.includes(el.id)
-    );
-    for (const id of elementIds) {
-      newCache.delete(id);
-    }
-    return {
-      elementIssuesCache: newCache,
-      autoScanState: {
-        ...state.autoScanState,
-        elements: newElements,
-        totalElements: newElements.length
-      }
-    };
-  }),
-  // ============ File/Element Selection ============
-  hoveredFilePath: null,
-  selectedFilePath: null,
-  selectedElementId: null,
-  hoveredElementId: null,
-  setHoveredFilePath: (path) => set({ hoveredFilePath: path }),
-  setSelectedFilePath: (path) => set({ selectedFilePath: path }),
-  setSelectedElementId: (id) => set({ selectedElementId: id }),
-  setHoveredElementId: (id) => set({ hoveredElementId: id }),
-  // ============ WebSocket ============
-  wsConnection: null,
-  wsConnected: false,
-  wsUrl: DEFAULT_WS_URL,
-  wsReconnectAttempts: 0,
-  eslintIssuesCache: /* @__PURE__ */ new Map(),
-  wsProgressPhase: /* @__PURE__ */ new Map(),
-  wsLastActivity: null,
-  wsRecentResults: [],
-  workspaceRoot: null,
-  appRoot: null,
-  serverCwd: null,
-  connectWebSocket: (url) => {
-    const targetUrl = url || get().wsUrl;
-    const existing = get().wsConnection;
-    if (existing && existing.readyState !== WebSocket.CLOSED) {
-      existing.close();
-    }
-    if (typeof WebSocket === "undefined") {
-      console.warn("[UILint] WebSocket not available in this environment");
-      return;
-    }
-    try {
-      const ws = new WebSocket(targetUrl);
-      ws.onopen = () => {
-        console.log("[UILint] WebSocket connected to", targetUrl);
-        set({
-          wsConnected: true,
-          wsReconnectAttempts: 0,
-          wsUrl: targetUrl
-        });
-      };
-      ws.onclose = () => {
-        console.log("[UILint] WebSocket disconnected");
-        set({ wsConnected: false, wsConnection: null });
-        const attempts = get().wsReconnectAttempts;
-        if (attempts < MAX_RECONNECT_ATTEMPTS) {
-          const delay = RECONNECT_BASE_DELAY * Math.pow(2, attempts);
-          console.log(
-            `[UILint] Reconnecting in ${delay}ms (attempt ${attempts + 1})`
-          );
-          setTimeout(() => {
-            set({ wsReconnectAttempts: attempts + 1 });
-            get()._reconnectWebSocket();
-          }, delay);
-        }
-      };
-      ws.onerror = (error) => {
-        console.error("[UILint] WebSocket error:", error);
-      };
-      ws.onmessage = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-          get()._handleWsMessage(data);
-        } catch (err) {
-          console.error("[UILint] Failed to parse WebSocket message:", err);
-        }
-      };
-      set({ wsConnection: ws, wsUrl: targetUrl });
-    } catch (err) {
-      console.error("[UILint] Failed to create WebSocket:", err);
-    }
-  },
-  disconnectWebSocket: () => {
-    const ws = get().wsConnection;
-    if (ws) {
-      ws.close();
-      set({
-        wsConnection: null,
-        wsConnected: false,
-        wsReconnectAttempts: MAX_RECONNECT_ATTEMPTS
-      });
-    }
-  },
-  requestFileLint: async (filePath) => {
-    const { wsConnection, wsConnected, eslintIssuesCache } = get();
-    const cached = eslintIssuesCache.get(filePath);
-    if (cached) {
-      console.log("[UILint] using cached issues for", filePath);
-      return cached;
-    }
-    if (!wsConnected || !wsConnection) {
-      console.log("[UILint] WebSocket not connected, using HTTP fallback");
-      return [];
-    }
-    return new Promise((resolve, reject) => {
-      const requestId = makeRequestId();
-      pendingRequests.set(requestId, { resolve, reject });
-      const message = {
-        type: "lint:file",
-        filePath,
-        requestId
-      };
-      wsConnection.send(JSON.stringify(message));
-      setTimeout(() => {
-        if (pendingRequests.has(requestId)) {
-          pendingRequests.delete(requestId);
-          reject(new Error("Request timed out"));
-        }
-      }, WS_REQUEST_TIMEOUT_MS);
-    });
-  },
-  requestElementLint: async (filePath, dataLoc) => {
-    const { wsConnection, wsConnected } = get();
-    if (!wsConnected || !wsConnection) {
-      console.log("[UILint] WebSocket not connected, using HTTP fallback");
-      return [];
-    }
-    return new Promise((resolve, reject) => {
-      const requestId = makeRequestId();
-      pendingRequests.set(requestId, { resolve, reject });
-      const message = {
-        type: "lint:element",
-        filePath,
-        dataLoc,
-        requestId
-      };
-      wsConnection.send(JSON.stringify(message));
-      setTimeout(() => {
-        if (pendingRequests.has(requestId)) {
-          pendingRequests.delete(requestId);
-          reject(new Error("Request timed out"));
-        }
-      }, WS_REQUEST_TIMEOUT_MS);
-    });
-  },
-  subscribeToFile: (filePath) => {
-    const { wsConnection, wsConnected } = get();
-    if (!wsConnected || !wsConnection) return;
-    const message = { type: "subscribe:file", filePath };
-    wsConnection.send(JSON.stringify(message));
-  },
-  invalidateCache: (filePath) => {
-    const { wsConnection, wsConnected } = get();
-    if (filePath) {
-      set((state) => {
-        const next = new Map(state.eslintIssuesCache);
-        next.delete(filePath);
-        return { eslintIssuesCache: next };
-      });
-    } else {
-      set({ eslintIssuesCache: /* @__PURE__ */ new Map() });
-    }
-    if (wsConnected && wsConnection) {
-      const message = {
-        type: "cache:invalidate",
-        filePath
-      };
-      wsConnection.send(JSON.stringify(message));
-    }
-  },
-  _handleWsMessage: (data) => {
-    switch (data.type) {
-      case "lint:result": {
-        const { filePath, issues, requestId } = data;
-        set((state2) => {
-          const next = new Map(state2.eslintIssuesCache);
-          next.set(filePath, issues);
-          return { eslintIssuesCache: next };
-        });
-        const state = get();
-        if (state.liveScanEnabled) {
-          const sourceFiles = groupBySourceFile(state.autoScanState.elements);
-          const sf = sourceFiles.find((s) => s.path === filePath);
-          if (sf) {
-            distributeIssuesToElements(
-              issues,
-              sf.elements,
-              filePath,
-              state.updateElementIssue,
-              state.updateFileIssues,
-              false
-            );
-          } else {
-            const unmappedIssues = issues.filter((i) => !i.dataLoc);
-            if (unmappedIssues.length > 0) {
-              state.updateFileIssues(filePath, unmappedIssues);
-            }
-          }
-        }
-        set((state2) => {
-          const next = new Map(state2.wsProgressPhase);
-          next.delete(filePath);
-          return { wsProgressPhase: next };
-        });
-        set((state2) => {
-          const next = [
-            { filePath, issueCount: issues.length, updatedAt: Date.now() },
-            ...state2.wsRecentResults.filter((r) => r.filePath !== filePath)
-          ].slice(0, 8);
-          return { wsRecentResults: next };
-        });
-        set({
-          wsLastActivity: {
-            filePath,
-            phase: `Done (${issues.length} issues)`,
-            updatedAt: Date.now()
-          }
-        });
-        if (requestId) {
-          const pending = pendingRequests.get(requestId);
-          if (pending) {
-            pending.resolve(issues);
-            pendingRequests.delete(requestId);
-          }
-        }
-        break;
-      }
-      case "lint:progress": {
-        const { filePath, phase } = data;
-        set((state) => {
-          const next = new Map(state.wsProgressPhase);
-          next.set(filePath, phase);
-          return {
-            wsProgressPhase: next,
-            wsLastActivity: { filePath, phase, updatedAt: Date.now() }
-          };
-        });
-        break;
-      }
-      case "file:changed": {
-        const { filePath } = data;
-        set((state2) => {
-          const next = new Map(state2.eslintIssuesCache);
-          next.delete(filePath);
-          return { eslintIssuesCache: next };
-        });
-        const state = get();
-        if (state.liveScanEnabled) {
-          const sourceFiles = groupBySourceFile(state.autoScanState.elements);
-          const sf = sourceFiles.find((s) => s.path === filePath);
-          if (sf) {
-            for (const el of sf.elements) {
-              const existing = state.elementIssuesCache.get(el.id);
-              state.updateElementIssue(el.id, {
-                elementId: el.id,
-                issues: existing?.issues || [],
-                status: "scanning"
-              });
-            }
-            state.requestFileLint(filePath).catch(() => {
-              for (const el of sf.elements) {
-                const existing = state.elementIssuesCache.get(el.id);
-                state.updateElementIssue(el.id, {
-                  elementId: el.id,
-                  issues: existing?.issues || [],
-                  status: "error"
-                });
-              }
-            });
-          }
-        }
-        break;
-      }
-      case "workspace:info": {
-        const { appRoot, workspaceRoot, serverCwd } = data;
-        console.log("[UILint] Received workspace info:", {
-          appRoot,
-          workspaceRoot,
-          serverCwd
-        });
-        set({ appRoot, workspaceRoot, serverCwd });
-        break;
-      }
-    }
-  },
-  _reconnectWebSocket: () => {
-    const { wsUrl } = get();
-    get().connectWebSocket(wsUrl);
-  }
-}));
-
-// src/components/ui-lint/UILintProvider.tsx
-import {
-  createContext,
-  useContext,
-  useState,
-  useEffect as useEffect2,
-  useCallback as useCallback2,
-  useMemo
-} from "react";
-
-// src/components/ui-lint/useDOMObserver.ts
-import { useEffect, useRef, useCallback } from "react";
-var RECONCILE_DEBOUNCE_MS = 100;
-function useDOMObserver(enabled = true) {
-  const observerRef = useRef(null);
-  const reconcileTimeoutRef = useRef(
-    null
-  );
-  const knownElementIdsRef = useRef(/* @__PURE__ */ new Set());
-  const liveScanEnabled = useUILintStore((s) => s.liveScanEnabled);
-  const settings = useUILintStore((s) => s.settings);
-  const autoScanState = useUILintStore((s) => s.autoScanState);
-  const removeStaleResults = useUILintStore(
-    (s) => s.removeStaleResults
-  );
-  const scanNewElements = useUILintStore((s) => s.scanNewElements);
-  useEffect(() => {
-    if (autoScanState.elements.length > 0) {
-      const ids = new Set(autoScanState.elements.map((el) => el.id));
-      knownElementIdsRef.current = ids;
-    }
-  }, [autoScanState.elements]);
-  const reconcileElements = useCallback(() => {
-    if (!liveScanEnabled) return;
-    const currentElements = scanDOMForSources(
-      document.body,
-      settings.hideNodeModules
-    );
-    const currentIds = new Set(currentElements.map((el) => el.id));
-    const knownIds = knownElementIdsRef.current;
-    const newElements = [];
-    for (const el of currentElements) {
-      if (!knownIds.has(el.id)) {
-        newElements.push(el);
-      }
-    }
-    const removedElementIds = [];
-    for (const id of knownIds) {
-      if (!currentIds.has(id)) {
-        removedElementIds.push(id);
-      }
-    }
-    knownElementIdsRef.current = currentIds;
-    if (newElements.length > 0) {
-      scanNewElements(newElements);
-    }
-    if (removedElementIds.length > 0) {
-      removeStaleResults(removedElementIds);
-    }
-  }, [
-    liveScanEnabled,
-    settings.hideNodeModules,
-    scanNewElements,
-    removeStaleResults
-  ]);
-  const debouncedReconcile = useCallback(() => {
-    if (reconcileTimeoutRef.current) {
-      clearTimeout(reconcileTimeoutRef.current);
-    }
-    reconcileTimeoutRef.current = setTimeout(() => {
-      reconcileElements();
-      reconcileTimeoutRef.current = null;
-    }, RECONCILE_DEBOUNCE_MS);
-  }, [reconcileElements]);
-  useEffect(() => {
-    if (!enabled) return;
-    if (typeof window === "undefined") return;
-    const observer = new MutationObserver((mutations) => {
-      let hasRelevantChanges = false;
-      for (const mutation of mutations) {
-        for (const node of mutation.addedNodes) {
-          if (node instanceof Element) {
-            if (node.hasAttribute("data-loc")) {
-              hasRelevantChanges = true;
-              break;
-            }
-            if (node.querySelector("[data-loc]")) {
-              hasRelevantChanges = true;
-              break;
-            }
-          }
-        }
-        if (hasRelevantChanges) break;
-        for (const node of mutation.removedNodes) {
-          if (node instanceof Element) {
-            if (node.hasAttribute("data-loc") || node.querySelector("[data-loc]")) {
-              hasRelevantChanges = true;
-              break;
-            }
-          }
-        }
-        if (hasRelevantChanges) break;
-      }
-      if (hasRelevantChanges) {
-        debouncedReconcile();
-      }
-    });
-    observer.observe(document.body, {
-      childList: true,
-      subtree: true
-    });
-    observerRef.current = observer;
-    return () => {
-      observer.disconnect();
-      observerRef.current = null;
-      if (reconcileTimeoutRef.current) {
-        clearTimeout(reconcileTimeoutRef.current);
-        reconcileTimeoutRef.current = null;
-      }
-    };
-  }, [enabled, debouncedReconcile]);
-}
-
-// src/components/ui-lint/UILintProvider.tsx
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-var UILintContext = createContext(null);
-function useUILintContext() {
-  const context = useContext(UILintContext);
-  if (!context) {
-    throw new Error("useUILintContext must be used within a UILintProvider");
-  }
-  return context;
-}
-function isBrowser() {
-  return typeof window !== "undefined";
-}
-function UILintProvider({
-  children,
-  enabled = true
-}) {
-  const [isMounted, setIsMounted] = useState(false);
-  const settings = useUILintStore((s) => s.settings);
-  const updateSettings = useUILintStore((s) => s.updateSettings);
-  const altKeyHeld = useUILintStore((s) => s.altKeyHeld);
-  const setAltKeyHeld = useUILintStore((s) => s.setAltKeyHeld);
-  const locatorTarget = useUILintStore((s) => s.locatorTarget);
-  const setLocatorTarget = useUILintStore(
-    (s) => s.setLocatorTarget
-  );
-  const inspectedElement = useUILintStore(
-    (s) => s.inspectedElement
-  );
-  const setInspectedElement = useUILintStore(
-    (s) => s.setInspectedElement
-  );
-  const liveScanEnabled = useUILintStore((s) => s.liveScanEnabled);
-  const autoScanState = useUILintStore((s) => s.autoScanState);
-  const elementIssuesCache = useUILintStore(
-    (s) => s.elementIssuesCache
-  );
-  const storeEnableLiveScan = useUILintStore(
-    (s) => s.enableLiveScan
-  );
-  const disableLiveScan = useUILintStore((s) => s.disableLiveScan);
-  const connectWebSocket = useUILintStore(
-    (s) => s.connectWebSocket
-  );
-  const disconnectWebSocket = useUILintStore(
-    (s) => s.disconnectWebSocket
-  );
-  useDOMObserver(enabled && isMounted);
-  const getLocatorTargetFromElement = useCallback2(
-    (element) => {
-      if (element.closest("[data-ui-lint]")) return null;
-      const source = getSourceFromDataLoc(element);
-      if (!source) return null;
-      if (settings.hideNodeModules && isNodeModulesPath(source.fileName)) {
-        return null;
-      }
-      return {
-        element,
-        source,
-        rect: element.getBoundingClientRect()
-      };
-    },
-    [settings.hideNodeModules]
-  );
-  const handleMouseMove = useCallback2(
-    (e) => {
-      if (!altKeyHeld) return;
-      const elementAtPoint = document.elementFromPoint(e.clientX, e.clientY);
-      if (!elementAtPoint) {
-        setLocatorTarget(null);
-        return;
-      }
-      let current = elementAtPoint;
-      while (current) {
-        const target = getLocatorTargetFromElement(current);
-        if (target) {
-          setLocatorTarget(target);
-          return;
-        }
-        current = current.parentElement;
-      }
-      setLocatorTarget(null);
-    },
-    [altKeyHeld, getLocatorTargetFromElement, setLocatorTarget]
-  );
-  const handleLocatorClick = useCallback2(
-    (e) => {
-      if (!altKeyHeld || !locatorTarget) return;
-      const targetEl = e.target;
-      if (targetEl?.closest?.("[data-ui-lint]")) return;
-      e.preventDefault();
-      e.stopPropagation();
-      setInspectedElement({
-        element: locatorTarget.element,
-        source: locatorTarget.source,
-        rect: locatorTarget.rect
-      });
-      setLocatorTarget(null);
-    },
-    [altKeyHeld, locatorTarget, setInspectedElement, setLocatorTarget]
-  );
-  useEffect2(() => {
-    if (!isBrowser() || !enabled) return;
-    const handleKeyDown = (e) => {
-      if (e.key === "Alt") {
-        setAltKeyHeld(true);
-      }
-    };
-    const handleKeyUp = (e) => {
-      if (e.key === "Alt") {
-        setAltKeyHeld(false);
-        setLocatorTarget(null);
-      }
-    };
-    const handleBlur = () => {
-      setAltKeyHeld(false);
-      setLocatorTarget(null);
-    };
-    window.addEventListener("keydown", handleKeyDown);
-    window.addEventListener("keyup", handleKeyUp);
-    window.addEventListener("blur", handleBlur);
-    return () => {
-      window.removeEventListener("keydown", handleKeyDown);
-      window.removeEventListener("keyup", handleKeyUp);
-      window.removeEventListener("blur", handleBlur);
-    };
-  }, [enabled, setAltKeyHeld, setLocatorTarget]);
-  useEffect2(() => {
-    if (!isBrowser() || !enabled) return;
-    if (!altKeyHeld) return;
-    window.addEventListener("mousemove", handleMouseMove);
-    window.addEventListener("click", handleLocatorClick, true);
-    return () => {
-      window.removeEventListener("mousemove", handleMouseMove);
-      window.removeEventListener("click", handleLocatorClick, true);
-    };
-  }, [enabled, altKeyHeld, handleMouseMove, handleLocatorClick]);
-  useEffect2(() => {
-    if (!isBrowser() || !enabled) return;
-    const handleKeyDown = (e) => {
-      if (e.key === "Escape" && inspectedElement) {
-        setInspectedElement(null);
-      }
-    };
-    window.addEventListener("keydown", handleKeyDown);
-    return () => window.removeEventListener("keydown", handleKeyDown);
-  }, [enabled, inspectedElement, setInspectedElement]);
-  useEffect2(() => {
-    setIsMounted(true);
-  }, []);
-  useEffect2(() => {
-    if (!isBrowser() || !enabled) return;
-    if (!isMounted) return;
-    connectWebSocket();
-    return () => {
-      disconnectWebSocket();
-    };
-  }, [enabled, isMounted, connectWebSocket, disconnectWebSocket]);
-  const enableLiveScan = useCallback2(() => {
-    storeEnableLiveScan(settings.hideNodeModules);
-  }, [storeEnableLiveScan, settings.hideNodeModules]);
-  const contextValue = useMemo(
-    () => ({
-      settings,
-      updateSettings,
-      altKeyHeld,
-      locatorTarget,
-      inspectedElement,
-      setInspectedElement,
-      liveScanEnabled,
-      autoScanState,
-      elementIssuesCache,
-      enableLiveScan,
-      disableLiveScan
-    }),
-    [
-      settings,
-      updateSettings,
-      altKeyHeld,
-      locatorTarget,
-      inspectedElement,
-      setInspectedElement,
-      liveScanEnabled,
-      autoScanState,
-      elementIssuesCache,
-      enableLiveScan,
-      disableLiveScan
-    ]
-  );
-  const shouldRenderUI = enabled && isMounted;
-  return /* @__PURE__ */ jsxs(UILintContext.Provider, { value: contextValue, children: [
-    children,
-    shouldRenderUI && /* @__PURE__ */ jsx(UILintUI, {})
-  ] });
-}
-function UILintUI() {
-  const { altKeyHeld, inspectedElement, liveScanEnabled } = useUILintContext();
-  const [components, setComponents] = useState(null);
-  useEffect2(() => {
-    Promise.all([
-      import("./UILintToolbar-CLVXQHCZ.js"),
-      import("./InspectionPanel-NXSE7CMH.js"),
-      import("./LocatorOverlay-3TKK74BD.js"),
-      import("./ElementBadges-2CTPMJ6L.js")
-    ]).then(([toolbar, panel, locator, badges]) => {
-      setComponents({
-        Toolbar: toolbar.UILintToolbar,
-        Panel: panel.InspectionPanel,
-        LocatorOverlay: locator.LocatorOverlay,
-        InspectedHighlight: locator.InspectedElementHighlight,
-        ElementBadges: badges.ElementBadges
-      });
-    });
-  }, []);
-  if (!components) return null;
-  const { Toolbar, Panel, LocatorOverlay, InspectedHighlight, ElementBadges } = components;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(Toolbar, {}),
-    (altKeyHeld || inspectedElement) && /* @__PURE__ */ jsx(LocatorOverlay, {}),
-    liveScanEnabled && /* @__PURE__ */ jsx(ElementBadges, {}),
-    inspectedElement && /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsx(InspectedHighlight, {}),
-      /* @__PURE__ */ jsx(Panel, {})
-    ] })
-  ] });
-}
-
-export {
-  getSourceFromDataLoc,
-  isNodeModulesPath,
-  getDisplayName,
-  scanDOMForSources,
-  groupBySourceFile,
-  cleanupDataAttributes,
-  getElementById,
-  updateElementRects,
-  buildEditorUrl,
-  FILE_COLORS,
-  DEFAULT_SETTINGS,
-  DATA_UILINT_ID,
-  useUILintStore,
-  useUILintContext,
-  UILintProvider
-};