Merge pull request #8 from dandehoon/feature/tokens [patch]

feat!: add support for more tokens, refactor tests with actual editor, multiple cursors support

Author: dandehoon

README.md

@@ -21,24 +21,25 @@ Smartly expand or shrink your code selection, recover from misclicks or accident
 - **Expand Selection**: `Ctrl+E` (Windows/Linux) or `Cmd+E` (Mac)
 - **Retract Selection**: `Ctrl+Shift+E` (Windows/Linux) or `Cmd+Shift+E` (Mac)
 
-### Expansion Examples
-
-#### Basic Token Expansion
-
-```javascript
-const API_BASE_URL = 'https://api.example.com';
-```
+> [!TIP]
+> Both commands work with single and multiple cursor selections.
 
-With cursor on `api` → `api.example.com` → `https://api.example.com` → full string
-
-#### Nested Scopes
+### Expansion Examples
 
-```javascript
-const config = { url: 'https://example.com' };
+Text: `const config = { url: 'https://example.com' };`
+
+```txt
+With cursor on `xamp`, next expansions will be:
+→ example
+→ example.com
+→ https://example.com
+→ 'https://example.com'
+→ url: 'https://example.com'
+→ { url: 'https://example.com' }
+→ const config = { url: 'https://example.com' }
+→ const config = { url: 'https://example.com' };
 ```
 
-With cursor on `example` → `example.com` → `https://example.com` → `[url]` → `{...}`
-
 ## Commands
 
 - **`vscode-generic-expand-selection.expandSelection`**: Expand Selection

package.json

@@ -9,7 +9,7 @@
 		"url": "git://github.com/dandehoon/vscode-generic-expand-selection.git"
 	},
 	"engines": {
-		"vscode": "^1.92.0"
+		"vscode": "^1.101.0"
 	},
 	"categories": [
 		"Other"
@@ -49,22 +49,22 @@
 		"test": "tsc -p . --outDir out && node esbuild.js && vscode-test",
 		"build": "pnpm run check && node esbuild.js --production && pnpm dlx vsce package --no-dependencies -o out.vsix",
 		"publish": "pnpm dlx vsce publish --no-dependencies",
-		"vsce:install": "pnpm run build && code --install-extension out.vsix"
+		"local": "pnpm run build && code --install-extension out.vsix"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.29.0",
 		"@types/mocha": "^10.0.10",
-		"@types/node": "22.x",
-		"@types/vscode": "^1.92.0",
-		"@typescript-eslint/eslint-plugin": "^8.34.1",
-		"@typescript-eslint/parser": "^8.34.1",
+		"@types/node": "~22.15.33",
+		"@types/vscode": "^1.101.0",
+		"@typescript-eslint/eslint-plugin": "^8.35.0",
+		"@typescript-eslint/parser": "^8.35.0",
 		"@vscode/test-cli": "^0.0.11",
-		"@vscode/test-electron": "^2.4.0",
-		"@vscode/vsce": "^3.5.0",
+		"@vscode/test-electron": "^2.5.2",
+		"@vscode/vsce": "^3.6.0",
 		"esbuild": "^0.25.5",
 		"eslint": "^9.29.0",
-		"mocha": "^11.7.0",
+		"mocha": "^11.7.1",
 		"typescript": "5.5.4"
 	},
-	"packageManager": "pnpm@10.12.1+sha512.f0dda8580f0ee9481c5c79a1d927b9164f2c478e90992ad268bbb2465a736984391d6333d2c327913578b2804af33474ca554ba29c04a8b13060a717675ae3ac"
+	"packageManager": "pnpm@10.12.3+sha512.467df2c586056165580ad6dfb54ceaad94c5a30f80893ebdec5a44c5aa73c205ae4a5bb9d5ed6bb84ea7c249ece786642bbb49d06a307df218d03da41c317417"
 }

pnpm-lock.yaml

@@ -6,41 +6,72 @@ import {
   findToken,
 } from './finders';
 
+const outputChannel = vscode.window.createOutputChannel(
+  'Generic Expand Selection',
+);
+
 export class SelectionProvider {
-  private selectionHistory: vscode.Selection[] = [];
+  private selectionHistories: vscode.Selection[][] = [];
 
   expandSelection(editor: vscode.TextEditor) {
     const document = editor.document;
-    const selection = editor.selection;
-
+    const selections = editor.selections || [editor.selection];
     const text = document.getText();
-    const startOffset = document.offsetAt(selection.start);
-    const endOffset = document.offsetAt(selection.end);
-
-    // Try scoped expansion
-    const newRange = this.findNextExpansion(
-      text,
-      startOffset,
-      endOffset,
-      document,
-    );
-    if (newRange) {
-      // Store current selection for retract functionality before changing
-      this.selectionHistory.push(selection);
-      if (this.selectionHistory.length > 100) {
-        this.selectionHistory.shift();
+
+    const newSelections: vscode.Selection[] = [];
+
+    for (let i = 0; i < selections.length; i++) {
+      const selection = selections[i];
+      const startOffset = document.offsetAt(selection.start);
+      const endOffset = document.offsetAt(selection.end);
+
+      const newRange = this.findNextExpansion(
+        text,
+        startOffset,
+        endOffset,
+        document,
+      );
+
+      if (newRange) {
+        if (!this.selectionHistories[i]) {
+          this.selectionHistories[i] = [];
+        }
+        this.selectionHistories[i].push(selection);
+        if (this.selectionHistories[i].length > 100) {
+          this.selectionHistories[i].shift();
+        }
+        const newStart = document.positionAt(newRange.start);
+        const newEnd = document.positionAt(newRange.end);
+        newSelections.push(new vscode.Selection(newStart, newEnd));
+      } else {
+        newSelections.push(selection);
       }
-      const newStart = document.positionAt(newRange.start);
-      const newEnd = document.positionAt(newRange.end);
-      editor.selection = new vscode.Selection(newStart, newEnd);
+    }
+
+    if (editor.selections) {
+      editor.selections = newSelections;
+    } else {
+      editor.selection = newSelections[0];
     }
   }
 
   shrinkSelection(editor: vscode.TextEditor) {
-    if (this.selectionHistory.length > 0) {
-      // Restore previous selection from history
-      const previousSelection = this.selectionHistory.pop()!;
-      editor.selection = previousSelection;
+    const selections = editor.selections || [editor.selection];
+    const newSelections: vscode.Selection[] = [];
+
+    for (let i = 0; i < selections.length; i++) {
+      if (this.selectionHistories[i] && this.selectionHistories[i].length > 0) {
+        const previousSelection = this.selectionHistories[i].pop()!;
+        newSelections.push(previousSelection);
+      } else {
+        newSelections.push(selections[i]);
+      }
+    }
+
+    if (editor.selections) {
+      editor.selections = newSelections;
+    } else {
+      editor.selection = newSelections[0];
     }
   }
 
@@ -59,6 +90,9 @@ export class SelectionProvider {
         line: findLineExpansion(text, startIndex, endIndex, document),
       };
 
+    const selectionValue = text.substring(startIndex, endIndex);
+    outputChannel.appendLine('[expandSelection] Current: ' + selectionValue);
+
     // Return the smallest valid expansion, with priority logic
     let best: { start: number; end: number } | null = null;
     let smallest = Infinity;
@@ -76,10 +110,16 @@ export class SelectionProvider {
       }
     }
 
-    for (const [_, candidate] of Object.entries(candidateMap)) {
+    for (const [key, candidate] of Object.entries(candidateMap)) {
       if (!candidate) {
         continue;
       }
+      outputChannel.appendLine(
+        `[expandSelection] Candidate: ${key} - ${text.substring(
+          candidate.start,
+          candidate.end,
+        )}`,
+      );
       const size = candidate.end - candidate.start;
       if (size > 0 && (best === null || size < smallest)) {
         best = candidate;

src/expandSelection.ts

@@ -1,13 +1,44 @@
 import { SelectionCandidate } from '../types';
 import { getCandidate } from './util';
 
-/**
- * Finds all quote pairs (", ', `) and returns the nearest containing candidate
- */
 export function findNearestQuotePair(
   text: string,
   startIndex: number,
   endIndex: number,
+): SelectionCandidate | null {
+  const selectionText = text.substring(startIndex, endIndex);
+  if (!selectionText.includes('\n')) {
+    const beforeSelection = text.substring(0, startIndex);
+    const afterSelection = text.substring(endIndex);
+
+    const lineStart = beforeSelection.lastIndexOf('\n') + 1;
+    const nextNewline = afterSelection.indexOf('\n');
+    const lineEnd = nextNewline === -1 ? text.length : endIndex + nextNewline;
+
+    const lineContent = text.substring(lineStart, lineEnd);
+    const selectionInLine = startIndex - lineStart;
+    const selectionEndInLine = endIndex - lineStart;
+
+    const singleLineResult = findQuotePairsInText(
+      lineContent,
+      selectionInLine,
+      selectionEndInLine,
+      lineStart,
+    );
+
+    if (singleLineResult) {
+      return singleLineResult;
+    }
+  }
+
+  return findQuotePairsInText(text, startIndex, endIndex, 0);
+}
+
+function findQuotePairsInText(
+  text: string,
+  startIndex: number,
+  endIndex: number,
+  offset: number = 0,
 ): SelectionCandidate | null {
   const quotes = ['"', "'", '`'];
   let nearestCandidate: SelectionCandidate | null = null;
@@ -16,15 +47,18 @@ export function findNearestQuotePair(
   for (const quote of quotes) {
     for (let i = 0; i < text.length; i++) {
       if (text[i] === quote) {
-        // Look for closing quote
         let j = i + 1;
         let escaped = false;
 
         while (j < text.length) {
           if (text[j] === '\\' && !escaped) {
             escaped = true;
           } else if (text[j] === quote && !escaped) {
-            // Try content inside quotes first
+            if (offset === 0 && !isValidQuotePair(text, i, j + 1)) {
+              i = j;
+              break;
+            }
+
             const innerCandidate = getCandidate(
               startIndex,
               endIndex,
@@ -34,18 +68,21 @@ export function findNearestQuotePair(
             );
             let candidate = innerCandidate;
             if (!candidate) {
-              // Fallback to full quote including delimiters
               candidate = getCandidate(startIndex, endIndex, i, j + 1, text);
             }
             if (candidate) {
+              candidate = {
+                start: candidate.start + offset,
+                end: candidate.end + offset,
+              };
               const size = candidate.end - candidate.start;
               if (size < smallestSize) {
                 smallestSize = size;
                 nearestCandidate = candidate;
               }
             }
 
-            i = j; // Skip to after this quote pair
+            i = j;
             break;
           } else {
             escaped = false;
@@ -58,3 +95,76 @@ export function findNearestQuotePair(
 
   return nearestCandidate;
 }
+
+function isValidQuotePair(
+  text: string,
+  startPos: number,
+  endPos: number,
+): boolean {
+  const startQuote = text[startPos];
+  const endQuote = text[endPos - 1];
+
+  if (startQuote !== endQuote) {
+    return false;
+  }
+
+  const content = text.substring(startPos + 1, endPos - 1);
+  let unescapedQuoteCount = 0;
+  let escaped = false;
+
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === '\\' && !escaped) {
+      escaped = true;
+    } else if (content[i] === startQuote && !escaped) {
+      unescapedQuoteCount++;
+    } else {
+      escaped = false;
+    }
+  }
+
+  if (unescapedQuoteCount > 0) {
+    return false;
+  }
+
+  const beforeQuote = text.substring(Math.max(0, startPos - 20), startPos);
+  const afterQuote = text.substring(endPos, Math.min(text.length, endPos + 20));
+
+  if (beforeQuote.includes('//') || beforeQuote.includes('/*')) {
+    const commentStart = Math.max(
+      beforeQuote.lastIndexOf('//'),
+      beforeQuote.lastIndexOf('/*'),
+    );
+    const lineBreak = beforeQuote.lastIndexOf('\n');
+    if (commentStart > lineBreak) {
+      return false;
+    }
+  }
+
+  if (beforeQuote.includes('```') || afterQuote.includes('```')) {
+    return false;
+  }
+
+  if (content.length < 50) {
+    return true;
+  }
+
+  const codePatterns = [/[=:]\s*$/, /\(\s*$/, /,\s*$/, /\[\s*$/, /return\s*$/];
+
+  const hasCodeContext = codePatterns.some((pattern) =>
+    pattern.test(beforeQuote),
+  );
+
+  if (
+    !hasCodeContext &&
+    (content.includes('"') || content.includes("'") || content.includes('`'))
+  ) {
+    const differentQuoteTypes = ['"', "'", '`'].filter(
+      (q) => q !== startQuote && content.includes(q),
+    );
+    if (differentQuoteTypes.length > 1) {
+      return false;
+    }
+  }
+
+  return true;
+}

src/finders/quote.ts

@@ -27,6 +27,8 @@ export function findToken(
     /[a-zA-Z0-9_]+/, // With underscores
     /[a-zA-Z0-9_-]+/, // With hyphens
     /[a-zA-Z0-9_\-.]+/, // With dots
+    /[a-zA-Z0-9_\-.#$@%]+/, // Extended identifiers with programming symbols
+    /[^\s[\]{}()"'`]+/, // Fallback: all except whitespace, scopes, and quotes
   ];
 
   for (const pattern of patterns) {