openclaw-stepfun 0.2.2

package/dist/src/reply-dispatcher.js

@@ -0,0 +1,234 @@
+import { resolveStepfunAccount } from "./accounts.js";
+import { getStepfunRuntime } from "./runtime.js";
+import { sendMessageStepfun } from "./send.js";
+/**
+ * Detect media type from URL and return placeholder message
+ */
+function getMediaPlaceholder(url) {
+    const lowerUrl = url.toLowerCase();
+    // Image extensions
+    if (/\.(jpg|jpeg|png|gif|webp|bmp|svg|ico)(\?.*)?$/i.test(lowerUrl)) {
+        return "【这是一条图片消息】";
+    }
+    // Video extensions
+    if (/\.(mp4|webm|ogg|mov|avi|mkv|flv|m3u8)(\?.*)?$/i.test(lowerUrl)) {
+        return "【这是一条视频消息】";
+    }
+    // Audio extensions
+    if (/\.(mp3|wav|aac|ogg|m4a|flac|wma)(\?.*)?$/i.test(lowerUrl)) {
+        return "【这是一条语音/音频消息】";
+    }
+    // Document extensions
+    if (/\.(pdf|doc|docx|xls|xlsx|ppt|pptx|txt|zip|rar)(\?.*)?$/i.test(lowerUrl)) {
+        return "【这是一条文件消息】";
+    }
+    // Default for unknown media types
+    return "【这是一条媒体消息】";
+}
+/**
+ * List of error messages that should not be sent to users
+ * These are typically API/connection errors from the model provider
+ * Note: These are exact matches to avoid false positives
+ */
+const BLOCKED_ERROR_MESSAGES = [
+    "Connection error.",
+    "APIConnectionError",
+    "Connection timeout",
+    "Network error",
+    "Request timeout",
+    "Service unavailable",
+];
+/**
+ * Maximum length for error messages
+ * API errors are typically short (< 50 chars), while normal responses explaining these terms would be longer
+ */
+const MAX_ERROR_LENGTH = 100;
+/**
+ * Check if content is an error message that should not be sent to users
+ * Uses exact match for short messages to avoid false positives
+ */
+function isErrorContent(content) {
+    const trimmed = content.trim();
+    // Only check relatively short messages to avoid false positives
+    // Normal explanations of these terms would be longer
+    if (trimmed.length > MAX_ERROR_LENGTH) {
+        return false;
+    }
+    // Check for exact match or the content being mostly the error message
+    return BLOCKED_ERROR_MESSAGES.some((errorMsg) => {
+        // Exact match
+        if (trimmed === errorMsg) {
+            return true;
+        }
+        // Content starts with the error message (error followed by punctuation or whitespace)
+        if (trimmed.startsWith(errorMsg) && /^[\s.,;:!?]/.test(trimmed.slice(errorMsg.length))) {
+            return true;
+        }
+        // Content is just the error message with minimal additions (like error code)
+        if (trimmed.includes(errorMsg) && trimmed.length < errorMsg.length + 20) {
+            return true;
+        }
+        return false;
+    });
+}
+/**
+ * Build message content with media placeholders if media is present
+ */
+function buildMessageContent(payload) {
+    const text = payload.text ?? "";
+    const mediaUrls = [];
+    // Collect all media URLs
+    if (payload.mediaUrl) {
+        mediaUrls.push(payload.mediaUrl);
+    }
+    if (payload.mediaUrls && payload.mediaUrls.length > 0) {
+        mediaUrls.push(...payload.mediaUrls);
+    }
+    // Build media placeholders
+    const mediaPlaceholders = [];
+    for (const url of mediaUrls) {
+        const placeholder = getMediaPlaceholder(url);
+        // Avoid duplicate placeholders
+        if (!mediaPlaceholders.includes(placeholder)) {
+            mediaPlaceholders.push(placeholder);
+        }
+    }
+    // Combine text and media placeholders
+    const parts = [];
+    if (text.trim()) {
+        parts.push(text);
+    }
+    if (mediaPlaceholders.length > 0) {
+        parts.push(...mediaPlaceholders);
+    }
+    return parts.join("\n");
+}
+export function createStepfunReplyDispatcher(params) {
+    const core = getStepfunRuntime();
+    const { cfg, agentId, runtime, chatSessionId, accountId } = params;
+    const account = resolveStepfunAccount({ cfg, accountId });
+    // Buffer for accumulating streaming content
+    let contentBuffer = "";
+    let isProcessing = false;
+    let hasPendingFlush = false;
+    // Flush the buffer and send accumulated content
+    const flushBuffer = async () => {
+        if (isProcessing || !contentBuffer.trim()) {
+            return;
+        }
+        isProcessing = true;
+        hasPendingFlush = false;
+        const textToSend = contentBuffer;
+        contentBuffer = ""; // Clear buffer before async operation
+        runtime.log?.(`stepfun[${account.accountId}] flush: sending accumulated text=${textToSend.slice(0, 100)}...`);
+        const outboundContent = {
+            type: "message",
+            content: textToSend,
+        };
+        try {
+            const success = await sendMessageStepfun({
+                cfg,
+                chatSessionId,
+                content: outboundContent,
+                accountId,
+                runtime: { log: runtime.log, error: runtime.error },
+            });
+            if (!success) {
+                // Restore buffer on error so we don't lose content
+                contentBuffer = textToSend + contentBuffer;
+                runtime.error?.(`stepfun[${account.accountId}] flush failed: message could not be sent`);
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : JSON.stringify(err);
+            runtime.error?.(`stepfun[${account.accountId}] flush failed: ${errorMsg}`);
+            // Restore buffer on error so we don't lose content
+            contentBuffer = textToSend + contentBuffer;
+            // Don't rethrow - errors should not propagate to the gateway
+        }
+        finally {
+            isProcessing = false;
+            // Check if new content arrived while sending, and flush it
+            if (hasPendingFlush && contentBuffer.trim()) {
+                runtime.log?.(`stepfun[${account.accountId}] flush: more content pending, flushing again`);
+                setImmediate(() => scheduleFlush());
+            }
+        }
+    };
+    // Schedule buffer flush - ensures all messages are sent even if they arrive during send
+    const scheduleFlush = () => {
+        if (isProcessing) {
+            // Mark that we have pending content to flush after current send completes
+            hasPendingFlush = true;
+            runtime.log?.(`stepfun[${account.accountId}] scheduleFlush: send in progress, marking pending`);
+            return;
+        }
+        flushBuffer().catch((err) => {
+            runtime.error?.(`stepfun[${account.accountId}] flush error: ${String(err)}`);
+        });
+    };
+    const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+        deliver: async (payload, info) => {
+            const { kind } = info;
+            // Build message content including media placeholders
+            const messageContent = buildMessageContent(payload);
+            runtime.log?.(`stepfun[${account.accountId}] deliver called: kind=${kind}, text=${messageContent.slice(0, 100)}, bufferBefore=${contentBuffer.slice(0, 100)}`);
+            if (!messageContent.trim()) {
+                runtime.log?.(`stepfun[${account.accountId}] deliver: empty content, skipping`);
+                return;
+            }
+            // Check if content is an error message that should not be sent to users
+            if (isErrorContent(messageContent)) {
+                runtime.error?.(`stepfun[${account.accountId}] deliver: blocked error message from being sent to user: "${messageContent}"`);
+                return;
+            }
+            // For tool results, send immediately without buffering
+            if (kind === "tool") {
+                runtime.log?.(`stepfun[${account.accountId}] tool result: sending immediately`);
+                // Add tool call placeholder prefix
+                const toolContent = messageContent.trim()
+                    ? `【这是一条工具调用消息】\n${messageContent}`
+                    : "【这是一条工具调用消息】";
+                contentBuffer += toolContent;
+                scheduleFlush();
+                return;
+            }
+            // For block replies, just accumulate without sending
+            // Block replies are streaming chunks that should not be sent individually
+            if (kind === "block") {
+                contentBuffer += messageContent;
+                runtime.log?.(`stepfun[${account.accountId}] block reply: accumulated, buffer=${contentBuffer.slice(0, 100)}...`);
+                return;
+            }
+            // For final replies, flush all accumulated content
+            if (kind === "final") {
+                contentBuffer += messageContent;
+                runtime.log?.(`stepfun[${account.accountId}] final reply: flushing accumulated content, total=${contentBuffer.slice(0, 100)}...`);
+                scheduleFlush();
+                return;
+            }
+        },
+        onError: (err, info) => {
+            const errorMsg = err instanceof Error ? err.message : JSON.stringify(err);
+            runtime.error?.(`stepfun[${account.accountId}] ${info.kind} reply failed: ${errorMsg}`);
+        },
+    });
+    // Override markDispatchIdle to flush remaining content when done
+    const originalMarkDispatchIdle = markDispatchIdle;
+    const wrappedMarkDispatchIdle = () => {
+        runtime.log?.(`stepfun[${account.accountId}] markDispatchIdle called, flushing remaining content`);
+        // Flush any remaining content
+        if (contentBuffer.trim()) {
+            flushBuffer().catch((err) => {
+                runtime.error?.(`stepfun[${account.accountId}] final flush error: ${String(err)}`);
+            });
+        }
+        originalMarkDispatchIdle();
+    };
+    return {
+        dispatcher,
+        replyOptions,
+        markDispatchIdle: wrappedMarkDispatchIdle,
+    };
+}
+//# sourceMappingURL=reply-dispatcher.js.map

package/dist/src/runtime.d.ts

@@ -0,0 +1,4 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+export declare function setStepfunRuntime(next: PluginRuntime): void;
+export declare function getStepfunRuntime(): PluginRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/src/runtime.js

@@ -0,0 +1,11 @@
+let runtime = null;
+export function setStepfunRuntime(next) {
+    runtime = next;
+}
+export function getStepfunRuntime() {
+    if (!runtime) {
+        throw new Error("Stepfun runtime not initialized");
+    }
+    return runtime;
+}
+//# sourceMappingURL=runtime.js.map

package/dist/src/send.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OutboundMessageContent } from "./types.js";
+/**
+ * Send a message to Stepfun gateway using Protobuf format.
+ * The content is wrapped in ChatMessage and sent via BotMsg service.
+ * Note: Returns boolean indicating success/failure instead of throwing,
+ * to ensure errors don't propagate to the OpenClaw gateway.
+ */
+export declare function sendMessageStepfun(params: {
+    cfg: OpenClawConfig;
+    chatSessionId: string;
+    content: OutboundMessageContent;
+    accountId?: string;
+    runtime?: {
+        log?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}): Promise<boolean>;
+//# sourceMappingURL=send.d.ts.map

package/dist/src/send.js

@@ -0,0 +1,66 @@
+import { resolveStepfunAccount } from "./accounts.js";
+import { BotMsgSocketClient } from "./websocket/service.js";
+import { ChatMessage, ChatMessageContent, MessageType, BotType, SendMessagesRequest, } from "./proto/capy/botmsg/botmsg_pb.js";
+import { getSocket } from "./websocket/index.js";
+/**
+ * Send a message to Stepfun gateway using Protobuf format.
+ * The content is wrapped in ChatMessage and sent via BotMsg service.
+ * Note: Returns boolean indicating success/failure instead of throwing,
+ * to ensure errors don't propagate to the OpenClaw gateway.
+ */
+export async function sendMessageStepfun(params) {
+    const { cfg, chatSessionId, content, accountId, runtime } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const account = resolveStepfunAccount({ cfg, accountId });
+    if (!account.configured) {
+        error(`[stepfun] sendMessageStepfun: account not configured`);
+        return false;
+    }
+    // Ensure socket is initialized with auth from config
+    const socket = getSocket();
+    const token = account.config.appToken;
+    const appId = account.config.appId;
+    if (!token || !appId) {
+        error(`[stepfun] sendMessageStepfun: appId and appToken are required`);
+        return false;
+    }
+    socket.setAuth(token, appId);
+    // Convert content to string
+    let contentStr;
+    if (typeof content.content === "string") {
+        contentStr = content.content;
+    }
+    else if (content.event) {
+        // Handle streaming events
+        contentStr = JSON.stringify(content.event);
+    }
+    else {
+        contentStr = JSON.stringify(content);
+    }
+    // Build Protobuf message
+    const chatMessage = new ChatMessage({
+        appId: appId,
+        sessionId: chatSessionId,
+        senderUid: "0", // Robot sends as 0
+        msgType: MessageType.MessageType_BOT_MSG,
+        botType: BotType.BotType_OPENCLAW,
+        content: new ChatMessageContent({
+            content: contentStr,
+        }),
+    });
+    const request = new SendMessagesRequest({
+        message: chatMessage,
+    });
+    // Send via BotMsg service
+    try {
+        await BotMsgSocketClient.sendMessages(request);
+        return true;
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : JSON.stringify(err);
+        error(`[stepfun] Failed to send message: ${errorMsg}`);
+        return false;
+    }
+}
+//# sourceMappingURL=send.js.map

package/dist/src/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Stepfun channel configuration in clawdbot config.
+ */
+export type StepfunConfig = {
+    enabled?: boolean;
+    /** App ID for bot authentication */
+    appId?: string;
+    /** App token for WebSocket connection authentication */
+    appToken?: string;
+};
+/**
+ * Resolved stepfun account with merged configuration.
+ */
+export type ResolvedStepfunAccount = {
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+    name?: string;
+    config: StepfunConfig;
+};
+export type InboundMessageType = "text";
+export type InboundMessageConfig = {};
+/**
+ * Inbound message from Stepfun gateway.
+ */
+export type StepfunInboundMessage = {
+    chatSessionId: string;
+    type?: InboundMessageType;
+    config?: InboundMessageConfig;
+    appId: string;
+    messageId: string;
+    userId: string;
+    userName?: string;
+    content: string;
+    timestamp?: number;
+};
+/**
+ * Outbound message to Stepfun gateway (stepfun format).
+ */
+export type StepfunOutboundMessage = {
+    chatSessionId: string;
+    role: "assistant";
+    content: string;
+    timestamp?: number;
+};
+/**
+ * Message context for internal processing.
+ */
+export type StepfunMessageContext = {
+    chatSessionId: string;
+    messageId: string;
+    userId: string;
+    userName?: string;
+    content: string;
+};
+export type OutboundMessageContent = {
+    type: "message" | "stream";
+    content?: string;
+    messageId?: string;
+    event?: {
+        eventName: "start" | "text" | "done";
+        data: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/websocket/cacheEvent.d.ts

@@ -0,0 +1,17 @@
+type CacheStatusType = Record<string, unknown>;
+type WatchListType = Record<string, (() => void)[]>;
+export declare class CacheEvent {
+    eventList: any[];
+    eventKeys: CacheStatusType;
+    watchList: WatchListType;
+    cacheStatus: CacheStatusType;
+    once(key: string): boolean;
+    set(key: string, data: unknown): void;
+    get(key: string): unknown;
+    do(cb: () => void | Promise<void>, cond: string[], cache?: boolean): void;
+    complete(key: string): void;
+    clear(): void;
+}
+export declare const globalCache: CacheEvent;
+export {};
+//# sourceMappingURL=cacheEvent.d.ts.map

package/dist/src/websocket/cacheEvent.js

@@ -0,0 +1,61 @@
+export class CacheEvent {
+    eventList = [];
+    eventKeys = {};
+    watchList = {};
+    cacheStatus = {};
+    once(key) {
+        if (!this.cacheStatus[key]) {
+            this.cacheStatus[key] = 1;
+            return true;
+        }
+        return false;
+    }
+    set(key, data) {
+        this.cacheStatus[key] = data;
+    }
+    get(key) {
+        return this.cacheStatus[key];
+    }
+    do(cb, cond, cache = true) {
+        const canDo = cond?.every((i) => this.eventKeys[i]) || !cond;
+        if (!canDo) {
+            if (cache) {
+                cond.forEach((key) => {
+                    if (!this.watchList[key]) {
+                        this.watchList[key] = [];
+                    }
+                    this.watchList[key].push(() => this.do(cb, cond, false));
+                });
+            }
+        }
+        else {
+            try {
+                const result = cb();
+                // Handle async callbacks - catch any promise rejections
+                if (result instanceof Promise) {
+                    result.catch((err) => {
+                        console.error("[cacheEvent] async callback error:", err);
+                    });
+                }
+            }
+            catch (err) {
+                console.error("[cacheEvent] callback error:", err);
+            }
+        }
+    }
+    complete(key) {
+        this.eventKeys[key] = 1;
+        if (this.watchList[key]) {
+            this.watchList[key].forEach((e) => e());
+            this.watchList[key] = [];
+        }
+    }
+    clear() {
+        this.eventList = [];
+        this.eventKeys = {};
+        this.watchList = {};
+        this.cacheStatus = {};
+    }
+}
+export const globalCache = new CacheEvent();
+//# sourceMappingURL=cacheEvent.js.map

package/dist/src/websocket/connect.d.ts

@@ -0,0 +1,32 @@
+import type { MethodInfo, MethodInfoBiDiStreaming, MethodInfoClientStreaming, MethodInfoServerStreaming, MethodInfoUnary, PartialMessage, ServiceType } from '@bufbuild/protobuf';
+import { ErrorRes } from './streamConnect.js';
+export interface SocketCallbacks<O, T = any> {
+    onStart?: (params: {
+        msgId: string;
+        method: string;
+    }) => void;
+    onData?: (params: {
+        msgId: string;
+        method: string;
+        data: O;
+        throwError: (error: ErrorRes) => void;
+        resolve: (data: T) => void;
+        close: () => void;
+    }) => void;
+    onError?: (params: {
+        msgId: string;
+        method: string;
+        error: ErrorRes | Uint8Array;
+    }) => void;
+    throwError?: (error: ErrorRes) => void;
+    onClose?: () => void;
+}
+type PromiseMethod<I, O> = (request: I | Promise<I>, callbacks?: SocketCallbacks<O>, once?: boolean) => Promise<O>;
+export type PromiseClient<T extends ServiceType> = {
+    [P in keyof T['methods']]: T['methods'][P] extends MethodInfoUnary<infer I, infer O> ? PromiseMethod<PartialMessage<I>, O> : T['methods'][P] extends MethodInfoServerStreaming<infer I, infer O> ? PromiseMethod<PartialMessage<I>, O> : T['methods'][P] extends MethodInfoClientStreaming<infer I, infer O> ? PromiseMethod<PartialMessage<I>, O> : T['methods'][P] extends MethodInfoBiDiStreaming<infer I, infer O> ? PromiseMethod<PartialMessage<I>, O> : never;
+};
+export declare function createSocketConnect<T extends ServiceType>(module: string, Service: T): PromiseClient<T>;
+export declare function removeMsgListener(msgId: string): void;
+export declare function createPromiseClient(module: string, methodInfo: MethodInfo): (payload: import("@bufbuild/protobuf").MessageType<import("@bufbuild/protobuf").AnyMessage>, callbacks?: SocketCallbacks<import("@bufbuild/protobuf").MessageType<import("@bufbuild/protobuf").AnyMessage>>, once?: boolean) => Promise<unknown>;
+export {};
+//# sourceMappingURL=connect.d.ts.map

package/dist/src/websocket/connect.js

@@ -0,0 +1,79 @@
+import { makeAnyClient } from '@connectrpc/connect';
+import { getSocket } from './index.js';
+import { ErrorRes } from './streamConnect.js';
+export function createSocketConnect(module, Service) {
+    return makeAnyClient(Service, (methodInfo) => {
+        return createPromiseClient(module, methodInfo);
+    });
+}
+export function removeMsgListener(msgId) {
+    const socket = getSocket();
+    socket?.events.off(msgId);
+    socket?.events.off(`error:${msgId}`);
+    socket._requestStreams.delete(msgId);
+}
+export function createPromiseClient(module, methodInfo) {
+    const { I, O } = methodInfo;
+    return (payload, callbacks, once = true) => {
+        const command = methodInfo.name;
+        const socket = getSocket();
+        const msgId = socket.send({
+            module,
+            command,
+            body: new I(payload).toBinary(),
+            type: methodInfo.kind,
+        });
+        return new Promise((resolve, reject) => {
+            const throwError = (error) => {
+                reject(error);
+            };
+            const socket = getSocket();
+            const closeHandler = () => {
+                removeMsgListener(msgId);
+                callbacks?.onClose?.();
+            };
+            socket?.on(msgId, (e) => {
+                if (!e || e instanceof ErrorRes) {
+                    const error = e instanceof ErrorRes ? e : new ErrorRes({ code: 1, reason: 'data error' });
+                    if (callbacks?.onError) {
+                        callbacks.onError({ msgId, method: command, error });
+                    }
+                    reject(error);
+                    removeMsgListener(msgId);
+                    return;
+                }
+                const data = O.fromBinary(e);
+                if (callbacks?.onData) {
+                    callbacks.onData({
+                        msgId,
+                        method: command,
+                        // @ts-ignore
+                        data,
+                        throwError,
+                        resolve,
+                        close: closeHandler,
+                    });
+                }
+                else {
+                    resolve({ ...data, traceid: msgId });
+                }
+                if (once) {
+                    removeMsgListener(msgId);
+                }
+            });
+            let rejected = 0;
+            socket?.on(`error:${msgId}`, (error) => {
+                if (callbacks?.onError) {
+                    callbacks.onError({ msgId, method: command, error });
+                }
+                if (!rejected) {
+                    reject(error);
+                    rejected = 1;
+                }
+                removeMsgListener(msgId);
+            });
+            // todo 超时逻辑
+        });
+    };
+}
+//# sourceMappingURL=connect.js.map

package/dist/src/websocket/constant.d.ts

@@ -0,0 +1,8 @@
+export declare const BASE_URL: Record<Env, {
+    api?: string;
+    ws: string;
+}>;
+export declare enum Env {
+    Prod = "prod"
+}
+//# sourceMappingURL=constant.d.ts.map

package/dist/src/websocket/constant.js

@@ -0,0 +1,10 @@
+export const BASE_URL = {
+    prod: {
+        ws: "wss://chatapi.stepfun.com/botapi/wss/bot",
+    },
+};
+export var Env;
+(function (Env) {
+    Env["Prod"] = "prod";
+})(Env || (Env = {}));
+//# sourceMappingURL=constant.js.map

package/dist/src/websocket/eventBus.d.ts

@@ -0,0 +1,15 @@
+type Fn = {
+    fn: (args: object | null | undefined) => void;
+    once?: boolean;
+};
+type EventType<K extends string> = Record<K, Fn[]>;
+export declare class Event<K extends string> {
+    eventList: EventType<K>;
+    on(key: K, fn: (args: any) => void, once?: boolean): void;
+    emit(key: K, args?: object): boolean;
+    off(key: K, fn?: (args: any) => void): void;
+    checkListenersCount(key: K): number;
+}
+export declare const commonEventBus: Event<string>;
+export {};
+//# sourceMappingURL=eventBus.d.ts.map

package/dist/src/websocket/eventBus.js

@@ -0,0 +1,46 @@
+export class Event {
+    eventList = {};
+    on(key, fn, once) {
+        if (!this.eventList[key])
+            this.eventList[key] = [];
+        // console.log('on-------', Object.keys(this.eventList));
+        this.eventList[key].push({
+            fn,
+            once,
+        });
+    }
+    emit(key, args) {
+        if (this.eventList?.[key]) {
+            this.eventList[key].forEach((fn) => {
+                try {
+                    fn.fn(args);
+                }
+                catch (err) {
+                    console.error(`[eventBus] Error in listener for "${key}":`, err);
+                    // Continue to next listener even if one fails
+                }
+            });
+            this.eventList[key] = this.eventList[key].filter((item) => !item.once);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    off(key, fn) {
+        if (fn) {
+            const index = this.eventList[key]?.findIndex((item) => item.fn === fn);
+            if (index !== undefined && index !== -1) {
+                this.eventList[key]?.splice(index, 1);
+            }
+        }
+        else {
+            this.eventList[key] = [];
+        }
+    }
+    checkListenersCount(key) {
+        return this.eventList[key]?.length;
+    }
+}
+export const commonEventBus = new Event();
+//# sourceMappingURL=eventBus.js.map