sse-stream-plugin-sdk 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -1,1012 +0,0 @@
-'use strict';
-
-class Emitter {
-    constructor() {
-        Object.defineProperty(this, "listeners", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    /**
-     * 订阅事件
-     * @returns 取消订阅函数
-     */
-    on(event, listener) {
-        let set = this.listeners.get(event);
-        if (!set) {
-            set = new Set();
-            this.listeners.set(event, set);
-        }
-        set.add(listener);
-        return () => this.off(event, listener);
-    }
-    /** 订阅一次，触发后自动移除 */
-    once(event, listener) {
-        const off = this.on(event, (...args) => {
-            off();
-            listener(...args);
-        });
-        return off;
-    }
-    /** 取消订阅 */
-    off(event, listener) {
-        this.listeners.get(event)?.delete(listener);
-    }
-    /** 派发事件，按订阅顺序同步调用 */
-    emit(event, ...args) {
-        const set = this.listeners.get(event);
-        if (!set)
-            return;
-        // 复制一份：回调中可能增删订阅者
-        for (const listener of [...set]) {
-            listener(...args);
-        }
-    }
-    /** 清空全部订阅（destroy 后阻止任何插件再响应） */
-    clear() {
-        this.listeners.clear();
-    }
-}
-
-/**
- * 创建标准 SSE 解析器
- * @description 规范允许 "\r\n" / "\n" / "\r" 三种换行，先归一化再按空行切块；
- * 最后一段可能不完整，保留在缓冲中等待后续数据拼接。
- */
-function createSSEParser() {
-    /** 尚未按空行切分完整的残留数据 */
-    let buffer = '';
-    const write = (chunk, emit) => {
-        buffer += chunk;
-        const normalized = buffer.replace(/\r\n?/g, '\n');
-        const parts = normalized.split('\n\n');
-        // 最后一段（不完整内容或空串）留存
-        buffer = parts.pop() ?? '';
-        for (const part of parts) {
-            if (!part.trim())
-                continue;
-            const event = parseBlock(part);
-            if (event)
-                emit(event);
-        }
-    };
-    const flush = (emit) => {
-        const normalized = buffer.replace(/\r\n?/g, '\n').trim();
-        buffer = '';
-        if (!normalized)
-            return;
-        const event = parseBlock(normalized);
-        if (event)
-            emit(event);
-    };
-    return { write, flush };
-}
-/**
- * 解析单个 SSE 事件块
- * @description
- * 1. 冒号开头为注释行，忽略；
- * 2. 值的第一个前导空格恰好移除一个；
- * 3. 多条 data 行以 "\n" 连接；
- * 4. 无 data 行的块返回 null（不派发）；
- * 5. id 含 U+0000 时忽略。
- */
-function parseBlock(block) {
-    let name = 'message';
-    const dataLines = [];
-    let id;
-    let hasId = false;
-    for (const line of block.split('\n')) {
-        if (!line || line.startsWith(':'))
-            continue;
-        const colonIndex = line.indexOf(':');
-        let field;
-        let value;
-        if (colonIndex === -1) {
-            field = line;
-            value = '';
-        }
-        else {
-            field = line.slice(0, colonIndex);
-            value = line.slice(colonIndex + 1);
-            if (value.charAt(0) === ' ')
-                value = value.slice(1);
-        }
-        switch (field) {
-            case 'event':
-                name = value;
-                break;
-            case 'data':
-                dataLines.push(value);
-                break;
-            case 'id':
-                if (!value.includes('\0')) {
-                    id = value;
-                    hasId = true;
-                }
-                break;
-        }
-    }
-    if (dataLines.length === 0)
-        return null;
-    return { name, data: dataLines.join('\n'), ...(hasId ? { id } : {}) };
-}
-
-const webFetchTransport = () => {
-    let reader = null;
-    /** 是否已被外部中止，中止导致的 catch 不再上报 error */
-    let aborted = false;
-    return {
-        name: 'web-fetch',
-        async connect(req, events) {
-            try {
-                const res = await fetch(req.url, {
-                    method: req.method,
-                    headers: { 'Content-Type': 'application/json', ...req.headers },
-                    body: req.method === 'POST' ? req.body : undefined,
-                });
-                events.response?.({
-                    status: res.status,
-                    headers: headerRecord(res.headers),
-                });
-                if (!res.ok || !res.body) {
-                    throw new Error(`HTTP ${res.status} 流不可用`);
-                }
-                reader = res.body.getReader();
-                const decoder = new TextDecoder('utf-8');
-                for (;;) {
-                    const { done, value } = await reader.read();
-                    if (aborted)
-                        break;
-                    if (done) {
-                        events.end();
-                        break;
-                    }
-                    events.data(decoder.decode(value, { stream: true }));
-                }
-            }
-            catch (err) {
-                if (!aborted)
-                    events.error(err);
-            }
-        },
-        abort() {
-            aborted = true;
-            // cancel 会令 pending read settle；releaseLock 在读取中会抛错
-            reader?.cancel().catch(() => { });
-            reader = null;
-        },
-    };
-};
-/** 将 Headers 对象拍平为普通键值对（值取首个） */
-function headerRecord(headers) {
-    const record = {};
-    headers.forEach((value, key) => {
-        record[key] = value;
-    });
-    return record;
-}
-
-/**
- * 创建通用小程序传输层工厂
- * @param getRequest 获取平台 request API 的函数（延迟求值，避免模块加载时全局对象未就绪）
- * @param name 传输层名称，默认 'miniprogram'
- */
-function createMpTransport(getRequest, name = 'miniprogram') {
-    return () => {
-        let task = null;
-        let aborted = false;
-        let decoder;
-        return {
-            name,
-            connect(req, events) {
-                const api = getRequest();
-                task = api.request({
-                    url: req.url,
-                    method: req.method,
-                    header: { ...req.headers },
-                    // 小程序 data 需为对象：将 JSON 字符串解析回对象
-                    data: req.method === 'POST' && req.body ? JSON.parse(req.body) : undefined,
-                    enableChunked: true,
-                    responseType: 'arraybuffer',
-                    // 请求完成（物理结束），并上报状态码
-                    success: (res) => {
-                        if (aborted)
-                            return;
-                        events.response?.({ status: res.statusCode });
-                        events.end();
-                    },
-                    fail: (err) => {
-                        if (!aborted)
-                            events.error(normalizeMpError(err));
-                    },
-                });
-                task.onChunkReceived((res) => {
-                    if (aborted)
-                        return;
-                    events.data(decodeBytes(new Uint8Array(res.data)));
-                });
-                /** 解码分片，优先 TextDecoder stream 模式，回退百分号解码 */
-                function decodeBytes(bytes) {
-                    if (decoder === undefined) {
-                        decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8') : null;
-                    }
-                    if (decoder)
-                        return decoder.decode(bytes, { stream: true });
-                    let hex = '';
-                    for (let i = 0; i < bytes.length; i++) {
-                        hex += '%' + bytes[i].toString(16).padStart(2, '0');
-                    }
-                    return decodeURIComponent(hex);
-                }
-            },
-            abort() {
-                aborted = true;
-                task?.abort();
-                task = null;
-            },
-        };
-    };
-}
-/** 将平台回调错误归一化为 Error：优先取 errMsg，保证错误信息可读 */
-function normalizeMpError(err) {
-    if (err instanceof Error)
-        return err;
-    if (err !== null && typeof err === 'object' && 'errMsg' in err) {
-        const msg = err.errMsg;
-        return new Error(typeof msg === 'string' && msg ? msg : 'request 失败');
-    }
-    return new Error(String(err));
-}
-
-/** 内置示例脚本（注册表中默认 'mock' 使用） */
-function defaultScript() {
-    return [
-        { id: 'm1', data: '开始解释：\n' },
-        { id: 'm2', data: '输入内容：你好\n' },
-        { name: 'ping', data: '', gap: 200 },
-        { id: 'm3', data: '\n1. 语法解析完成' },
-        { id: 'm4', data: '\n2. 语义分析完成' },
-        { id: 'm5', data: '\n3. 生成解释结果' },
-        { id: 'm6', data: '\n✅ 解释完毕' },
-    ];
-}
-/**
- * 创建 Mock 传输层工厂
- * @description 注意 failAfter 的“只失败一次”状态记忆在工厂闭包外层，
- * 重连产生的新实例不会再次失败。
- */
-function mockTransport(options) {
-    const script = options?.events ?? defaultScript();
-    const failAfter = options?.failAfter ?? 0;
-    const errorMessage = options?.errorMessage ?? '模拟网络中断（连接被重置）';
-    /** 本次失败是否已经发生过（跨重连实例共享） */
-    let failedOnce = false;
-    return ({ request }) => {
-        const timers = [];
-        let aborted = false;
-        // 续传：依据 Last-Event-ID 定位起始事件
-        let cursor = 0;
-        const lastId = request.headers['Last-Event-ID'] ?? request.headers['last-event-id'];
-        if (lastId) {
-            const index = script.findIndex((item) => item.id === lastId);
-            if (index >= 0)
-                cursor = index + 1;
-        }
-        return {
-            name: 'mock',
-            connect(_req, events) {
-                const schedule = () => {
-                    if (aborted)
-                        return;
-                    // 已投递 failAfter 个事件：制造唯一一次错误
-                    if (failAfter > 0 && cursor === failAfter && !failedOnce) {
-                        failedOnce = true;
-                        const timer = setTimeout(() => {
-                            if (!aborted)
-                                events.error(new Error(errorMessage));
-                        }, 500);
-                        timers.push(timer);
-                        return;
-                    }
-                    if (cursor >= script.length) {
-                        const timer = setTimeout(() => {
-                            if (!aborted)
-                                events.end();
-                        }, 200);
-                        timers.push(timer);
-                        return;
-                    }
-                    const item = script[cursor];
-                    const timer = setTimeout(() => {
-                        if (aborted)
-                            return;
-                        events.data(serializeSSE(item));
-                        cursor++;
-                        schedule();
-                    }, item.gap ?? 350);
-                    timers.push(timer);
-                };
-                schedule();
-            },
-            abort() {
-                aborted = true;
-                for (const timer of timers)
-                    clearTimeout(timer);
-                timers.length = 0;
-            },
-        };
-    };
-}
-/** 将脚本事件序列化为标准 SSE 文本块 */
-function serializeSSE(item) {
-    const lines = [];
-    if (item.id)
-        lines.push(`id:${item.id}`);
-    lines.push(`event:${item.name ?? 'message'}`);
-    for (const line of (item.data ?? '').split('\n')) {
-        lines.push(`data:${line}`);
-    }
-    return lines.join('\n') + '\n\n';
-}
-
-/**
- * 自动探测可用传输层
- * @description
- * 仅探测 Web 标准 fetch——fetch 是跨环境通用标准，自动探测合理；
- * 小程序等碎片化平台需通过插件显式注册传输层（createMpTransport），
- * 内核不做任何平台假设。
- */
-function detectTransport() {
-    const global = globalThis;
-    if (typeof global.fetch === 'function')
-        return webFetchTransport;
-    throw new Error('未检测到可用传输层，请通过 options.transport 显式指定，或用 createMpTransport 注册小程序传输层');
-}
-
-/**
- * @file 插件化 SSE 客户端内核
- * @description
- * 内核只做“编排”：
- * 连接开始 → 请求中间件链 → 传输层收发 → 解析器产出事件 →
- * 事件中间件链 → 事件总线派发；
- * 重连、心跳、节流、鉴权等能力全部下沉为插件，内核不内置任何平台分支。
- */
-class PluginSSE {
-    constructor(options) {
-        /** 公共事件总线 */
-        Object.defineProperty(this, "emitter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Emitter()
-        });
-        /** 已注册插件 */
-        Object.defineProperty(this, "plugins", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        /** 插件是否已完成安装（只安装一次） */
-        Object.defineProperty(this, "installed", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        /** 暴露给插件的上下文 */
-        Object.defineProperty(this, "context", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** 命名传输层注册表 */
-        Object.defineProperty(this, "transportRegistry", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        /** 请求中间件（按注册顺序） */
-        Object.defineProperty(this, "requestMiddleware", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        /** 事件中间件（按注册顺序） */
-        Object.defineProperty(this, "eventMiddleware", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        /** 插件销毁回调 */
-        Object.defineProperty(this, "disposeFns", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        /** 解析器工厂，默认标准 SSE */
-        Object.defineProperty(this, "parserFactory", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: createSSEParser
-        });
-        /** 当前连接使用的解析器 */
-        Object.defineProperty(this, "parser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        /** 当前连接的传输层实例 */
-        Object.defineProperty(this, "activeTransport", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        /** 当前请求配置（每次连接开始时重建） */
-        Object.defineProperty(this, "currentRequest", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {
-                url: '',
-                method: 'GET',
-                headers: {},
-            }
-        });
-        /** 初始化配置（合并默认值后） */
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** 内核状态 */
-        Object.defineProperty(this, "state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'idle'
-        });
-        /** 会话代际，每次开新流/出错自增，用于作废迟到回调 */
-        Object.defineProperty(this, "sessionId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        /** 是否已永久销毁 */
-        Object.defineProperty(this, "dead", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        /**
-         * 将解析出的事件送入事件中间件链，链尾派发到总线
-         * @description 最终同时派发通用 'event' 与具体事件名（如 'message'）
-         */
-        Object.defineProperty(this, "dispatch", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (event) => {
-                runEventChain(this.eventMiddleware, event, (final) => {
-                    this.emitter.emit('event', final);
-                    this.emitter.emit(final.name, final.data, final);
-                }, (err) => this.settleError(err));
-            }
-        });
-        this.options = {
-            url: options.url,
-            method: options.method ?? 'GET',
-            body: options.body ?? '',
-            headers: options.headers ?? {},
-            transport: options.transport,
-            plugins: options.plugins ?? [],
-            parser: options.parser,
-        };
-        if (this.options.parser)
-            this.parserFactory = this.options.parser;
-        // 注册内置命名传输层
-        // web / mock 为通用内置；小程序等平台传输层由使用方通过插件注册
-        this.transportRegistry.set('web', webFetchTransport);
-        this.transportRegistry.set('mock', mockTransport());
-        // 构造稳定的插件上下文
-        const self = this;
-        this.context = {
-            emitter: this.emitter,
-            get request() {
-                return self.currentRequest;
-            },
-            addRequestMiddleware: (mw) => this.requestMiddleware.push(mw),
-            addEventMiddleware: (mw) => this.eventMiddleware.push(mw),
-            setParser: (factory) => {
-                this.parserFactory = factory;
-            },
-            registerTransport: (name, factory) => this.transportRegistry.set(name, factory),
-            start: () => this.start(),
-            fail: (err) => this.settleError(err),
-            getState: () => this.state,
-            isDead: () => this.dead,
-            onDispose: (fn) => this.disposeFns.push(fn),
-        };
-        // 注册构造时传入的插件
-        for (const plugin of this.options.plugins)
-            this.use(plugin);
-    }
-    /**
-     * 注册插件
-     * @description 首次连接前注册会在连接时统一安装；连接后注册则立即安装，
-     * 新管道只影响后续的连接与事件。
-     */
-    use(plugin) {
-        if (this.dead)
-            throw new Error('实例已销毁，无法再注册插件');
-        if (this.plugins.some((p) => p.name === plugin.name)) {
-            // 同名插件忽略，避免重复订阅
-            return this;
-        }
-        this.plugins.push(plugin);
-        if (this.installed)
-            plugin.install(this.context);
-        return this;
-    }
-    /** 建立连接（公开入口） */
-    async connect() {
-        if (this.dead)
-            throw new Error('实例已销毁，请创建新的 PluginSSE');
-        await this.start();
-    }
-    /**
-     * 发起一次连接（连接与插件触发的重连共用）
-     * @description 中止旧连接 → 重建请求 → 请求中间件 → 创建解析器/传输层 → 收发
-     */
-    async start() {
-        if (this.dead)
-            return;
-        if (!this.installed)
-            this.installPlugins();
-        this.silentAbort();
-        const session = ++this.sessionId;
-        this.state = 'connecting';
-        this.currentRequest = {
-            url: this.options.url,
-            method: this.options.method,
-            headers: { ...this.options.headers },
-            body: this.options.method === 'POST' ? this.options.body : undefined,
-        };
-        this.emitter.emit('connecting', { session });
-        // 请求管道：插件可在此注入鉴权头、改写请求
-        let req;
-        try {
-            req = await composeRequest(this.requestMiddleware)(this.currentRequest);
-        }
-        catch (err) {
-            if (session === this.sessionId)
-                this.settleError(err);
-            return;
-        }
-        if (session !== this.sessionId || this.dead)
-            return;
-        this.currentRequest = req;
-        this.parser = this.parserFactory();
-        const factory = this.resolveTransportFactory();
-        const transport = factory({ request: req });
-        this.activeTransport = transport;
-        transport.connect(req, {
-            data: (chunk) => {
-                if (session !== this.sessionId)
-                    return;
-                this.emitter.emit('data', chunk);
-                this.parser?.write(chunk, this.dispatch);
-            },
-            end: () => {
-                if (session !== this.sessionId)
-                    return;
-                this.parser?.flush(this.dispatch);
-                this.state = 'closed';
-                this.emitter.emit('end');
-            },
-            error: (err) => {
-                if (session !== this.sessionId)
-                    return;
-                this.settleError(err);
-            },
-            response: (info) => {
-                if (session !== this.sessionId)
-                    return;
-                this.emitter.emit('response', info);
-            },
-        });
-        this.state = 'open';
-        this.emitter.emit('open', { transport: transport.name });
-    }
-    /**
-     * 永久销毁：中止连接、释放插件资源、清空订阅
-     * @description 销毁后不再有任何自动重连
-     */
-    destroy() {
-        if (this.dead)
-            return;
-        this.dead = true;
-        this.sessionId++;
-        this.silentAbort();
-        this.state = 'closed';
-        for (const fn of this.disposeFns) {
-            try {
-                fn();
-            }
-            catch {
-                // 单个插件销毁异常不影响其他清理
-            }
-        }
-        this.emitter.emit('closed');
-        this.emitter.clear();
-    }
-    // ---- 事件订阅（事件总线的便捷代理） ----
-    on(event, listener) {
-        return this.emitter.on(event, listener);
-    }
-    once(event, listener) {
-        return this.emitter.once(event, listener);
-    }
-    off(event, listener) {
-        this.emitter.off(event, listener);
-    }
-    /** 安装全部插件（仅一次） */
-    installPlugins() {
-        this.installed = true;
-        for (const plugin of this.plugins)
-            plugin.install(this.context);
-    }
-    /** 解析传输层配置：名称 → 工厂；省略则自动探测 */
-    resolveTransportFactory() {
-        const transport = this.options.transport;
-        if (typeof transport === 'string') {
-            const factory = this.transportRegistry.get(transport);
-            if (!factory)
-                throw new Error(`未注册的传输层：${transport}`);
-            return factory;
-        }
-        if (transport)
-            return transport;
-        return detectTransport();
-    }
-    /**
-     * 结束错误会话：作废代际、中止传输、派发错误事件
-     * @description 是否重连交由重连插件等订阅者决定，内核自身不重连
-     */
-    settleError(err) {
-        if (this.dead)
-            return;
-        this.sessionId++;
-        this.silentAbort();
-        this.state = 'closed';
-        this.emitter.emit('error', err);
-    }
-    /** 静默中止当前传输并清理引用（不派发任何事件） */
-    silentAbort() {
-        if (this.activeTransport) {
-            try {
-                this.activeTransport.abort();
-            }
-            catch {
-                // 忽略中止异常
-            }
-            this.activeTransport = null;
-        }
-    }
-}
-/**
- * 组装请求中间件链
- * @description 类 Koa 的线性 next 模型，最后一个中间件结束即返回请求
- */
-function composeRequest(middleware) {
-    return (arg) => {
-        let index = -1;
-        const dispatch = (i, req) => {
-            if (i <= index)
-                return Promise.reject(new Error('next() 被多次调用'));
-            index = i;
-            if (i === middleware.length)
-                return Promise.resolve(req);
-            try {
-                return Promise.resolve(middleware[i](req, (modified) => dispatch(i + 1, modified ?? req)));
-            }
-            catch (err) {
-                return Promise.reject(err);
-            }
-        };
-        return dispatch(0, arg);
-    };
-}
-/**
- * 执行事件中间件链
- * @param middleware 中间件列表
- * @param event 初始事件
- * @param terminal 链尾回调（真正派发）
- * @param onError 链上异常处理
- */
-function runEventChain(middleware, event, terminal, onError) {
-    let index = -1;
-    const dispatch = (i, e) => {
-        if (i <= index)
-            return Promise.reject(new Error('next() 被多次调用'));
-        index = i;
-        if (i === middleware.length) {
-            terminal(e);
-            return Promise.resolve();
-        }
-        try {
-            return Promise.resolve(middleware[i](e, (modified) => dispatch(i + 1, modified ?? e)));
-        }
-        catch (err) {
-            return Promise.reject(err);
-        }
-    };
-    dispatch(0, event).catch(onError);
-}
-
-function reconnectPlugin(options) {
-    const maxRetries = options?.maxRetries ?? 3;
-    const delay = options?.delay ?? 1500;
-    /** 最近事件 id（续传位点） */
-    let lastId = '';
-    /** 已重试次数 */
-    let attempts = 0;
-    let timer = null;
-    return {
-        name: 'reconnect',
-        install(ctx) {
-            // 请求中间件：重连时携带续传位点
-            ctx.addRequestMiddleware(async (req, next) => {
-                if (lastId)
-                    req.headers['Last-Event-ID'] = lastId;
-                return next(req);
-            });
-            // 记录最近的事件 id（ping 等无 id 事件不改变位点）
-            ctx.emitter.on('event', (event) => {
-                if (event.id)
-                    lastId = event.id;
-            });
-            ctx.emitter.on('error', (err) => {
-                if (ctx.isDead())
-                    return;
-                if (attempts >= maxRetries) {
-                    ctx.emitter.emit('reconnect-failed', err);
-                    return;
-                }
-                attempts++;
-                ctx.emitter.emit('reconnect', { attempt: attempts, inMs: delay });
-                timer = setTimeout(() => {
-                    timer = null;
-                    void ctx.start();
-                }, delay);
-            });
-            // 正常结束：重置重试计数与位点
-            ctx.emitter.on('end', () => {
-                attempts = 0;
-                lastId = '';
-            });
-            ctx.onDispose(() => {
-                if (timer)
-                    clearTimeout(timer);
-                timer = null;
-            });
-        },
-    };
-}
-
-function heartbeatPlugin(options) {
-    const interval = options?.interval ?? 10000;
-    let timer = null;
-    return {
-        name: 'heartbeat',
-        install(ctx) {
-            const clear = () => {
-                if (timer) {
-                    clearTimeout(timer);
-                    timer = null;
-                }
-            };
-            const arm = () => {
-                clear();
-                timer = setTimeout(() => {
-                    ctx.emitter.emit('heartbeat-lost');
-                    ctx.fail(new Error(`心跳丢失：${interval}ms 内未收到任何数据`));
-                }, interval);
-            };
-            ctx.emitter.on('connecting', arm);
-            // 任意原始数据到达即续命（包含 ping 事件文本）
-            ctx.emitter.on('data', arm);
-            // 结束/错误后撤掉计时，避免误判
-            ctx.emitter.on('end', clear);
-            ctx.emitter.on('error', clear);
-            ctx.onDispose(clear);
-        },
-    };
-}
-
-function throttlePlugin(options) {
-    const windowMs = options?.windowMs ?? 100;
-    /** 窗口内累积的数据 */
-    let buffer = '';
-    /** 窗口内最后一个事件 id */
-    let lastEventId;
-    let timer = null;
-    /** 被拦截事件的 next：窗口结束时一次性放行合并事件 */
-    let pendingNext = null;
-    return {
-        name: 'throttle',
-        install(ctx) {
-            const flush = () => {
-                if (timer) {
-                    clearTimeout(timer);
-                    timer = null;
-                }
-                if (buffer && pendingNext) {
-                    const data = buffer;
-                    const id = lastEventId;
-                    buffer = '';
-                    lastEventId = undefined;
-                    const next = pendingNext;
-                    pendingNext = null;
-                    next({ name: 'message', data, ...(id ? { id } : {}) });
-                }
-            };
-            const middleware = (event, next) => {
-                if (event.name !== 'message')
-                    return next(event);
-                buffer += event.data;
-                if (event.id)
-                    lastEventId = event.id;
-                pendingNext = next;
-                if (!timer) {
-                    timer = setTimeout(flush, windowMs);
-                }
-                // 不调用 next：事件被暂存，窗口结束时统一放行
-            };
-            ctx.addEventMiddleware(middleware);
-            // 结束/出错/销毁时立即冲刷，避免丢消息
-            ctx.emitter.on('end', flush);
-            ctx.emitter.on('error', flush);
-            ctx.onDispose(flush);
-        },
-    };
-}
-
-function loggerPlugin(options) {
-    const sink = options?.sink ?? ((message) => console.log(message));
-    return {
-        name: 'logger',
-        install(ctx) {
-            ctx.emitter.on('open', ({ transport }) => {
-                const headers = JSON.stringify(ctx.request.headers);
-                sink(`连接已打开（${transport}）请求头：${headers}`);
-            });
-            ctx.emitter.on('response', ({ status }) => {
-                sink(`收到响应，状态码：${status}`);
-            });
-            ctx.emitter.on('event', (event) => {
-                const preview = event.data.replace(/\n/g, '\\n');
-                const shown = preview.length > 40 ? preview.slice(0, 40) + '…' : preview;
-                sink(`事件 ${event.name}${event.id ? ' #' + event.id : ''} ` +
-                    `(${event.data.length} 字): ${shown}`);
-            });
-            ctx.emitter.on('reconnect', ({ attempt, inMs }) => {
-                sink(`连接中断，${inMs}ms 后进行第 ${attempt} 次重连…`);
-            });
-            ctx.emitter.on('heartbeat-lost', () => {
-                sink('心跳丢失！');
-            });
-            ctx.emitter.on('reconnect-failed', () => {
-                sink('已达最大重试次数，不再重连');
-            });
-            ctx.emitter.on('error', (err) => {
-                sink(`发生错误：${err instanceof Error ? err.message : String(err)}`);
-            });
-            ctx.emitter.on('end', () => {
-                sink('流正常结束');
-            });
-            ctx.emitter.on('closed', () => {
-                sink('实例已销毁，资源已释放');
-            });
-        },
-    };
-}
-
-function authPlugin(options) {
-    const header = options.header ?? 'Authorization';
-    const scheme = options.scheme ?? 'Bearer';
-    /** 是否正在刷新，避免多个 401 并发刷新 */
-    let refreshing = false;
-    return {
-        name: 'auth',
-        install(ctx) {
-            // 请求管道：注入鉴权头
-            ctx.addRequestMiddleware(async (req, next) => {
-                const token = await options.getToken();
-                req.headers[header] = scheme ? `${scheme} ${token}` : token;
-                return next(req);
-            });
-            // 状态码感知：401 → 刷新 → 重连
-            ctx.emitter.on('response', async ({ status }) => {
-                if (status !== 401 || refreshing || ctx.isDead())
-                    return;
-                refreshing = true;
-                ctx.emitter.emit('auth-refreshing');
-                try {
-                    await options.refreshToken();
-                }
-                finally {
-                    refreshing = false;
-                }
-                void ctx.start();
-            });
-        },
-    };
-}
-
-function statsPlugin(options) {
-    const keyword = options?.keyword ?? '✅';
-    return {
-        name: 'stats',
-        install(ctx) {
-            let messages = 0;
-            let chars = 0;
-            ctx.emitter.on('message', (data) => {
-                messages++;
-                chars += data.length;
-                const payload = { messages, chars };
-                ctx.emitter.emit('stats', payload);
-                if (data.includes(keyword)) {
-                    ctx.emitter.emit('keyword', { keyword, at: chars });
-                }
-            });
-            // 新一轮连接时归零统计
-            ctx.emitter.on('connecting', () => {
-                messages = 0;
-                chars = 0;
-                ctx.emitter.emit('stats', { messages, chars });
-            });
-        },
-    };
-}
-
-/**
- * @file 插件化 SSE SDK 统一出口
- */
-/**
- * 推荐插件组合（无副作用，不含日志/鉴权等业务相关插件）
- * @description 自动重连 + 心跳检测 + 消息节流
- */
-function recommendedPlugins() {
-    return [reconnectPlugin(), heartbeatPlugin(), throttlePlugin()];
-}
-
-exports.Emitter = Emitter;
-exports.PluginSSE = PluginSSE;
-exports.authPlugin = authPlugin;
-exports.createMpTransport = createMpTransport;
-exports.createSSEParser = createSSEParser;
-exports.defaultScript = defaultScript;
-exports.detectTransport = detectTransport;
-exports.heartbeatPlugin = heartbeatPlugin;
-exports.loggerPlugin = loggerPlugin;
-exports.mockTransport = mockTransport;
-exports.recommendedPlugins = recommendedPlugins;
-exports.reconnectPlugin = reconnectPlugin;
-exports.statsPlugin = statsPlugin;
-exports.throttlePlugin = throttlePlugin;
-exports.webFetchTransport = webFetchTransport;
-//# sourceMappingURL=index.cjs.map