/**
 * 请求队列管理器
 * 
 * 用于管理待执行的请求队列，支持请求拦截、暂停、恢复等功能
 */ function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
/**
 * 队列状态
 */ var QueueState = /*#__PURE__*/ function(QueueState) {
    /**
   * 正常状态，请求可以正常执行
   */ QueueState["IDLE"] = "idle";
    /**
   * 暂停状态，请求会被放入队列
   */ QueueState["PAUSED"] = "paused";
    /**
   * 处理中状态，正在执行回调
   */ QueueState["PROCESSING"] = "processing";
    return QueueState;
}(QueueState || {});
/**
 * 请求队列管理器
 */ let RequestQueueManager = class RequestQueueManager {
    /**
   * 获取单例实例
   */ static getInstance() {
        if (!RequestQueueManager.instance) {
            RequestQueueManager.instance = new RequestQueueManager();
        }
        return RequestQueueManager.instance;
    }
    /**
   * 检查队列是否处于暂停状态
   */ isPaused() {
        return this.state === "paused" || this.state === "processing";
    }
    /**
   * 暂停队列，后续请求会被放入队列
   */ pause() {
        if (this.state === "idle") {
            this.state = "paused";
        }
    }
    /**
   * 恢复队列，执行队列中的所有请求
   */ async resume() {
        if (this.state === "idle") {
            return;
        }
        this.state = "idle";
        // 执行队列中的所有请求
        const requests = [
            ...this.queue
        ];
        this.queue = [];
        // 并行执行所有请求
        await Promise.allSettled(requests.map((item)=>{
            return item.execute().then(item.resolve).catch(item.reject);
        }));
    }
    /**
   * 执行回调并等待完成，然后恢复队列
   * 
   * @param callback - 回调函数
   */ async processAndResume(callback) {
        if (this.state === "processing") {
            // 如果已经在处理中，等待当前处理完成
            if (this.processingPromise) {
                await this.processingPromise;
            }
            return;
        }
        this.state = "processing";
        try {
            // 执行回调
            this.processingPromise = Promise.resolve(callback());
            await this.processingPromise;
        } finally{
            this.processingPromise = null;
            // 恢复队列
            await this.resume();
        }
    }
    /**
   * 将请求添加到队列
   * 
   * @template TResponse - 响应数据类型
   * @param options - 请求配置
   * @param execute - 请求执行函数
   * @returns Promise 解析为响应对象
   */ async enqueue(options, execute) {
        return new Promise((resolve, reject)=>{
            this.queue.push({
                options: options,
                execute: execute,
                resolve: resolve,
                reject,
                timestamp: Date.now()
            });
        });
    }
    /**
   * 获取队列长度
   */ getQueueLength() {
        return this.queue.length;
    }
    /**
   * 清空队列
   * 
   * @param reason - 清空原因（用于错误信息）
   */ clear(reason) {
        const requests = [
            ...this.queue
        ];
        this.queue = [];
        // 拒绝所有待执行的请求
        const error = reason ? new Error(`请求队列已清空: ${reason}`) : new Error('请求队列已清空');
        requests.forEach((item)=>{
            item.reject(error);
        });
        this.state = "idle";
        this.processingPromise = null;
    }
    /**
   * 销毁管理器
   */ destroy() {
        this.clear('管理器已销毁');
        RequestQueueManager.instance = null;
    }
    constructor(){
        /**
   * 待执行的请求队列
   */ _define_property(this, "queue", []);
        /**
   * 队列状态
   */ _define_property(this, "state", "idle");
        /**
   * 当前正在执行的回调 Promise
   */ _define_property(this, "processingPromise", null);
    }
};
_define_property(RequestQueueManager, "instance", null);
/**
 * 获取请求队列管理器实例
 */ export function getRequestQueueManager() {
    return RequestQueueManager.getInstance();
}

//# sourceMappingURL=RequestQueueManager.js.map