@atmosx/event-product-parser 3.0.62 → 3.0.63

package/src/@modules/@eas/GetSampledPCM16.ts

@@ -18,17 +18,23 @@
     
 */
 
-export const GetSampledPCM16 = (int16: Int16Array, originalRate: number, targetRate: number): Int16Array => {
-    if (originalRate === targetRate) return int16;
-    const ratio = targetRate / originalRate;
-    const outLen = Math.max(1, Math.round(int16.length * ratio));
+interface GetSampledPCM16Options {
+    Int16: Int16Array
+    OriginalRate: number
+    TargetRate: number
+}
+
+export const GetSampledPCM16 = ({ Int16, OriginalRate, TargetRate }: GetSampledPCM16Options): Int16Array => {
+    if (OriginalRate === TargetRate) return Int16;
+    const ratio = TargetRate / OriginalRate;
+    const outLen = Math.max(1, Math.round(Int16.length * ratio));
     const out = new Int16Array(outLen);
     for (let i = 0; i < outLen; i++) {
         const pos = i / ratio;
         const i0 = Math.floor(pos);
-        const i1 = Math.min(i0 + 1, int16.length - 1);
+        const i1 = Math.min(i0 + 1, Int16.length - 1);
         const frac = pos - i0;
-        const v = int16[i0] * (1 - frac) + int16[i1] * frac;
+        const v = Int16[i0] * (1 - frac) + Int16[i1] * frac;
         out[i] = Math.round(v);
     }
     return out;

package/src/@modules/@eas/GetTTS.ts

@@ -18,22 +18,27 @@
     
 */
 
-import { platform } from 'os'
+import { platform } from "os"
 import { writeFileSync } from "fs"
-import { execSync } from 'child_process'
+import { execSync } from "child_process"
 
-export const GetTTS = async (text: string, outputPath: string): Promise<void> => {
+interface GetTTSOptions {
+    Text: string
+    OutputPath: string
+}
+
+export const GetTTS = async ({ Text, OutputPath }: GetTTSOptions): Promise<void> => {
     const vPlatform = platform();
     switch (vPlatform) {
         case 'win32': {
             try {
-                const txtPath = outputPath + ".txt";
-                writeFileSync(txtPath, text, "utf8");
+                const txtPath = OutputPath + ".txt";
+                writeFileSync(txtPath, Text, "utf8");
                 const command = [
                     "Add-Type -AssemblyName System.Speech;",
                     `$speak = New-Object System.Speech.Synthesis.SpeechSynthesizer;`,
                     `$text = Get-Content -Raw -LiteralPath '${txtPath}';`,
-                    `$speak.SetOutputToWaveFile('${outputPath}');`,
+                    `$speak.SetOutputToWaveFile('${OutputPath}');`,
                     `$speak.Speak($text);`,
                     `$speak.Dispose();`
                 ].join(" ");
@@ -45,7 +50,7 @@ export const GetTTS = async (text: string, outputPath: string): Promise<void> =>
         }
         case 'linux':
             try {
-                execSync(`espeak -w "${outputPath}" "${text.replace(/"/g, '\\"')}"`);
+                execSync(`espeak -w "${OutputPath}" "${Text.replace(/"/g, '\\"')}"`);
             } catch {}
             break;
         default: break;

package/src/@modules/@eas/GetWavPCM16.ts

@@ -19,10 +19,10 @@
 */
 
 interface getWavPCM16Response { 
-    samples: Int16Array
-    sampleRate: number
-    channels: number
-    bitsPerSample: number
+    Samples: Int16Array
+    SampleRate: number
+    Channels: number
+    BitsPerSample: number
 }
 
 export const GetWavPCM16 = (buffer: Buffer): getWavPCM16Response => {
@@ -46,7 +46,7 @@ export const GetWavPCM16 = (buffer: Buffer): getWavPCM16Response => {
     const bitsPerSample = fmt.readUInt16LE(14);
     if (audioFormat !== 1 || bitsPerSample !== 16 || channels !== 1) { return null; }
     const samples = new Int16Array(data.buffer, data.byteOffset, data.length / 2);
-    return { samples: new Int16Array(samples), sampleRate, channels, bitsPerSample };
+    return { Samples: new Int16Array(samples), SampleRate: sampleRate, Channels: channels, BitsPerSample: bitsPerSample };
 }
 
 

package/src/@modules/@eas/SetAFSK.ts

@@ -18,7 +18,12 @@
     
 */
 
-export const SetAFSK = (bits: number[], sampleRate: number): Int16Array => {
+interface SetAFSKOptions {
+    Bits: number[]
+    SampleRate: number
+}
+
+export const SetAFSK = ({ Bits, SampleRate }: SetAFSKOptions): Int16Array => {
     const baud = 520.83;
     const markFreq = 2083.3;
     const spaceFreq = 1562.5;
@@ -27,20 +32,20 @@ export const SetAFSK = (bits: number[], sampleRate: number): Int16Array => {
     const result = [];
     let phase = 0;
     let frac = 0;
-    for (let b = 0; b < bits.length; b++) {
-        const bit = bits[b];
+    for (let b = 0; b < Bits.length; b++) {
+        const bit = Bits[b];
         const freq = bit ? markFreq : spaceFreq;
-        const samplesPerBit = sampleRate / baud + frac;
+        const samplesPerBit = SampleRate / baud + frac;
         const n = Math.round(samplesPerBit);
         frac = samplesPerBit - n;
-        const inc = twoPi * freq / sampleRate;
+        const inc = twoPi * freq / SampleRate;
         for (let i = 0; i < n; i++) {
             result.push(Math.round(Math.sin(phase) * amplitude * 32767));
             phase += inc;
             if (phase > twoPi) phase -= twoPi;
         }
     }
-    const fadeSamples = Math.floor(sampleRate * 0.002);
+    const fadeSamples = Math.floor(SampleRate * 0.002);
     for (let i = 0; i < fadeSamples; i++) {
         const gain = i / fadeSamples;
         result[i] = Math.round(result[i] * gain);

package/src/@modules/@eas/SetAttentionTone.ts

@@ -18,16 +18,21 @@
     
 */
 
-export const SetAttentionTone = (ms: number, sampleRate: number): Int16Array => {
-    const len = Math.floor(ms * sampleRate);
+interface SetAttentionToneOptions {
+    MS: number
+    SampleRate: number
+}
+
+export const SetAttentionTone = ({ MS, SampleRate }: SetAttentionToneOptions): Int16Array => {
+    const len = Math.floor(MS * SampleRate);
     const out = new Int16Array(len);
     const f1 = 853;
     const f2 = 960;
     const twoPi = Math.PI * 2;
     const amp = 0.1;
-    const fadeLen = Math.floor(sampleRate * 0.00); 
+    const fadeLen = Math.floor(SampleRate * 0.00); 
     for (let i = 0; i < len; i++) {
-        const t = i / sampleRate;
+        const t = i / SampleRate;
         const s = Math.sin(twoPi * f1 * t) + Math.sin(twoPi * f2 * t);
         let gain = 1;
         if (i < fadeLen) gain = i / fadeLen;

package/src/@modules/@eas/SetNoise.ts

@@ -18,12 +18,17 @@
     
 */
 
-import { GetPCMToFloat } from "./GetPCMToFloat";
-import { GetFloatPCM16 } from "./GetFloatPCM16";
+import { GetPCMToFloat } from "@eas/GetPCMToFloat"
+import { GetFloatPCM16 } from "@eas/GetFloatPCM16"
 
-export const SetNoise = (int16: Int16Array, noiseLevel: number = 0.02): Int16Array => {
-    const x = GetPCMToFloat(int16);
-    for (let i = 0; i < x.length; i++) x[i] += (Math.random() * 2 - 1) * noiseLevel;
+interface SetNoiseOptions {
+    Int16: Int16Array
+    NoiseLevel?: number
+}
+
+export const SetNoise = ({ Int16, NoiseLevel }: SetNoiseOptions): Int16Array => {
+    const x = GetPCMToFloat(Int16);
+    for (let i = 0; i < x.length; i++) x[i] += (Math.random() * 2 - 1) * (NoiseLevel ?? 0.02);
     let peak = 0;
     for (let i = 0; i < x.length; i++) peak = Math.max(peak, Math.abs(x[i]));
     if (peak > 1) for (let i = 0; i < x.length; i++) x[i] *= 0.98 / peak;

package/src/@modules/@eas/SetRadioEffect.ts

@@ -18,14 +18,19 @@
     
 */
 
-import { GetPCMToFloat } from "./GetPCMToFloat";
-import { GetFloatPCM16 } from "./GetFloatPCM16";
+import { GetPCMToFloat } from "@eas/GetPCMToFloat"
+import { GetFloatPCM16 } from "@eas/GetFloatPCM16"
 
-export const SetRadioEffect = (int16: Int16Array, sampleRate: number): Int16Array => {
+interface SetRadioEffectOptions {
+    Int16: Int16Array
+    SampleRate: number
+}
+
+export const SetRadioEffect = ({ Int16, SampleRate }: SetRadioEffectOptions): Int16Array => {
     const hpCut = 3555;
     const lpCut = 1600;
-    const x = GetPCMToFloat(int16);
-    const dt = 1 / sampleRate;
+    const x = GetPCMToFloat(Int16);
+    const dt = 1 / SampleRate;
     const rcHP = 1 / (2 * Math.PI * hpCut);
     const aHP = rcHP / (rcHP + dt);
     let yHP = 0, xPrev = 0;

package/src/@modules/@eas/SetSameHeader.ts

@@ -18,26 +18,34 @@
     
 */
 
-import { SetAFSK } from "./SetAFSK";
-import { SetAsciiToBits } from "./SetAsciiToBits";
-import { GetMergedPCM16 } from "./GetMergedPCM16";
+import { SetAFSK } from "@eas/SetAFSK"
+import { SetAsciiToBits } from "@eas/SetAsciiToBits"
+import { GetMergedPCM16 } from "@eas/GetMergedPCM16"
 
-export const SetSameHeader = (vtec: string, repeats: number, sampleRate: number = 8000, options: {preMarkSec?: number, gapSec?: number} = {}): Int16Array => {
-    const preMarkSec = options.preMarkSec ?? 0.3;
-    const gapSec = options.gapSec ?? 0.1;
+interface SetSameHeaderOptions {
+    VTEC: string
+    Repeats: number
+    SampleRate?: number
+    PreMarkSec?: number
+    GapSec?: number
+}
+
+export const SetSameHeader = ({ VTEC, Repeats, SampleRate, PreMarkSec, GapSec }: SetSameHeaderOptions): Int16Array => {
+    const preMarkSec = PreMarkSec ?? 0.3;
+    const gapSec = GapSec ?? 0.1;
     const bursts = [];
-    const gap = new Int16Array(Math.floor(gapSec * sampleRate));
-    for (let i = 0; i < repeats; i++) {
-        const bodyBits = SetAsciiToBits(vtec);
-        const body = SetAFSK(bodyBits, sampleRate);
-        const extendedBodyDuration = Math.round(preMarkSec * sampleRate);
+    const gap = new Int16Array(Math.floor(gapSec * SampleRate));
+    for (let i = 0; i < Repeats; i++) {
+        const bodyBits = SetAsciiToBits(VTEC);
+        const body = SetAFSK({ Bits: bodyBits, SampleRate: SampleRate});
+        const extendedBodyDuration = Math.round(preMarkSec * SampleRate);
         const extendedBody = new Int16Array(extendedBodyDuration + gap.length);
         for (let j = 0; j < extendedBodyDuration; j++) { 
             extendedBody[j] = Math.round(body[j % body.length] * 0.2); 
         }
         extendedBody.set(gap, extendedBodyDuration);
         bursts.push(extendedBody);
-        if (i !== repeats - 1) bursts.push(gap);
+        if (i !== Repeats - 1) bursts.push(gap);
     }
     return GetMergedPCM16(bursts);
 }

package/src/@modules/@stanza/GetAwipsType.ts

@@ -17,32 +17,31 @@
 
 */
 
-import { TypeAttributes } from "../../@types/Attributes"
-import { EnumAWIPS } from "../../@enums/AWIPS"
+import { TypeAttributes } from "types-lower/Attributes"
+import { EnumAWIPS } from "@enums/AWIPS"
 
 interface GetAwipsTypeOptions { 
-    attributes: TypeAttributes
+    Attributes: TypeAttributes
 }
 
 interface GetAwipsTypeResponse { 
-    type: string
-    prefix: string
-    discovered: boolean
+    Type: string
+    Prefix: string
+    Discovered: boolean
 }
 
-export const GetAwipsType = (options: GetAwipsTypeOptions): GetAwipsTypeResponse => {
-    const attributes = options.attributes;
-    if (!attributes.awipsid) { 
+export const GetAwipsType = ({ Attributes }: GetAwipsTypeOptions): GetAwipsTypeResponse => {
+    if (!Attributes.awipsid) { 
         return { 
-            type: null, 
-            prefix: null,
-            discovered: false
+            Type: null, 
+            Prefix: null,
+            Discovered: false
         }
     }
     for (const [prefix, type] of Object.entries(EnumAWIPS)) {
-        if (attributes.awipsid.startsWith(prefix)) {
-            return { type, prefix, discovered: true }
+        if (Attributes.awipsid.startsWith(prefix)) {
+            return { Type: type, Prefix: prefix, Discovered: true }
         }
     }
-    return { type: options.attributes.awipsid, prefix: options.attributes.awipsid, discovered: false }
+    return { Type: Attributes.awipsid, Prefix: Attributes.awipsid, Discovered: false }
 }

package/src/@modules/@stanza/ValidateStanza.ts

@@ -17,34 +17,46 @@
 
 */
 
-import { TypeStanza } from "../../@types/Stanza"
-import { TypeStanzaCompiled } from "../../@types/StanzaCompiled"
-import { EnumExpressions } from "../../@enums/Expressions"
-import { GetAwipsType } from "./GetAwipsType"
+import { TypeStanza } from "types-lower/Stanza"
+import { TypeStanzaCompiled } from "types/StanzaCompiled"
+import { EnumExpressions } from "@enums/Expressions"
+import { GetAwipsType } from "@stanza/GetAwipsType"
 
 interface ValidateStanzaOptions { 
-    stanza: TypeStanza
+    Stanza: TypeStanza
 }
 
-export const ValidateStanza = (options: ValidateStanzaOptions): TypeStanzaCompiled => {
-    if (options.stanza.is(`message`)) {
-        const cb = options.stanza.getChild(`x`) as TypeStanza;
+export const ValidateStanza = ({ Stanza }: ValidateStanzaOptions): TypeStanzaCompiled => {
+    if (Stanza.is(`message`)) {
+        const cb = Stanza.getChild(`x`) as TypeStanza;
         if (cb && cb.children) {
             const message = unescape(cb.children[0]);
             const attributes = cb.attrs;
             if (attributes.awipsid && attributes.awipsid.length > 1) { 
                 const isCapEvent = message.includes(`<?xml`);
                 const isCapAreaDescription = message.includes(`<areaDesc>`)
-                const isVTEC = message.match(EnumExpressions.pvtec) != null;
+                const isVTEC = message.match(EnumExpressions.vtec) != null;
                 const isUGC = message.match(EnumExpressions.ugc1) != null;
-                const getType = GetAwipsType({ attributes: attributes})
-                if (getType.type != null) {
+                const getType = GetAwipsType({ Attributes: attributes})
+                if (getType.Type != null) {
                     return { 
-                        message, attributes, isCapEvent, isVTEC, isUGC, isCapAreaDescription, isIgnored: false, isNWWS: true, getType
+                        Message: message, 
+                        Attributes: attributes, 
+                        CapEvent: isCapEvent, 
+                        VTEC: isVTEC, 
+                        UGC: isUGC, 
+                        CapAreaDescription: isCapAreaDescription, 
+                        Ignored: false, 
+                        NWWS: true, 
+                        Type: {
+                            Type: getType.Type, 
+                            Prefix: getType.Prefix,
+                            Discovered: getType.Discovered
+                        }
                     }
                 }
             }
         }
     }
-    return { isIgnored: true}
+    return { Ignored: true}
 }

package/src/@modules/@utilities/CreateHttp.ts

@@ -18,27 +18,27 @@
 */
 
 interface CreateHttpOptions { 
-    url: string
-    headers?: any
-    timeout?: number
-    auth?: {
-        username: string
-        password: string
+    URL: string
+    Headers?: any
+    Timeout?: number
+    Auth?: {
+        Username: string
+        Password: string
     }
-    method?: `GET` | `POST` | `PUT` | `DELETE`
-    body?: any;
-    formData?: any;
+    Method?: `GET` | `POST` | `PUT` | `DELETE`
+    Body?: any;
+    Form?: any;
 }
 
-export const CreateHttp = async (options: CreateHttpOptions): Promise<any> => {
+export const CreateHttp = async ({ URL, Headers, Timeout, Auth, Method, Body, Form }: CreateHttpOptions): Promise<any> => {
 	const requestOptions: RequestInit = {
-        method: options.method ?? "GET",
-        headers: options.headers ?? {
+        method: Method ?? "GET",
+        headers: Headers ?? {
             "User-Agent": "AtmosphericX",
             "Accept": "application/geo+json, text/plain, */*; q=0.9",
             "Accept-Language": "en-US,en;q=0.9",
         },
-        signal: AbortSignal.timeout(options.timeout ?? 10_000),
+        signal: AbortSignal.timeout(Timeout ?? 10_000),
         redirect: "follow"
     };
 
@@ -47,8 +47,8 @@ export const CreateHttp = async (options: CreateHttpOptions): Promise<any> => {
 		return { error: error, options: requestOptions, status, message };
 	}
 
-    if (options?.auth) {
-        const authString = `${options.auth.username}:${options.auth.password}`;
+    if (Auth) {
+        const authString = `${Auth.Username}:${Auth.Password}`;
         const encodedAuth = Buffer.from(authString).toString("base64");
         requestOptions.headers = {
             ...requestOptions.headers,
@@ -56,20 +56,20 @@ export const CreateHttp = async (options: CreateHttpOptions): Promise<any> => {
         };
     }
 
-	if (options?.formData) { 
-		requestOptions.body = options.formData;
-	} else if (options?.body != undefined) {
+	if (Form) { 
+		requestOptions.body = Form;
+	} else if (Body != undefined) {
         requestOptions.body =
-        options.body instanceof FormData
-            ? options.body
-            : typeof options.body === "string"
-                ? options.body
-                : JSON.stringify(options.body);
+        Body instanceof FormData
+            ? Body
+            : typeof Body === "string"
+                ? Body
+                : JSON.stringify(Body);
 	}
 
 	try { 
 		const response = await fetch(
-			options?.url ?? `https://api.weather.gov/alerts/active`,
+			URL ?? `https://api.weather.gov/alerts/active`,
 			requestOptions
 		)
 		const body = await response.text();

package/src/@modules/@utilities/GetMatched.ts

@@ -17,11 +17,16 @@
 
 */
 
-export const GetMatched = (strings: string[], string: string): boolean => {
-    const isMatched = strings.some(pattern => {
+interface GetMatchedOptions {
+    Strings: string[]
+    String: string
+}
+
+export const GetMatched = ({ Strings, String }: GetMatchedOptions): boolean => {
+    const isMatched = Strings.some(pattern => {
         if (!pattern) return false;
         const lowerP = pattern.toLowerCase();
-        const lowerS = string.toLowerCase()
+        const lowerS = String.toLowerCase()
         if (lowerP === "*" || lowerP === lowerS) return true;
         if (lowerP.includes("*")) {
             const regex = "^" + lowerP.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";

package/src/@modules/@utilities/GetSettings.ts

@@ -17,9 +17,9 @@
 
 */
 
-import { TypeSettings } from '../../@types/Settings'
-import { bootstrap } from "../../bootstrap"
+import { TypeSettings } from "types/Settings"
+import { Bootstrap } from "@bootstrap"
 
 export const GetSettings = (): TypeSettings => {
-    return bootstrap.settings;
+    return Bootstrap.Settings;
 }

package/src/@modules/@utilities/GetShapeNearestPoint.ts

@@ -17,17 +17,22 @@
 
 */
 
+interface GetShapeNearestPointOptions {
+    Coordinates: number[][]
+    Point: [number, number]
+}
+
 interface GetShapeNearestPointResponse { 
-    proximity: boolean
-    point: [number, number]
-    distance: number | null 
-    distanceKm?: number | null
-    distanceMeters?: number | null
+    Proximity: boolean
+    Point: [number, number]
+    Distance: number | null 
+    DistanceKm?: number | null
+    DistanceMeters?: number | null
 }
 
-export const GetShapeNearestPoint = (coordinates: number[][], point: [number, number]): GetShapeNearestPointResponse => {
-    if (!coordinates || !point) { 
-        return { proximity: false, point: [0, 0], distance: null }
+export const GetShapeNearestPoint = ({ Coordinates, Point }: GetShapeNearestPointOptions): GetShapeNearestPointResponse => {
+    if (!Coordinates || !Point) { 
+        return { Proximity: false, Point: [0, 0], Distance: null }
     }
     const normalize = (coords: any): any[] => {
         if (!Array.isArray(coords)) return [];
@@ -43,10 +48,10 @@ export const GetShapeNearestPoint = (coordinates: number[][], point: [number, nu
         }
         return [];
     }
-    const polys = normalize(coordinates);
-    if (polys.length === 0) return { proximity: false, point: [0, 0], distance: null };
-    const lon = point[0];
-    const lat = point[1];
+    const polys = normalize(Coordinates);
+    if (polys.length === 0) return { Proximity: false, Point: [0, 0], Distance: null };
+    const lon = Point[0];
+    const lat = Point[1];
     const pointInRing = (pt: [number, number], ring: number[][]): boolean => {
         let x = pt[0], y = pt[1];
         let inside = false;
@@ -76,13 +81,13 @@ export const GetShapeNearestPoint = (coordinates: number[][], point: [number, nu
     for (const poly of polys) {
         const outer = poly[0];
         const holes = poly.slice(1);
-        if (pointInRing(point, outer)) {
+        if (pointInRing(Point, outer)) {
             let inHole = false;
             for (const hole of holes) {
-                if (pointInRing(point, hole)) { inHole = true; break; }
+                if (pointInRing(Point, hole)) { inHole = true; break; }
             }
             if (!inHole) {
-                return { proximity: true, point, distance: 0 };
+                return { Proximity: true, Point, Distance: 0 };
             }
         }
         for (const ring of poly) {
@@ -105,10 +110,10 @@ export const GetShapeNearestPoint = (coordinates: number[][], point: [number, nu
         }
     }
     if (!isFinite(minDistance) || closestPoint == null) {
-        return { proximity: false, point: [0,0], distance: null };
+        return { Proximity: false, Point: [0,0], Distance: null };
     }
     const distanceMiles = minDistance;
     const distanceKm = Number((distanceMiles * 1.609344).toFixed(3));
     const distanceMeters = Math.round(distanceKm * 1000);
-    return { proximity: distanceMiles === 0, point: closestPoint, distance: distanceMiles, distanceKm, distanceMeters };
+    return { Proximity: distanceMiles === 0, Point: closestPoint, Distance: distanceMiles, DistanceKm: distanceKm, DistanceMeters: distanceMeters };
 }

package/src/@modules/@utilities/QueueManager.ts

@@ -0,0 +1,70 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+*/
+
+export type QueueTask = () => Promise<void>;
+
+export interface QueueManagerOptions {
+    Concurrency?: number;
+    Error?: (error: unknown) => void;
+}
+
+export class QueueManager {
+    private readonly queue: QueueTask[] = [];
+    private readonly concurrency: number;
+    private readonly onError: (error: unknown) => void;
+
+    private running = 0;
+    private draining = false;
+
+    public constructor({ Concurrency, Error }: QueueManagerOptions = {}) {
+        this.concurrency = Concurrency ?? 1;
+        this.onError = Error ?? ((error) => {
+            console.error("[QueueManager] Task failed:", error);
+        });
+    }
+
+    public enqueue(task: QueueTask): void {
+        this.queue.push(task);
+        this.drain();
+    }
+
+    private drain(): void {
+        if (this.draining) { return; }
+        this.draining = true;
+        while (this.running < this.concurrency && this.queue.length > 0) {
+            const task = this.queue.shift();
+            if (!task) { continue; }
+            this.running++;
+            void this.execute(task);
+        }
+        this.draining = false;
+    }
+
+    private async execute(task: QueueTask): Promise<void> {
+        try {
+            await task();
+        } catch (error) {
+            try {
+                this.onError(error);
+            } catch (handlerError) {}
+        } finally {
+            this.running--;
+            this.drain();
+        }
+    }
+}