fix: resolve lint issues in process-lock

Remove unused vi import and fix numeric separator usage per linting rules.

Author: jdalton

src/process-lock.ts

@@ -157,7 +157,7 @@ class ProcessLockManager {
   ): Promise<() => void> {
     const {
       baseDelayMs = 100,
-      maxDelayMs = 1_000,
+      maxDelayMs = 1000,
       retries = 3,
       staleMs = 10_000,
     } = options

test/process-lock.test.ts

@@ -6,7 +6,7 @@
 import { existsSync, mkdirSync, statSync, utimesSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
 import { safeDelete } from '../src/fs'
 import { processLock } from '../src/process-lock'
@@ -19,7 +19,10 @@ describe('process-lock', () => {
 
   beforeEach(() => {
     // Create unique test directory for each test.
-    testDir = path.join(tmpdir(), `process-lock-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+    testDir = path.join(
+      tmpdir(),
+      `process-lock-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    )
     lockPath = path.join(testDir, 'test.lock')
 
     // Ensure test directory exists.
@@ -51,7 +54,9 @@ describe('process-lock', () => {
 
       try {
         // Second acquire should fail after retries.
-        await expect(processLock.acquire(lockPath, { retries: 1, baseDelayMs: 10 })).rejects.toThrow(/Lock already exists/)
+        await expect(
+          processLock.acquire(lockPath, { retries: 1, baseDelayMs: 10 }),
+        ).rejects.toThrow(/Lock already exists/)
       } finally {
         release1()
       }
@@ -101,18 +106,20 @@ describe('process-lock', () => {
     it('should respect custom stale timeout', async () => {
       // Create a lock that's 6 seconds old.
       mkdirSync(lockPath)
-      const sixSecondsAgo = Date.now() - 6_000
+      const sixSecondsAgo = Date.now() - 6000
       utimesSync(lockPath, new Date(sixSecondsAgo), new Date(sixSecondsAgo))
 
       // With 10s stale timeout, should not be stale yet.
-      await expect(processLock.acquire(lockPath, {
-        retries: 1,
-        baseDelayMs: 10,
-        staleMs: 10_000,
-      })).rejects.toThrow()
+      await expect(
+        processLock.acquire(lockPath, {
+          retries: 1,
+          baseDelayMs: 10,
+          staleMs: 10_000,
+        }),
+      ).rejects.toThrow()
 
       // With 5s stale timeout, should be stale and acquirable.
-      const release = await processLock.acquire(lockPath, { staleMs: 5_000 })
+      const release = await processLock.acquire(lockPath, { staleMs: 5000 })
       expect(existsSync(lockPath)).toBe(true)
 
       release()
@@ -170,10 +177,12 @@ describe('process-lock', () => {
     })
 
     it('should release lock even if callback throws', async () => {
-      await expect(processLock.withLock(lockPath, async () => {
-        expect(existsSync(lockPath)).toBe(true)
-        throw new Error('Test error')
-      })).rejects.toThrow('Test error')
+      await expect(
+        processLock.withLock(lockPath, async () => {
+          expect(existsSync(lockPath)).toBe(true)
+          throw new Error('Test error')
+        }),
+      ).rejects.toThrow('Test error')
 
       // Lock should be released despite error.
       expect(existsSync(lockPath)).toBe(false)
@@ -183,20 +192,28 @@ describe('process-lock', () => {
       const executionOrder: string[] = []
 
       // Start two withLock calls concurrently.
-      const promise1 = processLock.withLock(lockPath, async () => {
-        executionOrder.push('start-1')
-        await new Promise(resolve => setTimeout(resolve, 100))
-        executionOrder.push('end-1')
-      }, { retries: 10, baseDelayMs: 20 })
+      const promise1 = processLock.withLock(
+        lockPath,
+        async () => {
+          executionOrder.push('start-1')
+          await new Promise(resolve => setTimeout(resolve, 100))
+          executionOrder.push('end-1')
+        },
+        { retries: 10, baseDelayMs: 20 },
+      )
 
       // Small delay to ensure first lock is acquired.
       await new Promise(resolve => setTimeout(resolve, 10))
 
-      const promise2 = processLock.withLock(lockPath, async () => {
-        executionOrder.push('start-2')
-        await new Promise(resolve => setTimeout(resolve, 50))
-        executionOrder.push('end-2')
-      }, { retries: 10, baseDelayMs: 20 })
+      const promise2 = processLock.withLock(
+        lockPath,
+        async () => {
+          executionOrder.push('start-2')
+          await new Promise(resolve => setTimeout(resolve, 50))
+          executionOrder.push('end-2')
+        },
+        { retries: 10, baseDelayMs: 20 },
+      )
 
       await Promise.all([promise1, promise2])
 
@@ -209,13 +226,17 @@ describe('process-lock', () => {
         retries: 5,
         baseDelayMs: 50,
         maxDelayMs: 200,
-        staleMs: 5_000,
+        staleMs: 5000,
       }
 
       let executed = false
-      await processLock.withLock(lockPath, async () => {
-        executed = true
-      }, options)
+      await processLock.withLock(
+        lockPath,
+        async () => {
+          executed = true
+        },
+        options,
+      )
 
       expect(executed).toBe(true)
     })
@@ -226,12 +247,20 @@ describe('process-lock', () => {
       // Create stale lock (15 seconds old).
       mkdirSync(lockPath)
       const fifteenSecondsAgo = Date.now() - 15_000
-      utimesSync(lockPath, new Date(fifteenSecondsAgo), new Date(fifteenSecondsAgo))
+      utimesSync(
+        lockPath,
+        new Date(fifteenSecondsAgo),
+        new Date(fifteenSecondsAgo),
+      )
 
       // Should remove stale lock and acquire.
-      const release = await processLock.withLock(lockPath, async () => {
-        return 'acquired'
-      }, { staleMs: 10_000 })
+      const release = await processLock.withLock(
+        lockPath,
+        async () => {
+          return 'acquired'
+        },
+        { staleMs: 10_000 },
+      )
 
       expect(release).toBe('acquired')
       expect(existsSync(lockPath)).toBe(false)
@@ -243,10 +272,12 @@ describe('process-lock', () => {
 
       try {
         // Attempt to acquire with low retry count should fail.
-        await expect(processLock.acquire(lockPath, {
-          retries: 1,
-          baseDelayMs: 10,
-        })).rejects.toThrow()
+        await expect(
+          processLock.acquire(lockPath, {
+            retries: 1,
+            baseDelayMs: 10,
+          }),
+        ).rejects.toThrow()
       } finally {
         release1()
       }
@@ -291,16 +322,20 @@ describe('process-lock', () => {
       // Use a path we definitely can't write to.
       const invalidPath = '/root/socket-test-lock-no-permission'
 
-      await expect(processLock.acquire(invalidPath, {
-        retries: 1,
-        baseDelayMs: 10,
-      })).rejects.toThrow()
+      await expect(
+        processLock.acquire(invalidPath, {
+          retries: 1,
+          baseDelayMs: 10,
+        }),
+      ).rejects.toThrow()
     })
 
     it('should clean up on errors', async () => {
-      await expect(processLock.withLock(lockPath, async () => {
-        throw new Error('Intentional error')
-      })).rejects.toThrow('Intentional error')
+      await expect(
+        processLock.withLock(lockPath, async () => {
+          throw new Error('Intentional error')
+        }),
+      ).rejects.toThrow('Intentional error')
 
       // Lock should be cleaned up.
       expect(existsSync(lockPath)).toBe(false)