Fix multiline selection handling for number functions

Fixes #74 - Ensures sequence, increment, and decrement commands properly handle multiline selections as single units rather than processing line-by-line. This allows consistent max-length padding across entire multiline selections.

Key changes:
- Added numberFunctionNames handling to process multiline selections correctly
- Updated sequence function to use replaceAll for global replacement
- Added comprehensive tests for multiline selection scenarios
- Fixed code formatting and trailing commas

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: exceptionraiser

content.txt

@@ -65,3 +65,8 @@ prefix007 suffix008 middle009
 test01 value100 prefix007 99
 02 100 4
 010 100 123
+a001 b1
+c1 d01 e1
+f1 g1
+multi1 line2
+test3 data4

src/commands/index.ts

@@ -80,12 +80,12 @@ export const stringFunction = async (
 ): Promise<{ replacedSelections: string[] } | undefined> => {
   const startTime = Date.now();
   const editor = vscode.window.activeTextEditor;
-  
+
   if (!editor) {
     telemetryService.logError({
       errorType: "no_active_editor",
       source: `stringFunction.${executionSource}`,
-      message: "No active text editor found"
+      message: "No active text editor found",
     });
     return;
   }
@@ -107,7 +107,7 @@ export const stringFunction = async (
           executionSource,
           success: false,
           errorType: "user_cancelled_input",
-          selectionCount: editor.selections.length
+          selectionCount: editor.selections.length,
         });
         return;
       }
@@ -119,7 +119,7 @@ export const stringFunction = async (
           executionSource,
           success: false,
           errorType: "invalid_number_input",
-          selectionCount: editor.selections.length
+          selectionCount: editor.selections.length,
         });
         return;
       }
@@ -128,7 +128,9 @@ export const stringFunction = async (
       stringFunc = (str: string) =>
         (commandNameFunctionMap[commandName] as Function)(str, multiselectData);
     } else {
-      stringFunc = commandNameFunctionMap[commandName] as (str: string) => string;
+      stringFunc = commandNameFunctionMap[commandName] as (
+        str: string
+      ) => string;
     }
 
     if (
@@ -145,6 +147,13 @@ export const stringFunction = async (
       );
       selectionMap = result.selectionMap;
       replacedSelections = result.replacedSelections;
+    } else if (numberFunctionNames.includes(commandName)) {
+      for (const [index, selection] of editor.selections.entries()) {
+        const text = editor.document.getText(selection);
+        const replaced = stringFunc(text);
+        replacedSelections.push(replaced);
+        selectionMap[index] = { selection, replaced };
+      }
     } else {
       for (const [index, selection] of editor.selections.entries()) {
         const text = editor.document.getText(selection);
@@ -167,7 +176,10 @@ export const stringFunction = async (
         commandName === "duplicateAndIncrement" ||
         commandName === "duplicateAndDecrement"
       ) {
-        editor.selections = updateSelectionsAfterDuplicate(editor, selectionMap);
+        editor.selections = updateSelectionsAfterDuplicate(
+          editor,
+          selectionMap
+        );
       }
 
       context.globalState.update("lastAction", commandName);
@@ -180,7 +192,7 @@ export const stringFunction = async (
       executionSource,
       success: true,
       executionTimeMs: executionTime,
-      selectionCount: editor.selections.length
+      selectionCount: editor.selections.length,
     });
 
     return await Promise.resolve({ replacedSelections });
@@ -193,13 +205,13 @@ export const stringFunction = async (
       success: false,
       errorType: "execution_error",
       executionTimeMs: executionTime,
-      selectionCount: editor.selections.length
+      selectionCount: editor.selections.length,
     });
 
     telemetryService.logError({
       errorType: "command_execution_error",
       source: `stringFunction.${commandName}`,
-      message: error.message || String(error)
+      message: error.message || String(error),
     });
 
     throw error; // Re-throw to maintain existing error handling

src/commands/sequence.ts

@@ -14,30 +14,30 @@ export const sequence: CommandFunction = (
     }
     return 0;
   }));
-  
-  return str.replace(/-?\d+/g, (n) => {
+
+  return str.replaceAll(/-?\d+/g, (n) => {
     const isFirst = typeof multiselectData.offset !== "number";
     multiselectData.offset = isFirst
       ? Number(n)
       : (multiselectData.offset || 0) + 1;
-    
+
     const sequenceValue = multiselectData.offset;
-    
+
     // Use max length for consistent padding if any number in the string has leading zeros
     if (maxLength > 0) {
       const isNegative = sequenceValue < 0;
       const sequenceStr = String(sequenceValue);
-      
+
       if (isNegative) {
         // For negative numbers, pad after the minus sign
         const absStr = sequenceStr.substring(1);
-        return '-' + absStr.padStart(maxLength - 1, '0');
+        return "-" + absStr.padStart(maxLength - 1, "0");
       } else {
         // For positive numbers, pad the entire string
-        return sequenceStr.padStart(maxLength, '0');
+        return sequenceStr.padStart(maxLength, "0");
       }
     }
-    
+
     return String(sequenceValue);
   });
 };

src/test/extension.test.ts

@@ -422,6 +422,26 @@ suite("Extension Test Suite", () => {
       );
     });
 
+    test("increment handles multiline selections as single unit", async () => {
+      const [output] = await getTextForSelectionsByCommand(
+        "string-manipulation.increment",
+        [
+          {
+            start: { line: 70, character: 0 },
+            end: { line: 72, character: 10 },
+          },
+        ]
+      );
+
+      // Test that multiline selections are processed as a single unit
+      // Input: "multi1 line2\ntest3 data4"
+      // Expected: all numbers incremented by 1
+      assert.strictEqual(
+        output /* multi1 line2\ntest3 data4 */,
+        "multi2 line3test4 data5"
+      );
+    });
+
     test("decrement decreases all numbers in the selection by 1", async () => {
       const [output1, output2, output3] = await getTextForSelectionsByCommand(
         "string-manipulation.decrement",
@@ -455,6 +475,26 @@ suite("Extension Test Suite", () => {
       );
     });
 
+    test("decrement handles multiline selections as single unit", async () => {
+      const [output] = await getTextForSelectionsByCommand(
+        "string-manipulation.decrement",
+        [
+          {
+            start: { line: 70, character: 0 },
+            end: { line: 72, character: 10 },
+          },
+        ]
+      );
+
+      // Test that multiline selections are processed as a single unit
+      // Input: "multi1 line2\ntest3 data4"
+      // Expected: all numbers decremented by 1
+      assert.strictEqual(
+        output /* multi1 line2\ntest3 data4 */,
+        "multi0 line1test2 data3"
+      );
+    });
+
     test("incrementFloat increases all floats in the selection by 1", async () => {
       const [output] = await getTextForSelectionsByCommand(
         "string-manipulation.incrementFloat",
@@ -892,6 +932,26 @@ suite("Extension Test Suite", () => {
       );
     });
 
+    test("sequence handles multiline selections with consistent max-length padding", async () => {
+      const [output] = await getTextForSelectionsByCommand(
+        "string-manipulation.sequence",
+        [
+          {
+            start: { line: 67, character: 0 },
+            end: { line: 69, character: 6 },
+          },
+        ]
+      );
+
+      // Test the example from GitHub issue #74
+      // Input: "a001 b1\nc1 d01 e1\nf1 g1"
+      // Expected: all numbers should be padded to 3 digits (max length from "001")
+      assert.strictEqual(
+        output /* a001 b1\nc1 d01 e1\nf1 g1 */,
+        "a001 b002c003 d004 e005f006 g007"
+      );
+    });
+
     test("utf8ToChar converts Unicode escapes to characters", async () => {
       const [output] = await getTextForSelectionsByCommand(
         "string-manipulation.utf8ToChar",