Format without eclint

frontend/sync-client/src/utils/data-structures/locks.ts

@@ -21,34 +21,34 @@ export class Locks<T> {
     public constructor(private readonly logger?: Logger) {}
 
     /**
-    * Executes a function while holding exclusive locks on one or more keys.
-    *
-    * This method ensures that the provided function runs with exclusive access to the
-    * specified key(s). Multiple keys are sorted to prevent deadlocks when different
-    * operations request the same keys in different orders.
-    *
-    * @template R The return type of the function to execute
-    * @param keyOrKeys A single key or array of keys to lock during function execution
-    * @param fn The function to execute while holding the lock(s). Can be sync or async.
-    * @returns A Promise that resolves to the return value of the executed function
-    *
-    * @example
-    * ```typescript
-    * // Lock a single key
-    * const result = await locks.withLock('file1', () => {
-    *   // Critical section - only one operation can access 'file1' at a time
-    *   return processFile('file1');
-    * });
-    *
-    * // Lock multiple keys (prevents deadlocks through consistent ordering)
-    * await locks.withLock(['file1', 'file2'], async () => {
-    *   // Critical section - exclusive access to both files
-    *   await moveFile('file1', 'file2');
-    * });
-    * ```
-    *
-    * @throws Any error thrown by the provided function will be propagated after locks are released
-    */
+     * Executes a function while holding exclusive locks on one or more keys.
+     *
+     * This method ensures that the provided function runs with exclusive access to the
+     * specified key(s). Multiple keys are sorted to prevent deadlocks when different
+     * operations request the same keys in different orders.
+     *
+     * @template R The return type of the function to execute
+     * @param keyOrKeys A single key or array of keys to lock during function execution
+     * @param fn The function to execute while holding the lock(s). Can be sync or async.
+     * @returns A Promise that resolves to the return value of the executed function
+     *
+     * @example
+     * ```typescript
+     * // Lock a single key
+     * const result = await locks.withLock('file1', () => {
+     *   // Critical section - only one operation can access 'file1' at a time
+     *   return processFile('file1');
+     * });
+     *
+     * // Lock multiple keys (prevents deadlocks through consistent ordering)
+     * await locks.withLock(['file1', 'file2'], async () => {
+     *   // Critical section - exclusive access to both files
+     *   await moveFile('file1', 'file2');
+     * });
+     * ```
+     *
+     * @throws Any error thrown by the provided function will be propagated after locks are released
+     */
     public async withLock<R>(
         keyOrKeys: T | T[],
         fn: () => R | Promise<R>
@@ -83,12 +83,12 @@ export class Locks<T> {
     }
 
     /**
-    * Attempts to acquire a lock immediately without waiting.
-    * Must call `unlock()` if successful.
-    *
-    * @param key The key to lock
-    * @returns `true` if lock acquired, `false` if already locked
-    */
+     * Attempts to acquire a lock immediately without waiting.
+     * Must call `unlock()` if successful.
+     *
+     * @param key The key to lock
+     * @returns `true` if lock acquired, `false` if already locked
+     */
     public tryLock(key: T): boolean {
         if (this.locked.has(key)) {
             return false;
@@ -100,12 +100,12 @@ export class Locks<T> {
     }
 
     /**
-    * Waits to acquire a lock, blocking until available.
-    * Operations are queued in FIFO order. Must call `unlock()` when done.
-    *
-    * @param key The key to wait for and lock
-    * @returns Promise that resolves when lock is acquired
-    */
+     * Waits to acquire a lock, blocking until available.
+     * Operations are queued in FIFO order. Must call `unlock()` when done.
+     *
+     * @param key The key to wait for and lock
+     * @returns Promise that resolves when lock is acquired
+     */
     public async waitForLock(key: T): Promise<void> {
         if (this.tryLock(key)) {
             return Promise.resolve();
@@ -126,12 +126,12 @@ export class Locks<T> {
     }
 
     /**
-    * Releases a lock and grants access to the next waiting operation in FIFO order.
-    * Removes the key from locked set if no waiters.
-    *
-    * @param key The key to unlock
-    * @throws {Error} If key is not currently locked
-    */
+     * Releases a lock and grants access to the next waiting operation in FIFO order.
+     * Removes the key from locked set if no waiters.
+     *
+     * @param key The key to unlock
+     * @throws {Error} If key is not currently locked
+     */
     public unlock(key: T): void {
         if (!this.locked.has(key)) {
             return;