feature: update dependencies

package.json

@@ -24,8 +24,8 @@
   },
   "devDependencies": {
     "@lerna/legacy-package-management": "^8.2.4",
-    "@lvce-editor/eslint-config": "^8.3.0",
-    "eslint": "10.2.1",
+    "@lvce-editor/eslint-config": "^10.2.0",
+    "eslint": "10.4.0",
     "lerna": "^8.2.3",
     "prettier": "^3.8.3",
     "typescript": "^6.0.3"

packages/diff-view/package.json

@@ -44,16 +44,16 @@
     }
   },
   "devDependencies": {
-    "@jest/globals": "^30.3.0",
+    "@jest/globals": "^30.4.1",
     "@lvce-editor/assert": "^1.5.1",
-    "@lvce-editor/constants": "^5.11.0",
+    "@lvce-editor/constants": "^5.13.0",
     "@lvce-editor/i18n": "^2.1.0",
     "@lvce-editor/rpc": "^6.4.0",
-    "@lvce-editor/rpc-registry": "^9.22.0",
+    "@lvce-editor/rpc-registry": "^9.23.0",
     "@lvce-editor/verror": "^1.7.0",
     "@lvce-editor/viewlet-registry": "^4.1.0",
-    "@lvce-editor/virtual-dom-worker": "^9.8.0",
-    "jest": "^30.3.0",
-    "ts-jest": "^29.4.9"
+    "@lvce-editor/virtual-dom-worker": "^9.11.0",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.4.10"
   }
 }

packages/diff-view/src/parts/GetErrorStackDom/GetStackLineHref/GetStackLineHref.ts

@@ -1,7 +1,11 @@
 export const getStackLineHref = (location: string, allowedLinkSchemes: readonly string[]): string => {
   const scheme = location.startsWith('/') ? 'file' : location.slice(0, location.indexOf(':'))
   if (allowedLinkSchemes.includes(scheme)) {
-    return scheme === 'file' ? `file://${location.startsWith('file://') ? location.slice('file://'.length) : location}` : location
+    if (scheme !== 'file') {
+      return location
+    }
+    const fileLocation = location.startsWith('file://') ? location.slice('file://'.length) : location
+    return `file://${fileLocation}`
   }
   return '#'
 }

packages/diff-view/src/parts/GetInlineDiffRows/GetInlineDiffRows.ts

@@ -29,84 +29,132 @@ const findLookAheadMatch = (lines: readonly string[], startIndex: number, needle
   return -1
 }
 
+const shouldUseLeftMatch = (leftMatch: number, rightMatch: number, leftIndex: number, rightIndex: number): boolean => {
+  return leftMatch !== -1 && (rightMatch === -1 || leftMatch - leftIndex <= rightMatch - rightIndex)
+}
+
+const hasMatchingLines = (
+  leftLines: readonly string[],
+  rightLines: readonly string[],
+  leftIndex: number,
+  rightIndex: number,
+): boolean => {
+  return leftIndex < leftLines.length && rightIndex < rightLines.length
+}
+
 export const getInlineDiffRows = (contentLeft: string, contentRight: string): readonly InlineDiffRow[] => {
   const leftLines = getLines(contentLeft)
   const rightLines = getLines(contentRight)
   const rows: InlineDiffRow[] = []
+
+  const addContextRow = (text: string, lineNumberLeft: number, lineNumberRight: number): void => {
+    rows.push({
+      lineNumberLeft,
+      lineNumberRight,
+      text,
+      type: InlineDiffRowType.Context,
+    })
+  }
+
+  const addDeletionRow = (text: string, lineNumberLeft: number): void => {
+    rows.push({
+      lineNumberLeft,
+      lineNumberRight: null,
+      text,
+      type: InlineDiffRowType.Deletion,
+    })
+  }
+
+  const addInsertionRow = (text: string, lineNumberRight: number): void => {
+    rows.push({
+      lineNumberLeft: null,
+      lineNumberRight,
+      text,
+      type: InlineDiffRowType.Insertion,
+    })
+  }
+
+  const appendDeletionsUntil = (leftIndex: number, leftMatch: number, leftLineNumber: number): { leftIndex: number; leftLineNumber: number } => {
+    let nextLeftIndex = leftIndex
+    let nextLeftLineNumber = leftLineNumber
+    while (nextLeftIndex < leftMatch) {
+      addDeletionRow(leftLines[nextLeftIndex], nextLeftLineNumber)
+      nextLeftIndex++
+      nextLeftLineNumber++
+    }
+    return {
+      leftIndex: nextLeftIndex,
+      leftLineNumber: nextLeftLineNumber,
+    }
+  }
+
+  const appendInsertionsUntil = (rightIndex: number, rightMatch: number, rightLineNumber: number): { rightIndex: number; rightLineNumber: number } => {
+    let nextRightIndex = rightIndex
+    let nextRightLineNumber = rightLineNumber
+    while (nextRightIndex < rightMatch) {
+      addInsertionRow(rightLines[nextRightIndex], nextRightLineNumber)
+      nextRightIndex++
+      nextRightLineNumber++
+    }
+    return {
+      rightIndex: nextRightIndex,
+      rightLineNumber: nextRightLineNumber,
+    }
+  }
+
   let leftIndex = 0
   let rightIndex = 0
   let leftLineNumber = 1
   let rightLineNumber = 1
 
+  const appendLookAheadRows = (): boolean => {
+    if (!hasMatchingLines(leftLines, rightLines, leftIndex, rightIndex)) {
+      return false
+    }
+
+    const leftLine = leftLines[leftIndex]
+    const rightLine = rightLines[rightIndex]
+    const leftMatch = findLookAheadMatch(leftLines, leftIndex + 1, rightLine)
+    const rightMatch = findLookAheadMatch(rightLines, rightIndex + 1, leftLine)
+
+    if (shouldUseLeftMatch(leftMatch, rightMatch, leftIndex, rightIndex)) {
+      ;({ leftIndex, leftLineNumber } = appendDeletionsUntil(leftIndex, leftMatch, leftLineNumber))
+      return true
+    }
+
+    if (rightMatch === -1) {
+      return false
+    }
+
+    ;({ rightIndex, rightLineNumber } = appendInsertionsUntil(rightIndex, rightMatch, rightLineNumber))
+    return true
+  }
+
   while (leftIndex < leftLines.length || rightIndex < rightLines.length) {
     const leftLine = leftLines[leftIndex]
     const rightLine = rightLines[rightIndex]
 
-    if (leftIndex < leftLines.length && rightIndex < rightLines.length && leftLine === rightLine) {
-      rows.push({
-        lineNumberLeft: leftLineNumber,
-        lineNumberRight: rightLineNumber,
-        text: leftLine,
-        type: InlineDiffRowType.Context,
-      })
+    if (hasMatchingLines(leftLines, rightLines, leftIndex, rightIndex) && leftLine === rightLine) {
+      addContextRow(leftLine, leftLineNumber, rightLineNumber)
       leftIndex++
       rightIndex++
       leftLineNumber++
       rightLineNumber++
       continue
     }
 
-    if (leftIndex < leftLines.length && rightIndex < rightLines.length) {
-      const leftMatch = findLookAheadMatch(leftLines, leftIndex + 1, rightLine)
-      const rightMatch = findLookAheadMatch(rightLines, rightIndex + 1, leftLine)
-
-      if (leftMatch !== -1 && (rightMatch === -1 || leftMatch - leftIndex <= rightMatch - rightIndex)) {
-        while (leftIndex < leftMatch) {
-          rows.push({
-            lineNumberLeft: leftLineNumber,
-            lineNumberRight: null,
-            text: leftLines[leftIndex],
-            type: InlineDiffRowType.Deletion,
-          })
-          leftIndex++
-          leftLineNumber++
-        }
-        continue
-      }
-
-      if (rightMatch !== -1) {
-        while (rightIndex < rightMatch) {
-          rows.push({
-            lineNumberLeft: null,
-            lineNumberRight: rightLineNumber,
-            text: rightLines[rightIndex],
-            type: InlineDiffRowType.Insertion,
-          })
-          rightIndex++
-          rightLineNumber++
-        }
-        continue
-      }
+    if (appendLookAheadRows()) {
+      continue
     }
 
     if (leftIndex < leftLines.length) {
-      rows.push({
-        lineNumberLeft: leftLineNumber,
-        lineNumberRight: null,
-        text: leftLines[leftIndex],
-        type: InlineDiffRowType.Deletion,
-      })
+      addDeletionRow(leftLines[leftIndex], leftLineNumber)
       leftIndex++
       leftLineNumber++
     }
 
     if (rightIndex < rightLines.length) {
-      rows.push({
-        lineNumberLeft: null,
-        lineNumberRight: rightLineNumber,
-        text: rightLines[rightIndex],
-        type: InlineDiffRowType.Insertion,
-      })
+      addInsertionRow(rightLines[rightIndex], rightLineNumber)
       rightIndex++
       rightLineNumber++
     }

packages/diff-view/src/parts/GetVisibleLines/GetVisibleLines.ts

@@ -1,3 +1,4 @@
+import type { VisibleInlineDiffRow } from '../GetVisibleInlineDiffRows/GetVisibleInlineDiffRows.ts'
 import type { InlineDiffChange } from '../InlineDiffChange/InlineDiffChange.ts'
 import type { TokenizedLine } from '../TokenizedLine/TokenizedLine.ts'
 import type { VisibleLine } from '../VisibleLine/VisibleLine.ts'
@@ -10,6 +11,37 @@ import { getVisibleLineType } from './GetVisibleLineType/GetVisibleLineType.ts'
 
 type DiffSide = 'left' | 'right'
 
+const getNormalVisibleLines = (
+  content: string,
+  totalLineCount: number,
+  minLineY: number,
+  maxLineY: number,
+  tokenizedLines: readonly TokenizedLine[],
+): readonly VisibleLine[] => {
+  return getVisibleRows(content, totalLineCount, minLineY, maxLineY).map((line, index) => ({
+    lineNumber: minLineY + index + 1,
+    tokens: getTokens(tokenizedLines, minLineY + index, line),
+    type: VisibleLineTypeValue.Normal,
+  }))
+}
+
+const getInlineChange = (visibleRow: VisibleInlineDiffRow, side: DiffSide): InlineDiffChange | undefined => {
+  if (side === 'left') {
+    return visibleRow.leftChange
+  }
+  return visibleRow.rightChange
+}
+
+const getLineIndex = (inlineChange: InlineDiffChange | undefined, side: DiffSide): number => {
+  if (!inlineChange) {
+    return -1
+  }
+  if (side === 'left') {
+    return inlineChange.leftIndex
+  }
+  return inlineChange.rightIndex
+}
+
 export const getVisibleLines = (
   content: string,
   totalLineCount: number,
@@ -20,20 +52,16 @@ export const getVisibleLines = (
   tokenizedLines: readonly TokenizedLine[] = [],
 ): readonly VisibleLine[] => {
   if (inlineChanges.length === 0) {
-    return getVisibleRows(content, totalLineCount, minLineY, maxLineY).map((line, index) => ({
-      lineNumber: minLineY + index + 1,
-      tokens: getTokens(tokenizedLines, minLineY + index, line),
-      type: VisibleLineTypeValue.Normal,
-    }))
+    return getNormalVisibleLines(content, totalLineCount, minLineY, maxLineY, tokenizedLines)
   }
 
   const lines = content ? content.split('\n') : ['']
   return getVisibleInlineDiffRows(inlineChanges)
     .slice(minLineY, maxLineY)
     .map((visibleRow) => {
-      const inlineChange = side === 'left' ? visibleRow.leftChange : visibleRow.rightChange
+      const inlineChange = getInlineChange(visibleRow, side)
       const type = inlineChange ? getVisibleLineType(inlineChange, side) : VisibleLineTypeValue.Normal
-      const lineIndex = inlineChange ? (side === 'left' ? inlineChange.leftIndex : inlineChange.rightIndex) : -1
+      const lineIndex = getLineIndex(inlineChange, side)
       const tokens = inlineChange && lineIndex >= 0 ? getTokens(tokenizedLines, lineIndex, getLine(lines, lineIndex)) : []
       return {
         lineNumber: lineIndex >= 0 ? lineIndex + 1 : -1,

packages/diff-view/test/GetDiffEditorVirtualDom.test.ts

@@ -1,3 +1,5 @@
+/* eslint-disable jest/no-disabled-tests */
+
 import { expect, test } from '@jest/globals'
 import { text, VirtualDomElements } from '@lvce-editor/virtual-dom-worker'
 import * as ClassNames from '../src/parts/ClassNames/ClassNames.ts'

packages/diff-view/test/Initialize.test.ts

@@ -1,3 +1,5 @@
+/* eslint-disable jest/no-disabled-tests */
+
 import { expect, test } from '@jest/globals'
 import { ExtensionHost, RendererWorker, TextMeasurementWorker } from '@lvce-editor/rpc-registry'
 import { initialize } from '../src/parts/Initialize/Initialize.ts'

packages/diff-view/test/LoadFileContents.test.ts

@@ -1,3 +1,5 @@
+/* eslint-disable jest/no-disabled-tests */
+
 import { expect, test } from '@jest/globals'
 import { ExtensionHost, FileSystemWorker } from '@lvce-editor/rpc-registry'
 import { loadFileContents } from '../src/parts/LoadFileContents/LoadFileContents.ts'

packages/diff-view/test/RenderCss.test.ts

@@ -1,3 +1,5 @@
+/* eslint-disable jest/no-disabled-tests */
+
 import { expect, test } from '@jest/globals'
 import { ViewletCommand } from '@lvce-editor/constants'
 import { createDefaultState } from '../src/parts/CreateDefaultState/CreateDefaultState.ts'