light-async-queue 1.0.1 → 2.0.0

package/README.md

@@ -7,19 +7,41 @@
 [![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.
+
+## 🎥 Demo Video
+
+GitHub README often does not render local `.mp4` files inline. Use the direct raw link:
+
+- [▶️ Watch dashboard demo (streamable MP4)](https://raw.githubusercontent.com/gaikwadakshay79/light-async-queue/main/Light-Async-Queue-Dashboard.mp4)
+- [📁 Repo file link](./Light-Async-Queue-Dashboard.mp4)
 
 ## ✨ 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
 
@@ -49,17 +71,17 @@ The queue follows a producer-consumer pattern with the following components:
 ## 🚀 Quick Start
 
 ```typescript
-import { Queue } from "light-async-queue";
+import { Queue, StorageType, BackoffStrategyType } from "light-async-queue";
 
 // Create a queue
 const queue = new Queue({
-  storage: "file",
+  storage: StorageType.FILE,
   filePath: "./jobs.log",
   concurrency: 3,
   retry: {
     maxAttempts: 5,
     backoff: {
-      type: "exponential",
+      type: BackoffStrategyType.EXPONENTIAL,
       delay: 1000, // 1 second base delay
     },
   },
@@ -91,43 +113,200 @@ Create a new queue instance.
 **Config Options:**
 
 ```typescript
+import {
+  StorageType,
+  BackoffStrategyType,
+  QueueEventType,
+} from "light-async-queue";
+
 interface QueueConfig {
-  storage: "memory" | "file";
-  filePath?: string; // Required if storage is 'file'
+  storage: StorageType;
+  filePath?: string; // Required if storage is StorageType.FILE
   concurrency: number; // Max parallel jobs
   retry: {
     maxAttempts: number;
     backoff: {
-      type: "exponential";
+      type: BackoffStrategyType;
       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.getFailedJobs()`
+#### `queue.removeJob(jobId)`
+
+Remove a specific job (only if not currently active).
+
+```typescript
+const removed = await queue.removeJob("job-id-123");
+```
+
+#### `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.
 
@@ -135,7 +314,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.
 
@@ -143,21 +322,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.
 
@@ -190,8 +372,10 @@ After `maxAttempts`, jobs move to the Dead Letter Queue.
 Fast, in-memory storage for development:
 
 ```typescript
+import { Queue, StorageType } from "light-async-queue";
+
 const queue = new Queue({
-  storage: "memory",
+  storage: StorageType.MEMORY,
   concurrency: 5,
   retry: {
     /* ... */
@@ -204,8 +388,10 @@ const queue = new Queue({
 Persistent, crash-recoverable storage for production:
 
 ```typescript
+import { Queue, StorageType } from "light-async-queue";
+
 const queue = new Queue({
-  storage: "file",
+  storage: StorageType.FILE,
   filePath: "./jobs.log",
   concurrency: 5,
   retry: {
@@ -257,16 +443,103 @@ The queue handles `SIGINT` and `SIGTERM` signals:
 await queue.shutdown();
 ```
 
-## 📊 Comparison with Bull
+## �️ HTML Dashboard - Real-Time Monitoring
+
+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
 
-| 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 |
+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
+
+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
 
@@ -275,22 +548,22 @@ 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
 
 ```typescript
-import { Queue } from "light-async-queue";
+import { Queue, StorageType, BackoffStrategyType } from "light-async-queue";
 
 const queue = new Queue({
-  storage: "file",
+  storage: StorageType.FILE,
   filePath: "./production-jobs.log",
   concurrency: 10,
   retry: {
     maxAttempts: 3,
     backoff: {
-      type: "exponential",
+      type: BackoffStrategyType.EXPONENTIAL,
       delay: 2000,
     },
   },
@@ -351,10 +624,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
@@ -363,6 +653,10 @@ MIT
 
 Contributions welcome! This is a production-ready implementation focused on reliability and simplicity.
 
+## 📦 Publishing
+
+This package uses [npm trusted publishing](https://docs.npmjs.com/generating-provenance-statements) for secure, token-free releases from GitHub Actions. Publishes are automatically triggered when version tags are pushed (e.g., `v1.0.0`). See [TRUSTED_PUBLISHING.md](./TRUSTED_PUBLISHING.md) for detailed setup instructions.
+
 ---
 
 Built with ❤️ for Node.js developers who need reliable job queues without Redis.

package/dist/src/constants.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Job Status Enum
+ * Represents the different states a job can be in
+ */
+export declare enum JobStatus {
+    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
+ * Determines how to calculate delay between retries
+ */
+export declare enum BackoffStrategyType {
+    EXPONENTIAL = "exponential",
+    FIXED = "fixed"
+}
+/**
+ * Storage Type Enum
+ * Determines the storage backend for the queue
+ */
+export declare enum StorageType {
+    MEMORY = "memory",
+    FILE = "file"
+}
+/**
+ * Worker Message Type Enum
+ * Types of messages sent from parent to child worker process
+ */
+export declare enum WorkerMessageType {
+    EXECUTE = "execute",
+    SET_PROCESSOR = "setProcessor"
+}
+/**
+ * Worker Response Type Enum
+ * Types of responses sent from child to parent worker process
+ */
+export declare enum WorkerResponseType {
+    RESULT = "result"
+}
+/**
+ * Worker Signal Type Enum
+ * Special signals for worker communication
+ */
+export declare enum WorkerSignalType {
+    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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,75 @@
+/**
+ * Job Status Enum
+ * Represents the different states a job can be in
+ */
+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
+ * Determines how to calculate delay between retries
+ */
+export var BackoffStrategyType;
+(function (BackoffStrategyType) {
+    BackoffStrategyType["EXPONENTIAL"] = "exponential";
+    BackoffStrategyType["FIXED"] = "fixed";
+})(BackoffStrategyType || (BackoffStrategyType = {}));
+/**
+ * Storage Type Enum
+ * Determines the storage backend for the queue
+ */
+export var StorageType;
+(function (StorageType) {
+    StorageType["MEMORY"] = "memory";
+    StorageType["FILE"] = "file";
+})(StorageType || (StorageType = {}));
+/**
+ * Worker Message Type Enum
+ * Types of messages sent from parent to child worker process
+ */
+export var WorkerMessageType;
+(function (WorkerMessageType) {
+    WorkerMessageType["EXECUTE"] = "execute";
+    WorkerMessageType["SET_PROCESSOR"] = "setProcessor";
+})(WorkerMessageType || (WorkerMessageType = {}));
+/**
+ * Worker Response Type Enum
+ * Types of responses sent from child to parent worker process
+ */
+export var WorkerResponseType;
+(function (WorkerResponseType) {
+    WorkerResponseType["RESULT"] = "result";
+})(WorkerResponseType || (WorkerResponseType = {}));
+/**
+ * Worker Signal Type Enum
+ * Special signals for worker communication
+ */
+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

@@ -0,0 +1 @@
+{"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"}