light-async-queue 1.1.0 → 2.0.1

package/README.md

@@ -7,19 +7,34 @@
 [![Node.js Version](https://img.shields.io/node/v/light-async-queue.svg)](https://nodejs.org)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue.svg)](https://www.typescriptlang.org/)
 
-A production-ready, Redis-free async job queue for Node.js with TypeScript. Designed for single-node reliability with file-based persistence, worker process isolation, and crash recovery.
+A production-ready, **Redis-free** async job queue for Node.js with TypeScript. A powerful BullMQ alternative designed for single-node reliability with file-based persistence, worker process isolation, and enterprise-grade features.
 
 ## ✨ Features
 
+### Core Features
+
 - **🔄 Reliable Job Processing** - File-based persistence with crash recovery
 - **👷 Worker Isolation** - Jobs execute in separate child processes using `child_process.fork()`
 - **🔁 Smart Retry Logic** - Exponential backoff with configurable attempts
 - **💀 Dead Letter Queue** - Failed jobs are preserved and can be reprocessed
 - **⚡ Concurrency Control** - Configurable parallel job execution
 - **🛡️ Graceful Shutdown** - Waits for active jobs before exiting
-- **📊 Queue Statistics** - Monitor active, pending, completed, and failed jobs
 - **🎯 TypeScript First** - Full type safety with no `any` types
-- **🪶 Zero Dependencies** - Uses only Node.js built-in modules
+- **🪶 Minimal Dependencies** - Only 2 runtime dependencies (`cron-parser`, `ws`)
+
+### Advanced Features (BullMQ Compatible)
+
+- **📢 Job Events** - Listen to waiting, active, completed, failed, progress, stalled events
+- **⏰ Delayed Jobs** - Schedule jobs to run after a delay
+- **🔄 Repeating Jobs** - Interval-based and cron-pattern recurring jobs
+- **🎯 Job Priorities** - High-priority jobs run first
+- **📊 Progress Tracking** - Real-time job progress updates
+- **🔗 Job Dependencies** - Jobs can wait for other jobs to complete
+- **⚡ Rate Limiting** - Control job execution rate
+- **🌐 Webhooks** - HTTP callbacks for job events
+- **⏱️ Stalled Job Detection** - Automatically detect and handle stuck jobs
+- **📈 Enhanced Metrics** - Detailed queue statistics by job status
+- **🖥️ HTML Dashboard** - Real-time web UI for monitoring (Zookeeper-style)
 
 ## 📦 Installation
 
@@ -91,7 +106,11 @@ Create a new queue instance.
 **Config Options:**
 
 ```typescript
-import { StorageType, BackoffStrategyType } from "light-async-queue";
+import {
+  StorageType,
+  BackoffStrategyType,
+  QueueEventType,
+} from "light-async-queue";
 
 interface QueueConfig {
   storage: StorageType;
@@ -104,32 +123,183 @@ interface QueueConfig {
       delay: number; // Base delay in ms
     };
   };
+  rateLimiter?: {
+    max: number; // Max jobs
+    duration: number; // Per duration in ms
+  };
+  webhooks?: Array<{
+    url: string;
+    events: QueueEventType[];
+    headers?: Record<string, string>;
+  }>;
+  stalledInterval?: number; // Check for stalled jobs every X ms (default: 30000)
 }
 ```
 
 ### `queue.process(processor)`
 
-Set the job processor function.
+Set the job processor function with progress tracking support.
 
 ```typescript
-queue.process(async (job: JobData) => {
-  // Process job
-  return result;
+queue.process(async (job) => {
+  // Access job data
+  console.log(job.payload);
+
+  // Report progress
+  await job.updateProgress(50);
+
+  // Log messages
+  job.log("Processing step 1");
+
+  // Return result
+  return { success: true };
 });
 ```
 
-### `queue.add(payload)`
+### `queue.add(payload, options?)`
 
-Add a job to the queue.
+Add a job to the queue with advanced options.
 
 ```typescript
-const jobId = await queue.add({
-  userId: 123,
-  action: "send-email",
+// Simple job
+const jobId = await queue.add({ userId: 123 });
+
+// Job with priority (higher = more important)
+await queue.add({ urgent: true }, { priority: 10 });
+
+// Delayed job (runs after delay)
+await queue.add({ task: "cleanup" }, { delay: 5000 });
+
+// Repeating job (every X milliseconds)
+await queue.add(
+  { type: "heartbeat" },
+  {
+    repeat: {
+      every: 60000, // Every minute
+      limit: 100, // Max 100 repetitions
+    },
+  },
+);
+
+// Cron-style repeating job
+await queue.add(
+  { type: "daily-report" },
+  {
+    repeat: {
+      pattern: "0 0 * * *", // Every day at midnight
+    },
+  },
+);
+
+// Job with dependencies
+const job1 = await queue.add({ step: 1 });
+await queue.add({ step: 2 }, { dependsOn: [job1] });
+
+// Custom job ID
+await queue.add({ data: "test" }, { jobId: "custom-id-123" });
+```
+
+### Queue Events
+
+Listen to job lifecycle events:
+
+```typescript
+import { QueueEventType } from "light-async-queue";
+
+queue.on(QueueEventType.WAITING, (job) => {
+  console.log("Job waiting for dependencies:", job.id);
+});
+
+queue.on(QueueEventType.DELAYED, (job) => {
+  console.log("Job delayed until:", new Date(job.nextRunAt));
+});
+
+queue.on(QueueEventType.ACTIVE, (job) => {
+  console.log("Job started:", job.id);
+});
+
+queue.on(QueueEventType.PROGRESS, (job, progress) => {
+  console.log(`Job ${job.id} progress: ${progress}%`);
 });
+
+queue.on(QueueEventType.COMPLETED, (job, result) => {
+  console.log("Job completed:", job.id, result);
+});
+
+queue.on(QueueEventType.FAILED, (job, error) => {
+  console.error("Job failed:", job.id, error.message);
+});
+
+queue.on(QueueEventType.STALLED, (job) => {
+  console.warn("Job appears stalled:", job.id);
+});
+
+queue.on(QueueEventType.DRAINED, () => {
+  console.log("Queue drained - all jobs processed");
+});
+
+queue.on(QueueEventType.ERROR, (error) => {
+  console.error("Queue error:", error);
+});
+```
+
+### Queue Methods
+
+#### `queue.getJob(jobId)`
+
+Get a specific job by ID.
+
+```typescript
+const job = await queue.getJob("job-id-123");
+if (job) {
+  console.log(job.status, job.progress);
+}
+```
+
+#### `queue.removeJob(jobId)`
+
+Remove a specific job (only if not currently active).
+
+```typescript
+const removed = await queue.removeJob("job-id-123");
 ```
 
-### `queue.getFailedJobs()`
+#### `queue.pause()`
+
+Pause job processing.
+
+```typescript
+queue.pause();
+```
+
+#### `queue.resume()`
+
+Resume job processing.
+
+```typescript
+queue.resume();
+```
+
+#### `queue.drain()`
+
+Wait for all pending jobs to be processed.
+
+```typescript
+await queue.drain();
+console.log("All jobs completed!");
+```
+
+#### `queue.clean(maxAge)`
+
+Remove completed jobs older than maxAge (in milliseconds).
+
+```typescript
+// Clean jobs older than 24 hours
+const cleaned = await queue.clean(24 * 60 * 60 * 1000);
+console.log(`Cleaned ${cleaned} old jobs`);
+```
+
+#### `queue.getFailedJobs()`
 
 Get all jobs in the Dead Letter Queue.
 
@@ -137,7 +307,7 @@ Get all jobs in the Dead Letter Queue.
 const failedJobs = await queue.getFailedJobs();
 ```
 
-### `queue.reprocessFailed(jobId)`
+#### `queue.reprocessFailed(jobId)`
 
 Reprocess a failed job from the DLQ.
 
@@ -145,21 +315,24 @@ Reprocess a failed job from the DLQ.
 await queue.reprocessFailed("job-id-here");
 ```
 
-### `queue.getStats()`
+#### `queue.getStats()`
 
-Get queue statistics.
+Get enhanced queue statistics.
 
 ```typescript
 const stats = await queue.getStats();
 // {
 //   active: 2,
+//   waiting: 1,
+//   delayed: 3,
 //   pending: 5,
 //   completed: 100,
-//   failed: 3
+//   failed: 3,
+//   stalled: 0
 // }
 ```
 
-### `queue.shutdown()`
+#### `queue.shutdown()`
 
 Gracefully shutdown the queue.
 
@@ -263,16 +436,106 @@ The queue handles `SIGINT` and `SIGTERM` signals:
 await queue.shutdown();
 ```
 
-## 📊 Comparison with Bull
+## �️ HTML Dashboard - Real-Time Monitoring
+
+### 🎥 Demo Video
+https://github.com/user-attachments/assets/a122ba9d-dcf5-4c21-9e92-99c8847ae836
+
+Light Async Queue includes a built-in HTML dashboard for real-time monitoring, similar to Zookeeper. The dashboard provides a modern, responsive web interface for tracking job statuses and managing your queue.
+
+### Quick Start
+
+```typescript
+import { Queue, Dashboard, StorageType } from "light-async-queue";
+
+const queue = new Queue({
+  storage: StorageType.FILE,
+  filePath: "./jobs.log",
+  concurrency: 3,
+  retry: {
+    /* ... */
+  },
+});
+
+// Create and start dashboard
+const dashboard = new Dashboard(queue, {
+  port: 3000,
+  host: "localhost",
+  updateInterval: 1000, // Update every 1 second
+});
+
+await dashboard.start();
+console.log("📊 Dashboard: http://localhost:3000");
+```
+
+### Dashboard Features
+
+- **📊 Real-time Statistics** - Live job counts (active, waiting, delayed, pending, completed, failed, stalled)
+- **📋 Job Tracking** - View active/waiting jobs with progress bars
+- **⚠️ Dead Letter Queue** - Monitor and retry failed jobs from the UI
+- **🔄 WebSocket Updates** - Fast, real-time data synchronization
+- **🎨 Modern UI** - Responsive design with color-coded status badges
+- **📈 Progress Visualization** - Track job completion with visual indicators
+
+### API Endpoints
+
+The dashboard exposes REST API endpoints:
+
+- `GET /` - HTML dashboard interface
+- `GET /api/stats` - Queue statistics (JSON)
+- `GET /api/jobs` - Active and waiting jobs
+- `GET /api/failed-jobs` - Failed jobs in DLQ
+- `POST /api/reprocess-failed` - Retry a failed job
+
+### Example Usage
 
-| Feature          | light-queue      | Bull                |
-| ---------------- | ---------------- | ------------------- |
-| Redis Required   | ❌ No            | ✅ Yes              |
-| File Persistence | ✅ Yes           | ❌ No               |
-| Worker Isolation | ✅ Child Process | ⚠️ Same Process     |
-| Crash Recovery   | ✅ Built-in      | ⚠️ Requires Redis   |
-| Setup Complexity | 🟢 Low           | 🟡 Medium           |
-| Best For         | Single-node apps | Distributed systems |
+See the [complete dashboard example](./example/dashboard-example.ts) for a working implementation with:
+
+- Real-time job processing
+- Progress tracking
+- Event handling
+- Failed job retry from UI
+
+```bash
+# Run the example
+npm run build:examples
+node dist/example/dashboard-example.js
+# Open http://localhost:3000
+```
+
+For detailed dashboard documentation, see [Dashboard README](./src/dashboard/README.md).
+
+## �📊 Comparison with BullMQ and Bull
+
+| Feature           | light-async-queue             | BullMQ           | Bull            |
+| ----------------- | ----------------------------- | ---------------- | --------------- |
+| Redis Required    | ❌ No                         | ✅ Yes           | ✅ Yes          |
+| File Persistence  | ✅ Yes                        | ❌ No            | ❌ No           |
+| Worker Isolation  | ✅ Child Process              | ⚠️ Same Process  | ⚠️ Same Process |
+| Crash Recovery    | ✅ Built-in                   | ⚠️ Needs Redis   | ⚠️ Needs Redis  |
+| Job Events        | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| Job Priorities    | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| Delayed Jobs      | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| Repeating Jobs    | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| Cron Patterns     | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| Job Dependencies  | ✅ Yes                        | ✅ Yes           | ❌ No           |
+| Progress Tracking | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| Rate Limiting     | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| Webhooks          | ✅ Yes                        | ❌ No            | ❌ No           |
+| Stalled Detection | ✅ Yes                        | ✅ Yes           | ✅ Yes          |
+| HTML Dashboard    | ✅ Built-in                   | ⚠️ Bull Board    | ⚠️ Bull Board   |
+| Setup Complexity  | 🟢 Low                        | 🟡 Medium        | 🟡 Medium       |
+| Dependencies      | 🟢 Minimal (cron-parser + ws) | 🔴 Redis + deps  | 🔴 Redis + deps |
+| Best For          | Single-node apps              | Distributed apps | Legacy apps     |
+
+**Why choose light-async-queue?**
+
+- ✅ No Redis infrastructure or maintenance
+- ✅ Built-in crash recovery with file persistence
+- ✅ True process isolation for better fault tolerance
+- ✅ Minimal runtime dependencies (`cron-parser`, `ws`)
+- ✅ Perfect for edge deployments, serverless, or single-server apps
+- ✅ All BullMQ features without the complexity
 
 ## 🎯 Use Cases
 
@@ -281,7 +544,7 @@ Perfect for:
 - **Single-server applications** that don't need Redis
 - **Background job processing** (emails, reports, etc.)
 - **Reliable task queues** with crash recovery
-- **Development environments** without external dependencies
+- **Development environments** with minimal external dependencies
 - **Edge deployments** where Redis isn't available
 
 ## 🔧 Advanced Example
@@ -357,10 +620,27 @@ npm run build
 npm run example
 ```
 
-**Test Results:** ✅ 42 tests passing across 4 test suites (powered by Vitest)
+**Test Results:** ✅ 85+ tests passing across 8 test suites (powered by Vitest)
 
 See [TEST_SUITE.md](./TEST_SUITE.md) for detailed test documentation.
 
+## 📚 Examples
+
+Check out the `example/` directory for comprehensive examples:
+
+- **[basic.ts](./example/basic.ts)** - Simple queue setup and job processing
+- **[concurrency.ts](./example/concurrency.ts)** - Concurrent job processing
+- **[crash-recovery.ts](./example/crash-recovery.ts)** - Crash recovery demonstration
+- **[advanced-features.ts](./example/advanced-features.ts)** - All BullMQ-compatible features:
+  - Job events and listeners
+  - Job priorities
+  - Delayed and repeating jobs
+  - Cron patterns
+  - Job dependencies
+  - Progress tracking
+  - Rate limiting
+  - Webhooks
+
 ## 📝 License
 
 MIT

package/dist/src/constants.d.ts

@@ -3,10 +3,13 @@
  * Represents the different states a job can be in
  */
 export declare enum JobStatus {
-    PENDING = "pending",
-    PROCESSING = "processing",
-    COMPLETED = "completed",
-    FAILED = "failed"
+    WAITING = "waiting",// Waiting to be picked up (new default)
+    DELAYED = "delayed",// Scheduled for future execution
+    PENDING = "pending",// Ready to be processed
+    PROCESSING = "processing",// Currently being processed
+    COMPLETED = "completed",// Successfully completed
+    FAILED = "failed",// Failed after all retries
+    STALLED = "stalled"
 }
 /**
  * Backoff Strategy Type Enum
@@ -44,6 +47,22 @@ export declare enum WorkerResponseType {
  * Special signals for worker communication
  */
 export declare enum WorkerSignalType {
-    READY = "ready"
+    READY = "ready",
+    PROGRESS = "progress"
+}
+/**
+ * Queue Event Type Enum
+ * Events emitted by the queue
+ */
+export declare enum QueueEventType {
+    WAITING = "waiting",
+    DELAYED = "delayed",
+    ACTIVE = "active",
+    PROGRESS = "progress",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    STALLED = "stalled",
+    DRAINED = "drained",
+    ERROR = "error"
 }
 //# sourceMappingURL=constants.d.ts.map

package/dist/src/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,SAAS;IACnB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,MAAM,WAAW;CAClB;AAED;;;GAGG;AACH,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;IAC3B,KAAK,UAAU;CAChB;AAED;;;GAGG;AACH,oBAAY,WAAW;IACrB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED;;;GAGG;AACH,oBAAY,iBAAiB;IAC3B,OAAO,YAAY;IACnB,aAAa,iBAAiB;CAC/B;AAED;;;GAGG;AACH,oBAAY,kBAAkB;IAC5B,MAAM,WAAW;CAClB;AAED;;;GAGG;AACH,oBAAY,gBAAgB;IAC1B,KAAK,UAAU;CAChB"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,SAAS;IACnB,OAAO,YAAY,CAAO,wCAAwC;IAClE,OAAO,YAAY,CAAO,iCAAiC;IAC3D,OAAO,YAAY,CAAO,wBAAwB;IAClD,UAAU,eAAe,CAAE,4BAA4B;IACvD,SAAS,cAAc,CAAI,yBAAyB;IACpD,MAAM,WAAW,CAAU,2BAA2B;IACtD,OAAO,YAAY;CACpB;AAED;;;GAGG;AACH,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;IAC3B,KAAK,UAAU;CAChB;AAED;;;GAGG;AACH,oBAAY,WAAW;IACrB,MAAM,WAAW;IACjB,IAAI,SAAS;CACd;AAED;;;GAGG;AACH,oBAAY,iBAAiB;IAC3B,OAAO,YAAY;IACnB,aAAa,iBAAiB;CAC/B;AAED;;;GAGG;AACH,oBAAY,kBAAkB;IAC5B,MAAM,WAAW;CAClB;AAED;;;GAGG;AACH,oBAAY,gBAAgB;IAC1B,KAAK,UAAU;IACf,QAAQ,aAAa;CACtB;AAED;;;GAGG;AACH,oBAAY,cAAc;IACxB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,KAAK,UAAU;CAChB"}

package/dist/src/constants.js

@@ -4,10 +4,13 @@
  */
 export var JobStatus;
 (function (JobStatus) {
+    JobStatus["WAITING"] = "waiting";
+    JobStatus["DELAYED"] = "delayed";
     JobStatus["PENDING"] = "pending";
     JobStatus["PROCESSING"] = "processing";
     JobStatus["COMPLETED"] = "completed";
     JobStatus["FAILED"] = "failed";
+    JobStatus["STALLED"] = "stalled";
 })(JobStatus || (JobStatus = {}));
 /**
  * Backoff Strategy Type Enum
@@ -51,5 +54,22 @@ export var WorkerResponseType;
 export var WorkerSignalType;
 (function (WorkerSignalType) {
     WorkerSignalType["READY"] = "ready";
+    WorkerSignalType["PROGRESS"] = "progress";
 })(WorkerSignalType || (WorkerSignalType = {}));
+/**
+ * Queue Event Type Enum
+ * Events emitted by the queue
+ */
+export var QueueEventType;
+(function (QueueEventType) {
+    QueueEventType["WAITING"] = "waiting";
+    QueueEventType["DELAYED"] = "delayed";
+    QueueEventType["ACTIVE"] = "active";
+    QueueEventType["PROGRESS"] = "progress";
+    QueueEventType["COMPLETED"] = "completed";
+    QueueEventType["FAILED"] = "failed";
+    QueueEventType["STALLED"] = "stalled";
+    QueueEventType["DRAINED"] = "drained";
+    QueueEventType["ERROR"] = "error";
+})(QueueEventType || (QueueEventType = {}));
 //# sourceMappingURL=constants.js.map

package/dist/src/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAN,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,gCAAmB,CAAA;IACnB,sCAAyB,CAAA;IACzB,oCAAuB,CAAA;IACvB,8BAAiB,CAAA;AACnB,CAAC,EALW,SAAS,KAAT,SAAS,QAKpB;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,mBAGX;AAHD,WAAY,mBAAmB;IAC7B,kDAA2B,CAAA;IAC3B,sCAAe,CAAA;AACjB,CAAC,EAHW,mBAAmB,KAAnB,mBAAmB,QAG9B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,gCAAiB,CAAA;IACjB,4BAAa,CAAA;AACf,CAAC,EAHW,WAAW,KAAX,WAAW,QAGtB;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,wCAAmB,CAAA;IACnB,mDAA8B,CAAA;AAChC,CAAC,EAHW,iBAAiB,KAAjB,iBAAiB,QAG5B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,kBAEX;AAFD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;AACnB,CAAC,EAFW,kBAAkB,KAAlB,kBAAkB,QAE7B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,gBAEX;AAFD,WAAY,gBAAgB;IAC1B,mCAAe,CAAA;AACjB,CAAC,EAFW,gBAAgB,KAAhB,gBAAgB,QAE3B"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAN,IAAY,SAQX;AARD,WAAY,SAAS;IACnB,gCAAmB,CAAA;IACnB,gCAAmB,CAAA;IACnB,gCAAmB,CAAA;IACnB,sCAAyB,CAAA;IACzB,oCAAuB,CAAA;IACvB,8BAAiB,CAAA;IACjB,gCAAmB,CAAA;AACrB,CAAC,EARW,SAAS,KAAT,SAAS,QAQpB;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,mBAGX;AAHD,WAAY,mBAAmB;IAC7B,kDAA2B,CAAA;IAC3B,sCAAe,CAAA;AACjB,CAAC,EAHW,mBAAmB,KAAnB,mBAAmB,QAG9B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,gCAAiB,CAAA;IACjB,4BAAa,CAAA;AACf,CAAC,EAHW,WAAW,KAAX,WAAW,QAGtB;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,wCAAmB,CAAA;IACnB,mDAA8B,CAAA;AAChC,CAAC,EAHW,iBAAiB,KAAjB,iBAAiB,QAG5B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,kBAEX;AAFD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;AACnB,CAAC,EAFW,kBAAkB,KAAlB,kBAAkB,QAE7B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,mCAAe,CAAA;IACf,yCAAqB,CAAA;AACvB,CAAC,EAHW,gBAAgB,KAAhB,gBAAgB,QAG3B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,cAUX;AAVD,WAAY,cAAc;IACxB,qCAAmB,CAAA;IACnB,qCAAmB,CAAA;IACnB,mCAAiB,CAAA;IACjB,uCAAqB,CAAA;IACrB,yCAAuB,CAAA;IACvB,mCAAiB,CAAA;IACjB,qCAAmB,CAAA;IACnB,qCAAmB,CAAA;IACnB,iCAAe,CAAA;AACjB,CAAC,EAVW,cAAc,KAAd,cAAc,QAUzB"}

package/dist/src/dashboard/Dashboard.d.ts

@@ -0,0 +1,70 @@
+import { Queue } from "../queue/Queue.js";
+export interface DashboardConfig {
+    port: number;
+    host?: string;
+    updateInterval?: number;
+}
+export declare class Dashboard {
+    private queue;
+    private server;
+    private wss;
+    private updateInterval;
+    private config;
+    private clients;
+    private htmlTemplate;
+    constructor(queue: Queue, config: DashboardConfig);
+    /**
+     * Start the dashboard server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the dashboard server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle HTTP requests
+     */
+    private handleRequest;
+    /**
+     * Serve the HTML dashboard
+     */
+    private serveHTML;
+    /**
+     * Generate HTML dashboard
+     */
+    private generateHTML;
+    private loadTemplate;
+    /**
+     * Setup WebSocket handlers
+     */
+    private setupWebSocketHandlers;
+    /**
+     * Serve stats API
+     */
+    private serveStats;
+    /**
+     * Serve jobs list
+     */
+    private serveJobs;
+    /**
+     * Serve failed jobs
+     */
+    private serveFailedJobs;
+    /**
+     * Handle reprocess failed job request
+     */
+    private handleReprocessFailed;
+    /**
+     * Send stats to a specific client
+     */
+    private sendStatsToClient;
+    /**
+     * Broadcast stats to all clients
+     */
+    private broadcastStats;
+    /**
+     * Start periodic update interval
+     */
+    private startUpdateInterval;
+}
+//# sourceMappingURL=Dashboard.d.ts.map

package/dist/src/dashboard/Dashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dashboard.d.ts","sourceRoot":"","sources":["../../../src/dashboard/Dashboard.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG1C,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,YAAY,CAAS;gBAEjB,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe;IAkBjD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B;;OAEG;IACH,OAAO,CAAC,aAAa;IAiBrB;;OAEG;IACH,OAAO,CAAC,SAAS;IAMjB;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,YAAY;IAUpB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;OAEG;IACH,OAAO,CAAC,UAAU;IAqBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IA0BjB;;OAEG;IACH,OAAO,CAAC,eAAe;IAkBvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA0C7B;;OAEG;YACW,iBAAiB;IAiC/B;;OAEG;YACW,cAAc;IAyC5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAO5B"}