@lvce-editor/editor-worker 15.2.0 → 16.0.0

package/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,
@@ -3165,6 +3308,71 @@ const getLanguages = async (platform, assetDir) => {
   return languages;
 };
 
+/**
+ * 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;
+};
+
 const measureCharacterWidth = async (fontWeight, fontSize, fontFamily, letterSpacing) => {
   return await measureTextWidth('a', fontWeight, fontSize, fontFamily, letterSpacing, false, 0);
 };
@@ -3271,11 +3479,15 @@ const updateDiagnostics = async newState => {
     if (!latest) {
       return newState;
     }
-    const decorations = await getVisibleDiagnostics(latest.newState, diagnostics);
+    const visualDecorations = await getVisibleDiagnostics(latest.newState, diagnostics);
+    // Re-detect link decorations after text changes
+    const linkDecorations = detectAllLinksAsDecorations(latest.newState);
     const newEditor = {
       ...latest.newState,
-      decorations,
-      diagnostics
+      decorations: linkDecorations,
+      // 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,18 +3616,28 @@ 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,
     textInfos
   };
+  console.error({
+    newEditor4
+  });
   set$6(id, emptyEditor, newEditor4);
 
   // TODO only sync when needed
@@ -8619,6 +8841,9 @@ const getLineInfos = (lines, tokenizer, languageId) => {
     lineInfos.push(lineInfo);
     currentLineState = result;
   }
+  console.error({
+    lineInfos
+  });
   return lineInfos;
 };
 
@@ -10254,6 +10479,9 @@ const renderLines = {
     } = newState;
     const relativeLine = highlightedLine - minLineY;
     const dom = getEditorRowsVirtualDom(textInfos, differences, true, relativeLine);
+    console.error({
+      dom
+    });
     return [/* method */'setText', dom];
   },
   isEqual(oldState, newState) {
@@ -10324,11 +10552,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 = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "15.2.0",
+  "version": "16.0.0",
   "repository": {
     "type": "git",
     "url": "git@github.com:lvce-editor/editor-worker.git"