@lvce-editor/static-server 0.71.1 → 0.71.3

package/static/{9d73e0d → 17fc835}/packages/editor-worker/dist/editorWorkerMain.js

@@ -2170,8 +2170,29 @@ const getStartDefaults = (tokens, minOffset) => {
     startIndex
   };
 };
-const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
+const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, decorations, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
   const lineInfo = [];
+
+  // Build decoration map for this line (position -> decoration class)
+  const decorationMap = new Map();
+  for (let j = 0; j < decorations.length; j += 4) {
+    const decorationOffset = decorations[j];
+    const decorationLength = decorations[j + 1];
+    const decorationType = decorations[j + 2];
+    const relativeStart = decorationOffset - lineOffset;
+    const relativeEnd = relativeStart + decorationLength;
+
+    // Only include decorations that overlap with this line
+    if (relativeStart < line.length && relativeEnd > 0) {
+      const decorationClassName = getDecorationClassName(decorationType);
+      if (decorationClassName) {
+        decorationMap.set(Math.max(0, relativeStart), {
+          className: decorationClassName,
+          end: Math.min(line.length, relativeEnd)
+        });
+      }
+    }
+  }
   const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
   const embeddedTokens = embeddedResult.result.tokens;
   const embeddedTokenMap = embeddedResult.TokenMap;
@@ -2185,12 +2206,66 @@ const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, normalize,
   for (let i = startIndex; i < tokensLength; i += 2) {
     const tokenType = embeddedTokens[i];
     const tokenLength = embeddedTokens[i + 1];
-    end += tokenLength;
-    const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
-    const text = line.slice(start, end);
-    const normalizedText = normalizeText(text, normalize, tabSize);
-    lineInfo.push(normalizedText, className);
-    start = end;
+    const tokenEnd = start + tokenLength;
+
+    // Check if any decorations overlap with this token
+    let hasOverlap = false;
+    for (const [decorationStart, {
+      end: decorationEnd
+    }] of decorationMap) {
+      if (decorationStart < tokenEnd && decorationEnd > start) {
+        hasOverlap = true;
+        break;
+      }
+    }
+    if (hasOverlap) {
+      // Token has decoration overlap - split into parts
+      let currentPos = start;
+      while (currentPos < tokenEnd) {
+        // Find if current position is inside a decoration
+        let activeDecoration = null;
+        for (const [decorationStart, decoration] of decorationMap) {
+          if (decorationStart <= currentPos && decoration.end > currentPos) {
+            activeDecoration = decoration;
+            break;
+          }
+        }
+        if (activeDecoration) {
+          // Render decorated part
+          const partEnd = Math.min(tokenEnd, activeDecoration.end);
+          const text = line.slice(currentPos, partEnd);
+          const baseTokenClass = embeddedTokenMap[tokenType] || 'Unknown';
+          const className = `Token ${baseTokenClass} ${activeDecoration.className}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        } else {
+          // Find next decoration start or token end
+          let nextDecorationStart = tokenEnd;
+          for (const [decorationStart] of decorationMap) {
+            if (decorationStart > currentPos && decorationStart < tokenEnd) {
+              nextDecorationStart = Math.min(nextDecorationStart, decorationStart);
+            }
+          }
+
+          // Render non-decorated part
+          const partEnd = nextDecorationStart;
+          const text = line.slice(currentPos, partEnd);
+          const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        }
+      }
+    } else {
+      // No decoration overlap - render token normally
+      const text = line.slice(start, tokenEnd);
+      const className = `Token ${embeddedTokenMap[tokenType] || 'Unknown'}`;
+      const normalizedText = normalizeText(text, normalize, tabSize);
+      lineInfo.push(normalizedText, className);
+    }
+    start = tokenEnd;
+    end = tokenEnd;
     if (end >= maxOffset) {
       break;
     }
@@ -2223,11 +2298,25 @@ const getDifference = (start, averageCharWidth, deltaX) => {
 };
 const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
   const lineInfo = [];
-  let decorationIndex = 0;
-  for (; decorationIndex < decorations.length; decorationIndex += 3) {
-    const decorationOffset = decorations[decorationIndex];
-    if (decorationOffset >= lineOffset) {
-      break;
+
+  // Build decoration map for this line (position -> decoration class)
+  const decorationMap = new Map();
+  for (let j = 0; j < decorations.length; j += 4) {
+    const decorationOffset = decorations[j];
+    const decorationLength = decorations[j + 1];
+    const decorationType = decorations[j + 2];
+    const relativeStart = decorationOffset - lineOffset;
+    const relativeEnd = relativeStart + decorationLength;
+
+    // Only include decorations that overlap with this line
+    if (relativeStart < line.length && relativeEnd > 0) {
+      const decorationClassName = getDecorationClassName(decorationType);
+      if (decorationClassName) {
+        decorationMap.set(Math.max(0, relativeStart), {
+          className: decorationClassName,
+          end: Math.min(line.length, relativeEnd)
+        });
+      }
     }
   }
   const {
@@ -2243,27 +2332,66 @@ const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, To
   for (let i = startIndex; i < tokensLength; i += 2) {
     const tokenType = tokens[i];
     const tokenLength = tokens[i + 1];
-    const decorationOffset = decorations[decorationIndex];
-    let extraClassName = '';
-    if (decorationOffset !== undefined && decorationOffset - lineOffset === start) {
-      // @ts-ignore
-      decorations[++decorationIndex];
-      const decorationType = decorations[++decorationIndex];
-      // @ts-ignore
-      decorations[++decorationIndex];
-      //   decorationIndex,
-      //   decorationLength,
-      //   decorationType,
-      //   decorationModifiers,
-      // })
-      extraClassName = getDecorationClassName(decorationType);
+    const tokenEnd = start + tokenLength;
+
+    // Check if any decorations overlap with this token
+    let hasOverlap = false;
+    for (const [decorationStart, {
+      end: decorationEnd
+    }] of decorationMap) {
+      if (decorationStart < tokenEnd && decorationEnd > start) {
+        hasOverlap = true;
+        break;
+      }
     }
-    end += tokenLength;
-    const text = line.slice(start, end);
-    const className = `Token ${extraClassName || TokenMap[tokenType] || 'Unknown'}`;
-    const normalizedText = normalizeText(text, normalize, tabSize);
-    lineInfo.push(normalizedText, className);
-    start = end;
+    if (hasOverlap) {
+      // Token has decoration overlap - split into parts
+      let currentPos = start;
+      while (currentPos < tokenEnd) {
+        // Find if current position is inside a decoration
+        let activeDecoration = null;
+        for (const [decorationStart, decoration] of decorationMap) {
+          if (decorationStart <= currentPos && decoration.end > currentPos) {
+            activeDecoration = decoration;
+            break;
+          }
+        }
+        if (activeDecoration) {
+          // Render decorated part
+          const partEnd = Math.min(tokenEnd, activeDecoration.end);
+          const text = line.slice(currentPos, partEnd);
+          const baseTokenClass = TokenMap[tokenType] || 'Unknown';
+          const className = `Token ${baseTokenClass} ${activeDecoration.className}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        } else {
+          // Find next decoration start or token end
+          let nextDecorationStart = tokenEnd;
+          for (const [decorationStart] of decorationMap) {
+            if (decorationStart > currentPos && decorationStart < tokenEnd) {
+              nextDecorationStart = Math.min(nextDecorationStart, decorationStart);
+            }
+          }
+
+          // Render non-decorated part
+          const partEnd = nextDecorationStart;
+          const text = line.slice(currentPos, partEnd);
+          const className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
+          const normalizedText = normalizeText(text, normalize, tabSize);
+          lineInfo.push(normalizedText, className);
+          currentPos = partEnd;
+        }
+      }
+    } else {
+      // No decoration overlap - render token normally
+      const text = line.slice(start, tokenEnd);
+      const className = `Token ${TokenMap[tokenType] || 'Unknown'}`;
+      const normalizedText = normalizeText(text, normalize, tabSize);
+      lineInfo.push(normalizedText, className);
+    }
+    start = tokenEnd;
+    end = tokenEnd;
     if (end >= maxOffset) {
       break;
     }
@@ -2281,7 +2409,7 @@ const getLineInfo$1 = (line, tokenResults, embeddedResults, decorations, TokenMa
   if (embeddedResults.length > 0 && tokenResults.embeddedResultIndex !== undefined) {
     const embeddedResult = embeddedResults[tokenResults.embeddedResultIndex];
     if (embeddedResult?.isFull) {
-      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
+      return getLineInfoEmbeddedFull(embeddedResults, tokenResults, line, decorations, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
     }
   }
   return getLineInfoDefault(line, tokenResults, embeddedResults, decorations, TokenMap, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset);
@@ -2302,10 +2430,25 @@ const getLineInfosViewport = (editor, tokens, embeddedResults, minLineY, maxLine
   for (let i = minLineY; i < maxLineY; i++) {
     const line = lines[i];
     const normalize = shouldNormalizeText(line);
+
+    // Use decorations that were pre-computed (includes links and diagnostics)
+    // Filter decorations to only include those for this line
+    const lineDecorations = [];
+    for (let j = 0; j < decorations.length; j += 4) {
+      const decorationOffset = decorations[j];
+      const decorationLength = decorations[j + 1];
+      const decorationType = decorations[j + 2];
+      const decorationModifiers = decorations[j + 3];
+
+      // Include decoration if it starts within this line
+      if (decorationOffset >= offset && decorationOffset < offset + line.length) {
+        lineDecorations.push(decorationOffset, decorationLength, decorationType, decorationModifiers);
+      }
+    }
     const {
       difference,
       lineInfo
-    } = getLineInfo$1(line, tokens[i - minLineY], embeddedResults, decorations, tokenMap, offset, normalize, tabSize, width, deltaX, averageCharWidth);
+    } = getLineInfo$1(line, tokens[i - minLineY], embeddedResults, lineDecorations, tokenMap, offset, normalize, tabSize, width, deltaX, averageCharWidth);
     result.push(lineInfo);
     differences.push(difference);
     offset += line.length + 1;
@@ -2336,7 +2479,7 @@ const getVisible$1 = async (editor, syncIncremental) => {
     tokenizersToLoad,
     tokens
   } = await getTokensViewport2(editor, minLineY, maxLineY, syncIncremental);
-  const minLineOffset = offsetAtSync(editor, minLineY, 0);
+  const minLineOffset = await offsetAtSync(editor, minLineY, 0);
   const averageCharWidth = charWidth;
   const {
     differences,
@@ -2476,6 +2619,108 @@ const getIncrementalEdits = async (oldState, newState) => {
   return emptyIncrementalEdits;
 };
 
+/**
+ * Gets all regex matches for a given text and regex pattern
+ * @param text The text to match against
+ * @param regex The regex pattern to use (should have global flag)
+ * @returns Array of regex matches
+ */
+const getRegexMatches = (text, regex) => {
+  return [...text.matchAll(regex)];
+};
+
+// URL matching regex pattern - matches common URL schemes
+// Supports: http://, https://, ftp://, ftps://, file://
+// Also matches URLs without explicit scheme (www.example.com)
+const URL_PATTERN = /(?:(?:https?|ftp|ftps|file):\/\/)?(?:www\.)?(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\/[^\s]*)?/g;
+
+// Regex to check if URL has a scheme (http://, https://, ftp://, etc.)
+const HAS_SCHEME_PATTERN = /^(?:https?|ftp|ftps|file):\/\//;
+
+// Regex to check if URL starts with www.
+const HAS_WWW_PATTERN = /^www\./;
+
+/**
+ * Detects links in a given text and returns their positions
+ * @param text The text to scan for links
+ * @returns Array of links with their start position and length
+ */
+const detectLinks = text => {
+  const matches = getRegexMatches(text, URL_PATTERN);
+  const links = [];
+  for (const match of matches) {
+    const url = match[0];
+    // Only consider as link if it has a scheme or starts with www.
+    if (HAS_SCHEME_PATTERN.test(url) || HAS_WWW_PATTERN.test(url)) {
+      links.push({
+        length: url.length,
+        start: match.index ?? 0
+      });
+    }
+  }
+  return links;
+};
+
+/**
+ * Detects all links in an editor and returns them as decorations
+ * @param editor The editor containing lines to scan
+ * @returns Flat array of decorations in format [offset, length, type, modifiers, ...]
+ */
+const detectAllLinksAsDecorations = editor => {
+  const decorations = [];
+  const {
+    lines
+  } = editor;
+  let offset = 0;
+  for (const line of lines) {
+    const links = detectLinks(line);
+    for (const link of links) {
+      const linkOffset = offset + link.start;
+      // Add link decoration: offset, length, type, modifiers
+      decorations.push(linkOffset, link.length, Link, 0);
+    }
+    offset += line.length + 1; // +1 for newline
+  }
+  return decorations;
+};
+
+/**
+ * Gets the URL text at a given offset in the editor if it's a link
+ * @param editor The editor
+ * @param offset The offset in the document
+ * @returns The URL string if the offset is on a link, or undefined
+ */
+const getUrlAtOffset = (editor, offset) => {
+  const {
+    decorations,
+    lines
+  } = editor;
+
+  // Iterate through decorations in groups of 4 (offset, length, type, modifiers)
+  for (let i = 0; i < decorations.length; i += 4) {
+    const decorationOffset = decorations[i];
+    const decorationLength = decorations[i + 1];
+    const decorationType = decorations[i + 2];
+
+    // Check if this decoration is a link and if the offset falls within it
+    if (decorationType === Link && offset >= decorationOffset && offset < decorationOffset + decorationLength) {
+      // Extract the URL text from the editor content
+      let currentOffset = 0;
+      for (const line of lines) {
+        const lineLength = line.length + 1; // +1 for newline
+        if (currentOffset + lineLength > decorationOffset) {
+          // The link starts in this line
+          const linkStartInLine = decorationOffset - currentOffset;
+          const url = line.slice(linkStartInLine, linkStartInLine + decorationLength);
+          return url;
+        }
+        currentOffset += lineLength;
+      }
+    }
+  }
+  return undefined;
+};
+
 const splitLines = lines => {
   if (!lines) {
     return [''];
@@ -2891,11 +3136,17 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
     selections: newSelections,
     undoStack: [...editor.undoStack, changes]
   };
-  set$6(editor.uid, editor, newEditor);
-  const incrementalEdits = await getIncrementalEdits(editor, newEditor);
-  const editorWithNewWidgets = await applyWidgetChanges(newEditor, changes);
-  const newEditor2 = {
+  // Update link decorations after text changes
+  const linkDecorations = detectAllLinksAsDecorations(newEditor);
+  const newEditorWithDecorations = {
     ...newEditor,
+    decorations: linkDecorations
+  };
+  set$6(editor.uid, editor, newEditorWithDecorations);
+  const incrementalEdits = await getIncrementalEdits(editor, newEditorWithDecorations);
+  const editorWithNewWidgets = await applyWidgetChanges(newEditorWithDecorations, changes);
+  const newEditor2 = {
+    ...newEditorWithDecorations,
     ...editorWithNewWidgets,
     incrementalEdits
   };
@@ -3252,6 +3503,37 @@ const getVisibleDiagnostics = async (editor, diagnostics) => {
   return visibleDiagnostics;
 };
 
+/**
+ * Merges link decorations with diagnostic decorations
+ * Links should always be present, but we also need to include any diagnostic decorations
+ */
+const mergeLinksWithDiagnosticDecorations = (editor, diagnosticDecorations) => {
+  // Get link decorations
+  const linkDecorations = detectAllLinksAsDecorations(editor);
+
+  // Merge with diagnostic decorations
+  const allDecorations = [...linkDecorations, ...diagnosticDecorations];
+
+  // Sort by offset to maintain proper order
+  const sortedDecorations = [];
+  for (let i = 0; i < allDecorations.length; i += 4) {
+    sortedDecorations.push({
+      length: allDecorations[i + 1],
+      modifiers: allDecorations[i + 3],
+      offset: allDecorations[i],
+      type: allDecorations[i + 2]
+    });
+  }
+  sortedDecorations.sort((a, b) => a.offset - b.offset);
+
+  // Flatten back to array format
+  const result = [];
+  for (const dec of sortedDecorations) {
+    result.push(dec.offset, dec.length, dec.type, dec.modifiers);
+  }
+  return result;
+};
+
 const updateDiagnostics = async newState => {
   try {
     // TODO handle error
@@ -3271,11 +3553,17 @@ const updateDiagnostics = async newState => {
     if (!latest) {
       return newState;
     }
-    const decorations = await getVisibleDiagnostics(latest.newState, diagnostics);
+    const visualDecorations = await getVisibleDiagnostics(latest.newState, diagnostics);
+    // Get diagnostic decorations from visual decorations (if any)
+    const diagnosticDecorations = visualDecorations.flatMap(deco => [deco.offset, deco.length, deco.type, deco.modifiers || 0]);
+    // Merge link decorations with diagnostic decorations
+    const mergedDecorations = mergeLinksWithDiagnosticDecorations(latest.newState, diagnosticDecorations);
     const newEditor = {
       ...latest.newState,
-      decorations,
-      diagnostics
+      decorations: mergedDecorations,
+      // Text-level decorations (flat array) for CSS classes
+      diagnostics,
+      visualDecorations // Visual decorations (objects with x, y, width, height) for squiggly underlines
     };
     set$6(newState.id, latest.oldState, newEditor);
     // @ts-ignore
@@ -3404,13 +3692,20 @@ const createEditor = async ({
   } else {
     newEditor3 = await setDeltaY$2(newEditor2, 0);
   }
+
+  // Detect links and initialize decorations
+  const linkDecorations = detectAllLinksAsDecorations(newEditor3);
+  const newEditor3WithLinks = {
+    ...newEditor3,
+    decorations: linkDecorations
+  };
   const syncIncremental = getEnabled();
   const {
     differences,
     textInfos
-  } = await getVisible$1(newEditor3, syncIncremental);
+  } = await getVisible$1(newEditor3WithLinks, syncIncremental);
   const newEditor4 = {
-    ...newEditor3,
+    ...newEditor3WithLinks,
     differences,
     focus: FocusEditorText$1,
     focused: true,
@@ -5221,6 +5516,10 @@ const setPosition$1 = position => {
   state$3.position = position;
 };
 
+const openExternal = async url => {
+  await invoke$b('Open.openUrl', url);
+};
+
 // TODO first change cursor position, then run go to definition
 // cursor should appear at mousedown position immediately
 const handleSingleClickWithAlt = async (editor, position) => {
@@ -5228,12 +5527,21 @@ const handleSingleClickWithAlt = async (editor, position) => {
     columnIndex,
     rowIndex
   } = position;
+
+  // Check if the click is on a link
+  const offset = offsetAt(editor, rowIndex, columnIndex);
+  const url = getUrlAtOffset(editor, offset);
+  if (url) {
+    // Open the link
+    await openExternal(url);
+    return editor;
+  }
+
+  // Otherwise, perform the default go to definition
   const newEditor = {
     ...editor,
     selections: new Uint32Array([rowIndex, columnIndex, rowIndex, columnIndex])
   };
-  // TODO rectangular selection with alt click,
-  // but also go to definition with alt click
   const newEditor2 = await goToDefinition(newEditor);
   return newEditor2;
 };
@@ -8619,6 +8927,9 @@ const getLineInfos = (lines, tokenizer, languageId) => {
     lineInfos.push(lineInfo);
     currentLineState = result;
   }
+  console.error({
+    lineInfos
+  });
   return lineInfos;
 };
 
@@ -10324,11 +10635,11 @@ const renderAdditionalFocusContext = {
 };
 const renderDecorations = {
   apply(oldState, newState) {
-    const dom = getDiagnosticsVirtualDom(newState.decorations);
+    const dom = getDiagnosticsVirtualDom(newState.visualDecorations || []);
     return ['setDecorationsDom', dom];
   },
   isEqual(oldState, newState) {
-    return oldState.decorations === newState.decorations;
+    return oldState.visualDecorations === newState.visualDecorations;
   }
 };
 const renderGutterInfo = {