Concurrent Upload Limiter

class ConcurrentUploadLimiter {
  private queue: Array<() => Promise<void>> = [];
  private running = 0;
  private maxConcurrent: number;

  constructor(maxConcurrent = 3) {
    this.maxConcurrent = maxConcurrent;
  }

  async add(uploadFn: () => Promise<void>): Promise<void> {
    return new Promise((resolve, reject) => {
      this.queue.push(async () => {
        try {
          await uploadFn();
          resolve();
        } catch (error) {
          reject(error);
        }
      });

      this.process();
    });
  }

  private async process(): Promise<void> {
    if (this.running >= this.maxConcurrent || this.queue.length === 0) {
      return;
    }

    this.running++;
    const task = this.queue.shift();

    if (task) {
      try {
        await task();
      } finally {
        this.running--;
        this.process(); // Process next in queue
      }
    }
  }
}

// Usage
async function uploadFiles(files: File[]): Promise<void> {
  const limiter = new ConcurrentUploadLimiter(3); // Max 3 at once

  const uploads = files.map((file, index) => 
    limiter.add(async () => {
      console.log(`Starting upload ${index + 1}/${files.length}: ${file.name}`);
      await uploadFile(file);
      console.log(`Completed ${index + 1}/${files.length}`);
    })
  );

  await Promise.all(uploads);
  console.log('All uploads complete');
}

async function uploadFile(file: File): Promise<void> {
  const formData = new FormData();
  formData.append('file', file);

  const response = await fetch('/api/upload', {
    method: 'POST',
    body: formData
  });

  if (!response.ok) {
    throw new Error(`Upload failed: ${response.statusText}`);
  }
}

// Alternative: Using p-limit library pattern
class PromiseQueue {
  private maxConcurrent: number;
  private running = 0;
  private queue: Array<{
    fn: () => Promise<unknown>;
    resolve: (value: unknown) => void;
    reject: (error: unknown) => void;
  }> = [];

  constructor(maxConcurrent = 3) {
    this.maxConcurrent = maxConcurrent;
  }

  async run<T>(fn: () => Promise<T>): Promise<T> {
    return new Promise((resolve, reject) => {
      this.queue.push({ fn, resolve, reject });
      this.tryExecute();
    });
  }

  private async tryExecute(): Promise<void> {
    if (this.running >= this.maxConcurrent || this.queue.length === 0) {
      return;
    }

    this.running++;
    const { fn, resolve, reject } = this.queue.shift()!;

    try {
      const result = await fn();
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.running--;
      this.tryExecute();
    }
  }
}

// With progress tracking
interface UploadProgress {
  total: number;
  completed: number;
  failed: number;
  inProgress: number;
}

class UploadQueue {
  private limiter: ConcurrentUploadLimiter;
  private progress: UploadProgress;
  private onProgress?: (progress: UploadProgress) => void;

  constructor(maxConcurrent = 3, onProgress?: (progress: UploadProgress) => void) {
    this.limiter = new ConcurrentUploadLimiter(maxConcurrent);
    this.onProgress = onProgress;
    this.progress = { total: 0, completed: 0, failed: 0, inProgress: 0 };
  }

  async uploadFiles(files: File[]): Promise<void> {
    this.progress.total = files.length;
    this.notifyProgress();

    const uploads = files.map((file) =>
      this.limiter.add(async () => {
        this.progress.inProgress++;
        this.notifyProgress();

        try {
          await uploadFile(file);
          this.progress.completed++;
        } catch (error) {
          this.progress.failed++;
          console.error(`Failed to upload ${file.name}:`, error);
        } finally {
          this.progress.inProgress--;
          this.notifyProgress();
        }
      })
    );

    await Promise.all(uploads);
  }

  private notifyProgress(): void {
    this.onProgress?.(this.progress);
  }
}

// Usage with progress
const queue = new UploadQueue(3, (progress) => {
  console.log(`Progress: ${progress.completed}/${progress.total}`);
  console.log(`In progress: ${progress.inProgress}, Failed: ${progress.failed}`);
});

await queue.uploadFiles(files);