Refactor cancelTokenToAbortSignal to src/core/cancellation-utils.ts and add tests.

- Extracted `cancelTokenToAbortSignal` from `src/helpers.ts` to `src/core/cancellation-utils.ts` to decouple from `vscode` module runtime dependency.
- Updated `src/helpers.ts` to re-export the function.
- Added unit tests in `tests/unit/cancellation-utils.test.ts`.
- Fixed type signature of `cancelTokenToAbortSignal` to correctly reflect return type when input is null/undefined.

Co-authored-by: zknpr <96851588+zknpr@users.noreply.github.com>

Author: google-labs-jules[bot]

src/core/cancellation-utils.ts

@@ -0,0 +1,24 @@
+
+import type { CancellationToken } from 'vscode';
+
+/**
+ * Convert VS Code CancellationToken to standard AbortSignal.
+ *
+ * @param token - VS Code cancellation token (or null/undefined)
+ * @returns AbortSignal that triggers when token is cancelled
+ */
+export function cancelTokenToAbortSignal<T extends CancellationToken | null | undefined>(
+  token: T
+): T extends null | undefined ? undefined : AbortSignal {
+  if (token == null) return undefined as any;
+
+  const controller = new AbortController();
+  // We access properties on 'token' assuming it adheres to the CancellationToken interface.
+  // Since we only import it as a type, this code doesn't depend on the vscode module at runtime.
+  if (token.isCancellationRequested) {
+    controller.abort();
+  } else {
+    token.onCancellationRequested(() => controller.abort());
+  }
+  return controller.signal as any;
+}

src/helpers.ts

@@ -184,25 +184,7 @@ export function getUriParts(uri: string | vsc.Uri): {
 // Abort Signal Utilities
 // ============================================================================
 
-/**
- * Convert VS Code CancellationToken to standard AbortSignal.
- *
- * @param token - VS Code cancellation token (or null/undefined)
- * @returns AbortSignal that triggers when token is cancelled
- */
-export function cancelTokenToAbortSignal<T extends vsc.CancellationToken | null | undefined>(
-  token: T
-): T extends null ? undefined : AbortSignal {
-  if (token == null) return undefined as any;
-
-  const controller = new AbortController();
-  if (token.isCancellationRequested) {
-    controller.abort();
-  } else {
-    token.onCancellationRequested(() => controller.abort());
-  }
-  return controller.signal as any;
-}
+export { cancelTokenToAbortSignal } from './core/cancellation-utils';
 
 // ============================================================================
 // Cryptographic Utilities
@@ -337,4 +319,3 @@ export function toBoolString(value?: boolean | null): BoolString | undefined {
   if (value === false) return 'false';
   return undefined;
 }
-

tests/unit/cancellation-utils.test.ts

@@ -0,0 +1,56 @@
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { cancelTokenToAbortSignal } from '../../src/core/cancellation-utils';
+
+describe('Cancellation Utils', () => {
+    describe('cancelTokenToAbortSignal', () => {
+        it('should return undefined if token is null', () => {
+            assert.strictEqual(cancelTokenToAbortSignal(null), undefined);
+        });
+
+        it('should return undefined if token is undefined', () => {
+            assert.strictEqual(cancelTokenToAbortSignal(undefined), undefined);
+        });
+
+        it('should return AbortSignal if token is provided', () => {
+            const token: any = {
+                isCancellationRequested: false,
+                onCancellationRequested: () => {}
+            };
+            const signal = cancelTokenToAbortSignal(token);
+            assert.ok(signal instanceof AbortSignal);
+            assert.strictEqual(signal.aborted, false);
+        });
+
+        it('should abort if token is already cancelled', () => {
+            const token: any = {
+                isCancellationRequested: true,
+                onCancellationRequested: () => {}
+            };
+            const signal = cancelTokenToAbortSignal(token);
+            assert.ok(signal instanceof AbortSignal);
+            assert.strictEqual(signal.aborted, true);
+        });
+
+        it('should abort when token is cancelled later', () => {
+            let callback: (() => void) | undefined;
+            const token: any = {
+                isCancellationRequested: false,
+                onCancellationRequested: (cb: () => void) => {
+                    callback = cb;
+                    return { dispose: () => {} };
+                }
+            };
+
+            const signal = cancelTokenToAbortSignal(token);
+            assert.strictEqual(signal!.aborted, false);
+
+            // Simulate cancellation
+            assert.ok(callback);
+            callback();
+
+            assert.strictEqual(signal!.aborted, true);
+        });
+    });
+});