@koi-design/callkit 1.0.22

package/dist/index.mjs

@@ -0,0 +1,1662 @@
+// package/index.ts
+import md5 from "blueimp-md5";
+
+// package/axios.ts
+import axios from "axios";
+var instance = axios.create({
+  headers: {
+    "Content-Type": "application/x-www-form-urlencoded"
+  }
+});
+instance.interceptors.request.use((config) => config);
+instance.interceptors.response.use(
+  (response) => response.data,
+  (error) => Promise.reject(error)
+);
+var request = (config) => instance.request(config);
+var axios_default = request;
+
+// package/api.ts
+var Api = class {
+  callKit;
+  constructor(callKit) {
+    this.callKit = callKit;
+  }
+  async login(params) {
+    return this.post({
+      url: "/auth/agentUser/login",
+      method: "post",
+      data: params
+    });
+  }
+  async loginOut(params) {
+    return this.post({
+      url: "/auth/agentUser/loginOut",
+      method: "post",
+      data: params
+    });
+  }
+  /**
+   *
+   * @param params agentId userStatus
+   * @description userStatus: Logout(1, "unregistered"), Free(2, "free"), Break(3, "nap"), Busy(4, "busy")
+   * @returns
+   */
+  async setUserStatus(params) {
+    return this.post({
+      url: "/agent/user/changeStatus",
+      method: "post",
+      data: params
+    });
+  }
+  async post(config) {
+    this.callKit.logger.debug(`Request ${config.url}:`, config.data);
+    const { userInfo, host } = this.callKit.config.getConfig();
+    const { sessionId } = userInfo;
+    config.url = `${host}${config.url}`;
+    config.headers = {
+      ...config.headers,
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    if (config.headers["Content-Type"] === "application/x-www-form-urlencoded") {
+      config.data = new URLSearchParams(config.data).toString();
+    }
+    if (sessionId) {
+      config.headers.sessionId = sessionId;
+    }
+    const res = await axios_default(config).catch(() => {
+      this.callKit.config.reset();
+    });
+    if (!res) {
+      this.callKit.config.reset();
+      throw new Error("Network error");
+    }
+    const { code, data, message } = res;
+    if (code === "000000") {
+      return data;
+    }
+    if (code === "100013") {
+      this.callKit.config.reset();
+    }
+    throw new Error(message ?? "Request failed");
+  }
+};
+
+// package/const.ts
+var UserStatus = {
+  /**
+   * Offline
+   */
+  offline: 1,
+  /**
+   * Online & Idle
+   */
+  online: 2,
+  /**
+   * Nap
+   */
+  catNap: 3,
+  /**
+   * Busy
+   */
+  busy: 4,
+  /**
+   * Training
+   */
+  training: 5,
+  /**
+   * Processing
+   */
+  processing: 6
+};
+var CallStatus = {
+  /**
+   * Initial state/Hang up
+   */
+  init: 0,
+  /**
+   * Registered
+   */
+  registered: 1,
+  /**
+   * Connecting
+   */
+  connecting: 2,
+  /**
+   * Call on hold
+   */
+  holding: 3,
+  /**
+   * Ringing
+   */
+  ringing: 4,
+  /**
+   * In call
+   */
+  calling: 5
+};
+var KitEvent = {
+  /**
+   * User status change
+   */
+  KIT_USER_STATUS_CHANGE: "userStatusChange",
+  /**
+   * User login status change
+   */
+  KIT_LOGIN_CHANGE: "loginChange",
+  /**
+   * Registration status change
+   */
+  KIT_REGISTER_CHANGE: "registerChange",
+  /**
+   * Call status change
+   */
+  KIT_CALL_STATUS_CHANGE: "callStatusChange",
+  /**
+   * Hold status change
+   */
+  KIT_SET_HOLD: "holdChange",
+  /**
+   * Mute status change
+   */
+  KIT_SET_MUTE: "muteChange",
+  /**
+   * Error
+   */
+  KIT_ERROR: "error",
+  /**
+   * Server initiated call
+   */
+  KIT_INVITE: "invite",
+  /**
+   * Connecting
+   */
+  CALL_CONNECTING: "connecting",
+  /**
+   * Customer ringing
+   */
+  CALL_RINGING: "ringing",
+  /**
+   * Agent pick up
+   */
+  AGENT_PICK_UP: "agentPickUp",
+  /**
+   * Customer answer
+   */
+  CALL_PICK_UP: "pickUp",
+  /**
+   * Customer no response
+   */
+  CALL_NO_ANSWER: "noAnswer",
+  /**
+   * Customer hang up
+   */
+  CALL_HANG_UP: "hangUp",
+  /**
+   * Call end
+   */
+  CALL_END: "callEnd",
+  /**
+   * Call detail record push
+   */
+  CALL_CDR: "callCdr",
+  /**
+   * Forward all socket events
+   */
+  SERVER_SOCKET_EVENT: "socketEvent",
+  /**
+   * User status change
+   */
+  USER_STATUS_CHANGE: "userStatusChange"
+};
+var ErrorCode = {
+  /**
+   * Unknown error
+   */
+  UNKNOWN_ERROR: -1,
+  /**
+   * API user login failed
+   */
+  API_USER_LOGIN_ERROR: 1000001,
+  /**
+   * API user status update failed
+   */
+  API_USER_STATUS_UPDATE_ERROR: 1000002,
+  /**
+   * API user logout failed
+   */
+  API_USER_LOGOUT_ERROR: 1000003,
+  /**
+   * connectStatus call status error
+   */
+  CONNECT_CALL_STATUS_ERROR: 2000001,
+  /**
+   * User not logged in
+   */
+  USER_NOT_LOGIN: 2000002,
+  /**
+   * Browser version too low, does not support webrtc getUserMedia
+   */
+  WEBRTC_USER_MEDIA_ERROR: 2000003,
+  /**
+   * Call hold failed
+   */
+  WEBRTC_HOLE_STATUS_ERROR: 2000004,
+  /**
+   * Audio player does not exist
+   */
+  WEBRTC_AUDIO_PLAYER_ERROR: 2000005,
+  /**
+   * Audio playback failed
+   */
+  WEBRTC_AUDIO_PLAY_ERROR: 2000006,
+  /**
+   * User agent startup failed
+   */
+  WEBRTC_USER_AGENT_ERROR: 2000007,
+  /**
+   * Call request failed
+   */
+  WEBRTC_CALL_INVITE_ERROR: 2000008,
+  /**
+   * Register request failed
+   */
+  WEBRTC_REGISTER_ERROR: 2000009,
+  /**
+   * Mute failed
+   */
+  WEBRTC_MUTE_STATUS_ERROR: 2000010,
+  /**
+   * Unregister failed
+   */
+  WEBRTC_CANCEL_REGISTER_ERROR: 2000011,
+  /**
+   * Mute failed
+   */
+  WEBRTC_MUTE_ERROR: 2000012,
+  /**
+   * Socket connection error
+   */
+  SOCKET_CONNECT_ERROR: 3000001,
+  /**
+   * Ping timeout
+   */
+  SOCKET_PING_TIMEOUT: 3000002,
+  /**
+   * Server error
+   */
+  SOKET_SERVER_ERROR: 3000003,
+  /**
+   * API call failed
+   */
+  SOCKET_CALL_ERROR: 3000004,
+  /**
+   * Reconnection limit exceeded
+   */
+  SOCKET_RECONNECT_FAILED: 3000005
+};
+var LoggerLevelMap = {
+  debug: 9,
+  log: 4,
+  warn: 3,
+  error: 2,
+  silent: 1
+};
+var SocketSendEvent = {
+  /**
+   * ping
+   */
+  PING: "PING",
+  /**
+   * Start
+   */
+  START: "START",
+  /**
+   * Hang up
+   */
+  AGENT_HANGUP: "AGENT_HANG_UP",
+  /**
+   * Cancel
+   */
+  CALL_CANCEL: "AGENT_CANCEL",
+  /**
+   * Hold
+   */
+  HOLD: "AGENT_HOLD",
+  /**
+   * Unhold
+   */
+  UNHOLD: "AGENT_UN_HOLD",
+  /**
+   * Call
+   */
+  CALL: "CALL",
+  /**
+   * End
+   */
+  END: "STOP"
+};
+var SocketReceiveEvent = {
+  /**
+   * Response
+   */
+  PONG: "PONG",
+  /**
+   * Start confirmation
+   */
+  START_CONFIRM: "START_CONFIRM",
+  /**
+   * Call success
+   */
+  CALL_SUCCESS: "CALL_SUCCESS",
+  /**
+   * Call failed
+   */
+  CALL_FAILED: "CALL_FAILED",
+  /**
+   * Customer ringing
+   */
+  CUSTOMER_RINGING: "CUSTOMER_RINGING",
+  /**
+   * Agent pick up
+   */
+  AGENT_PICK_UP: "AGENT_PICK_UP",
+  /**
+   * Customer pick up
+   */
+  CUSTOMER_PICK_UP: "CUSTOMER_PICK_UP",
+  /**
+   * Customer no answer
+   */
+  CUSTOMER_NO_ANSWER: "CUSTOMER_NO_ANSWER",
+  /**
+   * Customer hang up
+   */
+  CUSTOMER_HANG_UP: "CUSTOMER_HANG_UP",
+  /**
+   * Agent no answer
+   */
+  AGENT_NO_ANSWER: "AGENT_NO_ANSWER",
+  /**
+   * Call detail record push
+   */
+  CALL_CDR: "CALL_CDR",
+  /**
+   * Stop confirmation
+   */
+  STOP_CONFIRM: "STOP_CONFIRM",
+  /**
+   * Close
+   */
+  CLOSE: "CLOSE",
+  /**
+   * Error
+   */
+  ERROR: "ERROR"
+};
+var constrainsDefault = {
+  audio: {
+    autoGainControl: true,
+    // Noise suppression
+    noiseSuppression: true,
+    // Set echo cancellation
+    echoCancellation: true
+  },
+  video: false
+};
+var isAutoUpdateUserStatusDefault = true;
+
+// package/call.ts
+var Call = class {
+  callKit;
+  constructor(callKit) {
+    this.callKit = callKit;
+  }
+  async callStart() {
+    if (!this.callKit.config.check())
+      return;
+    this.callKit.logger.debug("callStart");
+    if (!this.callKit.socket.satrtConfirm) {
+      this.callKit.logger.warn("server not confirm start");
+      return;
+    }
+    this.callKit.connect.call(async (user) => {
+      const queryTrain = {
+        agentId: user.agentId,
+        phoneNum: user.extno
+      };
+      this.callKit.socket.send(SocketSendEvent.CALL, queryTrain);
+    });
+  }
+  /**
+   * Hang up
+   * @param isUnprompted Whether to actively hang up
+   * @param isError Whether an error occurred
+   * @returns
+   */
+  async callEnd(isUnprompted = false, isError = false) {
+    if (this.callKit.connect.connectStatus === CallStatus.init || this.callKit.connect.connectStatus === CallStatus.registered)
+      return;
+    if (!this.callKit.config.check())
+      return;
+    this.callKit.connect.hangup(isUnprompted, isError);
+  }
+  async callHold() {
+    if (!this.callKit.config.check())
+      return;
+    if (!this.callKit.connect.isCalling()) {
+      this.callKit.logger.warn("Current state cannot be held");
+      return;
+    }
+    this.callKit.connect.hold();
+    this.callKit.socket.send(SocketSendEvent.HOLD);
+    this.callKit.connect.setConnectStatus(CallStatus.holding);
+  }
+  async callUnhold() {
+    if (!this.callKit.config.check())
+      return;
+    if (!this.callKit.connect.isHolding()) {
+      this.callKit.logger.warn("Current state cannot unhold");
+      return;
+    }
+    this.callKit.connect.unhold();
+    this.callKit.socket.send(SocketSendEvent.UNHOLD);
+    this.callKit.connect.setConnectStatus(CallStatus.calling);
+  }
+};
+
+// package/config.ts
+var Config = class {
+  callKit;
+  constructor(callKit) {
+    this.callKit = callKit;
+  }
+  config = {
+    version: "1.0.2",
+    host: "",
+    log: "debug",
+    audioRef: void 0,
+    constrains: constrainsDefault,
+    socket: "",
+    userInfo: {
+      wsUrl: "",
+      sessionId: "",
+      // User
+      username: "",
+      // Password
+      password: "",
+      // Extension number
+      extno: "",
+      userPart: "",
+      agentId: "",
+      fsUserId: "",
+      fsPassword: "",
+      fsIp: "",
+      fsPort: "",
+      iceInfo: [],
+      iceGatheringTimeout: 0
+    },
+    // EXECUTE setUserStatus
+    isAutoUpdateUserStatus: true
+  };
+  getConfig = () => this.config;
+  setConfig = async (key, value) => {
+    this.config[key] = value;
+  };
+  setUserInfo = async (key, value) => {
+    this.config.userInfo[key] = value;
+    this.callKit.logger.debug(`setUserInfo: key: ${key}, value: ${value}`);
+  };
+  reset = () => {
+    if (this.isLogin()) {
+      this.config.userInfo = {
+        wsUrl: "",
+        sessionId: "",
+        username: "",
+        password: "",
+        userPart: "",
+        extno: "",
+        agentId: "",
+        fsUserId: "",
+        fsPassword: "",
+        fsIp: "",
+        fsPort: "",
+        iceInfo: [],
+        iceGatheringTimeout: this.config.userInfo.iceGatheringTimeout
+      };
+      this.callKit.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
+    }
+  };
+  validate = () => {
+    const {
+      userPart,
+      fsIp,
+      fsPassword,
+      fsPort
+    } = this.config.userInfo;
+    if (!userPart || !fsIp || !fsPort || !fsPassword) {
+      return false;
+    }
+    return true;
+  };
+  isLogin = () => this.validate();
+  check() {
+    if (!this.isLogin()) {
+      this.callKit.logger.error("User not logged in", {
+        errCode: ErrorCode.USER_NOT_LOGIN
+      });
+      return false;
+    }
+    return true;
+  }
+};
+
+// package/logger.ts
+function getLevel(level) {
+  return LoggerLevelMap[level];
+}
+var Logger = class {
+  prefix = "CallKit";
+  level = "debug";
+  callKit;
+  constructor(callKit, level) {
+    this.callKit = callKit;
+    this.level = level || "debug";
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  debug(msg, extra) {
+    if (getLevel(this.level) >= getLevel("debug")) {
+      this.output("blue")(msg, extra);
+    }
+  }
+  log(msg, extra) {
+    if (getLevel(this.level) >= getLevel("log")) {
+      this.output("green")(msg, extra);
+    }
+  }
+  warn(msg, extra) {
+    if (getLevel(this.level) >= getLevel("warn")) {
+      this.output("orange")(msg, extra);
+    }
+  }
+  error(msg, extra) {
+    const message = msg?.message ?? msg;
+    if (getLevel(this.level) >= getLevel("error")) {
+      this.output("red")(message, extra);
+    }
+    const { errCode, ...rest } = extra;
+    const errorCode = errCode ?? ErrorCode.UNKNOWN_ERROR;
+    this.callKit.trigger(KitEvent.KIT_ERROR, {
+      code: errorCode,
+      msg: message,
+      data: rest
+    });
+    this.callKit.reset();
+    const error = new Error(message);
+    error.name = "CallKitError";
+    error.code = errorCode;
+    error.data = rest;
+    throw error;
+  }
+  output(color) {
+    return (msg, extra = {}) => {
+      const now = /* @__PURE__ */ new Date();
+      if (Object.keys(extra).length > 0) {
+        console.log(
+          `%c[${this.prefix}] %c ${msg} %o %c ${now.toLocaleString()}`,
+          `color: ${color};`,
+          "color:block;",
+          extra,
+          "color:#999;"
+        );
+      } else {
+        console.log(
+          `%c[${this.prefix}] %c ${msg} %c ${now.toLocaleString()}`,
+          `color: ${color};`,
+          "color:block;",
+          "color:#999;"
+        );
+      }
+    };
+  }
+};
+
+// package/connect.ts
+import {
+  UserAgent,
+  Web,
+  Registerer,
+  SessionState
+} from "sip.js";
+function convertObjectStringToJSON(input) {
+  const corrected = input.replace(/(\w+):\s*'(.*?)'/g, '"$1": "$2"').replace(/'/g, '"');
+  return corrected;
+}
+var closeStream = (stream) => {
+  if (stream)
+    stream.getTracks().forEach((track) => track.stop());
+};
+var initUserMedia = () => {
+  if (typeof navigator.mediaDevices === "undefined") {
+    navigator.mediaDevices = {};
+  }
+  if (typeof navigator.mediaDevices.getUserMedia === "undefined") {
+    navigator.mediaDevices.getUserMedia = (constraints) => {
+      const getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
+      if (!getUserMedia) {
+        return Promise.reject(
+          new Error("Browser version is too low, please upgrade and try again.")
+        );
+      }
+      return new Promise((resolve, reject) => {
+        getUserMedia.call(navigator, constraints, resolve, reject);
+      });
+    };
+  }
+};
+var Connect = class {
+  callKit;
+  /**
+   * connectStatus:  init registered connecting calling
+   */
+  connectStatus = CallStatus.init;
+  currentSession;
+  mediaStream;
+  userAgent;
+  registerer;
+  sipConnected = false;
+  /**
+   * Whether it's an outgoing call
+   */
+  isOutgoing = false;
+  /**
+   * Whether it's an active hangup
+   */
+  isUnprompted = false;
+  /**
+   * Whether registered
+   * @param
+   * @deprecated Deprecated, please use isRegistered method
+   */
+  get isRegister() {
+    return this.isRegistered();
+  }
+  /**
+   * Call hold
+   * @param isHold
+   */
+  isHold = false;
+  /**
+   * Whether muted
+   */
+  isMute = false;
+  constructor(callKit) {
+    this.callKit = callKit;
+  }
+  reset() {
+    if (this.connectStatus !== CallStatus.init) {
+      this.setConnectStatus(CallStatus.init);
+    }
+    if (this.isRegistered()) {
+      this.unregister();
+    }
+    this.currentSession = void 0;
+    this.mediaStream = void 0;
+    this.userAgent = void 0;
+    this.registerer = void 0;
+    this.isOutgoing = false;
+    this.isUnprompted = false;
+    this.sipConnected = false;
+    if (this.isHold) {
+      this.setHoldStatus(false);
+    }
+  }
+  getAduioReference() {
+    const { audioRef } = this.callKit.config.getConfig();
+    if (typeof audioRef === "function") {
+      return audioRef();
+    }
+    return audioRef;
+  }
+  async permission() {
+    this.callKit.logger.debug("permission");
+    initUserMedia();
+    const _stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    closeStream(_stream);
+  }
+  isRegistered() {
+    return [
+      CallStatus.registered,
+      CallStatus.connecting,
+      CallStatus.ringing,
+      CallStatus.calling,
+      CallStatus.holding
+    ].includes(this.connectStatus);
+  }
+  /**
+   * Making connection
+   * @returns
+   */
+  isConnecting() {
+    return this.connectStatus === CallStatus.connecting;
+  }
+  /**
+   * In call
+   * @returns
+   */
+  isCalling() {
+    return this.connectStatus === CallStatus.calling;
+  }
+  /**
+   * Ringing
+   */
+  isRinging() {
+    return this.connectStatus === CallStatus.ringing;
+  }
+  /**
+   *
+   */
+  isHolding() {
+    return this.connectStatus === CallStatus.holding;
+  }
+  /**
+   * Call ended, call not started
+   * @returns
+   */
+  isInit() {
+    return this.connectStatus === CallStatus.init;
+  }
+  async register() {
+    if (this.connectStatus !== CallStatus.init) {
+      if (this.connectStatus === CallStatus.registered) {
+        this.callKit.logger.warn("connectStatus is registered");
+        return;
+      }
+      this.callKit.logger.error("connectStatus is not init", {
+        errCode: ErrorCode.CONNECT_CALL_STATUS_ERROR
+      });
+      this.callKit.callCenter.callEnd();
+      return;
+    }
+    this.callKit.logger.debug("connect register");
+    await this.permission().catch((err) => {
+      this.callKit.logger.error(err, {
+        errCode: ErrorCode.WEBRTC_USER_MEDIA_ERROR
+      });
+    });
+    const { userInfo, constrains } = this.callKit.config.getConfig();
+    const localStreamFactory = async () => {
+      this.mediaStream = await navigator.mediaDevices.getUserMedia(constrains);
+      return this.mediaStream;
+    };
+    const {
+      userPart,
+      fsIp,
+      fsPort,
+      iceInfo,
+      wsUrl
+    } = userInfo;
+    const connectConfig = {
+      uri: UserAgent.makeURI(`sip:${userPart}@${fsIp}:${fsPort}`),
+      displayName: userPart,
+      transportOptions: {
+        wsServers: [wsUrl],
+        traceSip: true
+      },
+      logLevel: "error",
+      allowLegacyNotifications: true,
+      contactName: userPart,
+      sessionDescriptionHandlerFactory: Web.defaultSessionDescriptionHandlerFactory(localStreamFactory),
+      sessionDescriptionHandlerFactoryOptions: {
+        constraints: constrains,
+        iceGatheringTimeout: userInfo.iceGatheringTimeout,
+        peerConnectionConfiguration: {
+          iceServers: JSON.parse(convertObjectStringToJSON(iceInfo))
+        }
+      }
+    };
+    this.callKit.logger.debug("connect connectConfig", connectConfig);
+    this.userAgent = new UserAgent(connectConfig);
+    const remoteStream = new MediaStream();
+    const setupRemoteMedia = (session) => {
+      const audioRef = this.getAduioReference();
+      this.callKit.logger.debug("connect setupRemoteMedia", audioRef);
+      session.sessionDescriptionHandler.peerConnection.getReceivers().forEach((receiver) => {
+        if (receiver.track) {
+          remoteStream.addTrack(receiver.track);
+        }
+      });
+      if (audioRef) {
+        audioRef.srcObject = remoteStream;
+        audioRef.play().catch((error) => {
+          this.callKit.logger.error(error.message, {
+            errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+          });
+        });
+      } else {
+        this.callKit.logger.error("video is not exist", {
+          errCode: ErrorCode.WEBRTC_AUDIO_PLAYER_ERROR
+        });
+      }
+    };
+    const registererOptions = {};
+    this.registerer = new Registerer(this.userAgent, registererOptions);
+    this.userAgent.delegate = {
+      onInvite: (invite) => {
+        this.callKit.logger.debug("connect onInvite");
+        this.currentSession = invite;
+        this.currentSession.stateChange.addListener((state) => {
+          switch (state) {
+            case SessionState.Establishing:
+              this.callKit.logger.debug("connect Establishing");
+              break;
+            case SessionState.Established:
+              this.callKit.logger.debug("connect Established");
+              if (this.connectStatus === CallStatus.registered) {
+                this.callKit.logger.warn("call is already hangup");
+                return;
+              }
+              this.sipConnected = true;
+              setupRemoteMedia(this.currentSession);
+              break;
+            case SessionState.Terminating:
+              this.callKit.logger.debug("connect Terminating");
+              break;
+            case SessionState.Terminated:
+              this.callKit.logger.debug("connect Terminated");
+              if (!this.isUnprompted) {
+                this.callKit.callCenter.callEnd();
+              }
+              this.isUnprompted = false;
+              break;
+            default:
+              break;
+          }
+        });
+        const options = {
+          sessionDescriptionHandlerOptions: {
+            constraints: constrains,
+            alwaysAcquireMediaFirst: true
+          }
+        };
+        if (this.isOutgoing) {
+          this.currentSession.accept(options);
+        } else {
+          this.callKit.trigger(KitEvent.KIT_INVITE, {
+            accept: () => {
+              this.setConnectStatus(CallStatus.connecting);
+              this.callKit.trigger(KitEvent.CALL_CONNECTING, /* @__PURE__ */ new Date());
+              this.currentSession.accept(options);
+            },
+            reject: () => {
+              this.currentSession.reject();
+              this.callKit.callCenter.callEnd(true, false);
+            },
+            getInviteData: () => {
+              const { request: request2 } = this.currentSession;
+              const headerNames = Object.keys(request2.headers);
+              const xHeaders = {};
+              headerNames.filter((name) => name.toLocaleLowerCase().startsWith("x-antaios")).forEach((name) => {
+                xHeaders[name.toLocaleLowerCase()] = request2.getHeader(name);
+              });
+              this.callKit.logger.debug("get invite data", xHeaders);
+              return xHeaders;
+            }
+          });
+        }
+      },
+      onConnect: async () => {
+        this.callKit.logger.debug("connect onConnect");
+        await this.registerer.register().then(() => {
+          this.callKit.socket.send(SocketSendEvent.START);
+        }).catch((err) => {
+          this.callKit.logger.error(err?.message, {
+            errCode: ErrorCode.WEBRTC_REGISTER_ERROR
+          });
+        });
+      },
+      onDisconnect: () => {
+        this.callKit.logger.debug("connect onDisconnect");
+        this.callKit.callCenter.callEnd();
+      },
+      onRegister: () => {
+        this.callKit.logger.debug("connect onRegister");
+      }
+    };
+    await this.userAgent.start().catch((err) => {
+      this.callKit.callCenter.callEnd(false, true);
+      this.callKit.logger.error(err, {
+        errCode: ErrorCode.WEBRTC_USER_AGENT_ERROR
+      });
+    });
+  }
+  async unregister() {
+    this.callKit.logger.debug("connect unregister");
+    if (!this.isRegistered() || !this.registerer) {
+      this.callKit.logger.warn("No registerer to unregister.");
+      return;
+    }
+    await this.registerer.unregister({ all: true }).then(() => {
+      this.setConnectStatus(CallStatus.init);
+    }).catch((err) => {
+      this.callKit.logger.error(err, {
+        errCode: ErrorCode.WEBRTC_CANCEL_REGISTER_ERROR
+      });
+    });
+  }
+  async call(callback) {
+    this.callKit.logger.debug("connect call");
+    this.isOutgoing = true;
+    if (!this.isRegistered()) {
+      await this.register();
+    }
+    this.setConnectStatus(CallStatus.connecting);
+    this.callKit.trigger(KitEvent.CALL_CONNECTING, /* @__PURE__ */ new Date());
+    const { userInfo } = this.callKit.config.getConfig();
+    callback(userInfo);
+  }
+  /**
+   * Update registration status
+   * @param register
+   */
+  setRegister(register) {
+    this.callKit.logger.debug(`connect setRegister:${register}`);
+    this.callKit.trigger(KitEvent.KIT_REGISTER_CHANGE, register);
+  }
+  /**
+   * Set call status
+   * @param status
+   */
+  setConnectStatus(status) {
+    this.callKit.logger.debug(`connect setConnectStatus: ${status}`);
+    if (this.isRegistered() && status === CallStatus.init) {
+      this.setRegister(false);
+    }
+    if (!this.isRegistered() && status !== CallStatus.init) {
+      this.setRegister(true);
+    }
+    this.connectStatus = status;
+    this.callKit.trigger(KitEvent.KIT_CALL_STATUS_CHANGE, status);
+  }
+  /**
+   * Hang up
+   * @param isUnprompted Whether actively hanging up
+   * @param isError Whether an error occurred
+   * @returns
+   */
+  async hangup(isUnprompted = false, isError = false) {
+    this.callKit.logger.debug(`connect hangup isError: ${isError}`);
+    if (this.connectStatus === CallStatus.init || this.connectStatus === CallStatus.registered)
+      return;
+    this.isOutgoing = false;
+    this.isUnprompted = isUnprompted;
+    try {
+      if (isUnprompted) {
+        this.callKit.socket.send(SocketSendEvent.AGENT_HANGUP);
+        const shouldSendBye = this.sipConnected || this.isRinging() || this.isCalling() || this.isHolding();
+        if (shouldSendBye) {
+          await this.currentSession?.bye();
+        }
+      }
+      this.sipConnected = false;
+      closeStream(this.mediaStream);
+      const audioRef = this.getAduioReference();
+      if (audioRef) {
+        audioRef.pause();
+        audioRef.srcObject = null;
+      }
+      if (isError) {
+        this.setConnectStatus(CallStatus.init);
+      } else {
+        this.setConnectStatus(CallStatus.registered);
+      }
+      this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
+    } catch (err) {
+      this.callKit.trigger(KitEvent.CALL_END, /* @__PURE__ */ new Date());
+    }
+  }
+  /**
+   * The remote media stream. Undefined if call not answered.
+   * @param session - Session to get the media stream from.
+   */
+  getRemoteMediaStream(session) {
+    this.callKit.logger.debug("connect getRemoteMediaStream");
+    const sdh = session.sessionDescriptionHandler;
+    if (!sdh) {
+      return void 0;
+    }
+    return sdh.remoteMediaStream;
+  }
+  setupRemoteMedia(session) {
+    this.callKit.logger.debug("connect setupRemoteMedia");
+    const remoteStream = this.getRemoteMediaStream(session);
+    const audioRef = this.getAduioReference();
+    if (audioRef) {
+      audioRef.autoplay = true;
+      audioRef.srcObject = remoteStream;
+      audioRef.play().catch((error) => {
+        this.callKit.logger.error(error.message, {
+          errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+        });
+      });
+      remoteStream.onaddtrack = () => {
+        this.callKit.logger.debug("Remote media onaddtrack");
+        audioRef.load();
+        audioRef.play().catch((error) => {
+          this.callKit.logger.error(error.message, {
+            errCode: ErrorCode.WEBRTC_AUDIO_PLAY_ERROR
+          });
+        });
+      };
+    } else {
+      this.callKit.logger.error("video is not exist", {
+        errCode: ErrorCode.WEBRTC_AUDIO_PLAYER_ERROR
+      });
+    }
+  }
+  /**
+   * Update hold
+   * @param hold
+   */
+  setHoldStatus(hold) {
+    this.callKit.logger.debug("connect setHold", hold);
+    this.isHold = hold;
+    this.callKit.trigger(KitEvent.KIT_SET_HOLD, hold);
+  }
+  async setHold(hold) {
+    this.setHoldStatus(hold);
+  }
+  async hold() {
+    this.callKit.logger.debug("connect hold");
+    if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
+      this.callKit.logger.error("Current status is not in call", {
+        errCode: ErrorCode.WEBRTC_HOLE_STATUS_ERROR
+      });
+      return;
+    }
+    await this.setHold(true);
+  }
+  async unhold() {
+    this.callKit.logger.debug("connect unhold");
+    await this.setHold(false);
+  }
+  async setMute(mute) {
+    this.callKit.logger.debug("connect setMute", mute);
+    if (!this.currentSession) {
+      this.callKit.logger.error("No active session", {
+        errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+      });
+      return;
+    }
+    try {
+      const sdh = this.currentSession.sessionDescriptionHandler;
+      if (!sdh || !("peerConnection" in sdh)) {
+        throw new Error("Invalid session description handler");
+      }
+      const pc = sdh.peerConnection;
+      const audioSender = pc.getSenders().find((sender) => sender.track?.kind === "audio");
+      if (audioSender && audioSender.track) {
+        audioSender.track.enabled = !mute;
+        this.isMute = mute;
+        this.callKit.trigger(KitEvent.KIT_SET_MUTE, mute);
+      } else {
+        throw new Error("No audio track found");
+      }
+    } catch (error) {
+      this.callKit.logger.error("Failed to set mute state", {
+        errCode: ErrorCode.WEBRTC_MUTE_ERROR,
+        error
+      });
+    }
+  }
+  async mute() {
+    this.callKit.logger.debug("connect mute");
+    if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
+      this.callKit.logger.error("Current status is not in call", {
+        errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+      });
+      return;
+    }
+    await this.setMute(true);
+  }
+  async unmute() {
+    this.callKit.logger.debug("connect unmute");
+    if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
+      this.callKit.logger.error("Current status is not in call", {
+        errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+      });
+      return;
+    }
+    await this.setMute(false);
+  }
+};
+
+// package/socket.ts
+var RECONNECT_CONFIG = {
+  enabled: true,
+  maxAttempts: 1,
+  delay: 1e3,
+  backoffMultiplier: 1.5,
+  pingInterval: 3e4,
+  pingTimeout: 5e3
+};
+var Socket = class {
+  callKit;
+  ws;
+  socketConfig;
+  lastPingTime = void 0;
+  isConnected = false;
+  pingTimer;
+  // Whether received server hangup confirmation
+  recivedClose = false;
+  // Whether received start confirmation
+  satrtConfirm = false;
+  reconnectTimer;
+  isReconnecting = false;
+  reconnectAttempts = 0;
+  constructor(callKit) {
+    this.callKit = callKit;
+    const { reconnect } = this.callKit.config.getConfig();
+    this.socketConfig = {
+      ...RECONNECT_CONFIG,
+      ...reconnect
+    };
+  }
+  init() {
+    const { socket } = this.callKit.config.getConfig();
+    this.callKit.logger.debug(`socket init: ${socket}`);
+    this.connect(socket);
+  }
+  connect(socketUrl) {
+    this.ws = new WebSocket(socketUrl);
+    this.ws.onopen = (ev) => this.onOpen(ev);
+    this.ws.onclose = (ev) => this.onClose(ev);
+    this.ws.onerror = (ev) => this.onError(ev);
+    this.ws.onmessage = (ev) => this.onMessage(ev);
+  }
+  onOpen(ev) {
+    this.callKit.logger.debug("socket onOpen", ev);
+    this.isConnected = true;
+    this.lastPingTime = Date.now();
+    this.checkPing();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    this.reconnectAttempts = 0;
+  }
+  onClose(ev) {
+    this.callKit.logger.debug("socket onClose", ev);
+    this.isConnected = false;
+    this.satrtConfirm = false;
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = void 0;
+    }
+    this.callKit.connect.hangup();
+    this.reset();
+  }
+  onError(ev) {
+    this.callKit.logger.error("socket onError", {
+      errCode: ErrorCode.SOCKET_CONNECT_ERROR,
+      data: ev
+    });
+    this.isConnected = false;
+    if (!this.isReconnecting && this.socketConfig.maxAttempts > 0) {
+      this.attemptReconnect();
+    } else if (this.reconnectAttempts >= this.socketConfig.maxAttempts) {
+      this.reset();
+      this.callKit.logger.error(
+        "Reconnection failed, maximum retry attempts reached",
+        {
+          errCode: ErrorCode.SOCKET_RECONNECT_FAILED
+        }
+      );
+    }
+  }
+  onMessage(ev) {
+    const data = JSON.parse(ev.data);
+    this.callKit.logger.debug("socket onMessage", data);
+    if (data.event === SocketReceiveEvent.PONG) {
+      this.lastPingTime = Date.now();
+      return;
+    }
+    if (data.event === SocketReceiveEvent.START_CONFIRM) {
+      this.callKit.logger.debug("register success");
+      this.satrtConfirm = true;
+      this.callKit.connect.setConnectStatus(CallStatus.registered);
+    }
+    if (data.event === SocketReceiveEvent.CALL_SUCCESS) {
+      this.recivedClose = false;
+      this.callKit.logger.debug("callStart");
+      this.callKit.user.setUserStatus(UserStatus.busy);
+    }
+    if (data.event === SocketReceiveEvent.CALL_FAILED) {
+      this.callKit.logger.debug(data.msg, {
+        errCode: ErrorCode.SOCKET_CALL_ERROR
+      });
+      this.callKit.user.setUserStatus(UserStatus.online);
+    }
+    if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
+      this.callKit.logger.debug(data.msg);
+      if (this.callKit.connect.isConnecting()) {
+        this.callKit.trigger(KitEvent.CALL_RINGING, /* @__PURE__ */ new Date());
+        this.callKit.connect.setConnectStatus(CallStatus.ringing);
+      }
+    }
+    if (data.event === SocketReceiveEvent.CUSTOMER_PICK_UP) {
+      this.callKit.logger.debug(data.msg);
+      if (this.callKit.connect.isRinging()) {
+        this.callKit.connect.setConnectStatus(CallStatus.calling);
+        this.callKit.trigger(KitEvent.CALL_PICK_UP, /* @__PURE__ */ new Date());
+      }
+    }
+    if (data.event === SocketReceiveEvent.AGENT_PICK_UP) {
+      this.callKit.logger.debug(data.msg);
+      this.callKit.trigger(KitEvent.AGENT_PICK_UP, /* @__PURE__ */ new Date());
+    }
+    if (data.event === SocketReceiveEvent.CUSTOMER_HANG_UP) {
+      this.callKit.logger.debug(data.msg);
+      this.callKit.trigger(KitEvent.CALL_HANG_UP, /* @__PURE__ */ new Date());
+      this.callKit.user.setUserStatus(UserStatus.catNap);
+    }
+    if (data.event === SocketReceiveEvent.CUSTOMER_NO_ANSWER) {
+      this.callKit.logger.debug(data.msg);
+      this.callKit.trigger(KitEvent.CALL_NO_ANSWER);
+      this.callKit.user.setUserStatus(UserStatus.catNap);
+    }
+    if (data.event === SocketReceiveEvent.CALL_CDR) {
+      this.callKit.logger.debug(data.msg);
+      this.callKit.trigger(KitEvent.CALL_CDR, data.data);
+    }
+    if (data.event === SocketReceiveEvent.STOP_CONFIRM) {
+      this.callKit.logger.debug(data.msg);
+      this.recivedClose = true;
+    }
+    if (data.event === SocketReceiveEvent.CLOSE) {
+      const { userInfo } = this.callKit.config.getConfig();
+      this.callKit.logger.debug(data.msg);
+      this.send(SocketSendEvent.END, {
+        agentId: userInfo.agentId
+      });
+    }
+    if (data.event === SocketReceiveEvent.ERROR) {
+      this.callKit.logger.error(data.msg, {
+        errCode: ErrorCode.SOKET_SERVER_ERROR,
+        data
+      });
+      this.callKit.user.setUserStatus(UserStatus.catNap);
+    }
+    if (data.event === SocketReceiveEvent.AGENT_NO_ANSWER) {
+      this.callKit.user.setUserStatus(UserStatus.catNap);
+    }
+    this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, data);
+  }
+  send(event, message) {
+    if (!this.isConnected) {
+      this.callKit.logger.error("socket not connected", {
+        errCode: ErrorCode.SOCKET_CONNECT_ERROR
+      });
+      this.callKit.config.reset();
+      this.callKit.reset();
+      return;
+    }
+    const { userInfo } = this.callKit.config.getConfig();
+    const { sessionId, extno, agentId } = userInfo;
+    if (!sessionId) {
+      this.callKit.logger.error("sessionId is empty", {
+        errCode: ErrorCode.SOCKET_CONNECT_ERROR
+      });
+      return;
+    }
+    const msg = {
+      event,
+      sessionId,
+      ...message
+    };
+    if (SocketSendEvent.CALL === event) {
+      msg.phoneNum = extno;
+      msg.agentId = agentId;
+    }
+    this.callKit.logger.debug("socket send", msg);
+    switch (event) {
+      case SocketSendEvent.PING:
+        this.lastPingTime = Date.now();
+        this.ws?.send(JSON.stringify({ event, ...msg }));
+        break;
+      default:
+        this.ws?.send(JSON.stringify({ event, ...msg }));
+        break;
+    }
+  }
+  /**
+   * Attempt to close socket, need to wait for server confirmation
+   * @returns
+   */
+  async requestClose() {
+    return new Promise((resolve) => {
+      let remainingTime = 5;
+      const interval = setInterval(() => {
+        remainingTime -= 1;
+        if (this.recivedClose || remainingTime <= 0) {
+          clearInterval(interval);
+          resolve(this.recivedClose);
+        }
+      }, 1e3);
+    });
+  }
+  ping() {
+    if (!this.isConnected)
+      return;
+    this.send(SocketSendEvent.PING);
+    const now = Date.now();
+    this.callKit.logger.debug(`socket ping: ${now - this.lastPingTime}ms`);
+    const { pingInterval, pingTimeout } = this.socketConfig;
+    if (now - this.lastPingTime > pingInterval + pingTimeout) {
+      this.callKit.logger.error("socket ping timeout", {
+        errCode: ErrorCode.SOCKET_PING_TIMEOUT
+      });
+      if (this.ws && this.isConnected) {
+        this.ws.close(4001, "ping timeout");
+      } else {
+        this.reset();
+      }
+    }
+  }
+  checkPing() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+    }
+    this.ping();
+    this.pingTimer = setInterval(() => {
+      this.ping();
+    }, this.socketConfig.pingInterval);
+  }
+  /**
+   *
+   * @param isWaitConfirm Whether need to wait for close confirmation
+   */
+  async reset(isWaitConfirm = true) {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    this.lastPingTime = void 0;
+    this.pingTimer = void 0;
+    this.satrtConfirm = false;
+    this.isReconnecting = false;
+    this.reconnectAttempts = 0;
+    if (this.ws && this.isConnected) {
+      if (isWaitConfirm) {
+        await this.requestClose();
+      }
+      this.recivedClose = false;
+      this.callKit.logger.debug("socket destroy");
+      this.ws.close();
+      this.isConnected = false;
+    }
+  }
+  attemptReconnect() {
+    if (this.isReconnecting) {
+      return;
+    }
+    this.isReconnecting = true;
+    const delay = this.socketConfig.delay * this.socketConfig.backoffMultiplier ** this.reconnectAttempts;
+    this.callKit.logger.debug(
+      `Preparing reconnection attempt ${this.reconnectAttempts + 1}, delay: ${delay}ms`
+    );
+    this.reconnectTimer = setTimeout(() => {
+      const { socket } = this.callKit.config.getConfig();
+      this.connect(socket);
+      this.reconnectAttempts += 1;
+      this.isReconnecting = false;
+    }, delay);
+  }
+};
+
+// package/user.ts
+var User = class {
+  callKit;
+  userStatus;
+  // logout(1, "unregistered"), idle(2, "free"), break(3, "nap"), busy(4, "busy")
+  constructor(callKit) {
+    this.callKit = callKit;
+  }
+  /**
+   *
+   * @param status logout(1, "unregistered"), idle(2, "free"), break(3, "nap"), busy(4, "busy")
+   */
+  async setUserStatus(status) {
+    const { isAutoUpdateUserStatus } = this.callKit.config.getConfig();
+    if (status === this.userStatus || !isAutoUpdateUserStatus)
+      return;
+    return this.updateUserStatus(status);
+  }
+  /**
+   * Update user status
+   * @param status
+   */
+  async updateUserStatus(status) {
+    const { agentId } = this.callKit.config.getConfig().userInfo;
+    if (!this.callKit.config.isLogin()) {
+      this.userStatus = UserStatus.offline;
+      this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, UserStatus.offline);
+      return;
+    }
+    await this.callKit.api.setUserStatus({
+      agentId,
+      userStatus: status
+    }).then(() => {
+      this.userStatus = status;
+      this.callKit.trigger(KitEvent.KIT_USER_STATUS_CHANGE, status);
+    }).catch((err) => {
+      this.callKit.logger.error(err, {
+        errCode: ErrorCode.API_USER_STATUS_UPDATE_ERROR
+      });
+    });
+  }
+};
+
+// package/index.ts
+var CallKit = class {
+  api;
+  config;
+  logger;
+  callCenter;
+  connect;
+  socket;
+  user;
+  listener = [];
+  constructor(options) {
+    this.config = new Config(this);
+    this.config.setConfig("log", options.log);
+    this.config.setConfig("audioRef", options.audioRef);
+    this.config.setConfig("host", options.host);
+    this.config.setConfig(
+      "constrains",
+      options.constrains || constrainsDefault
+    );
+    this.config.setConfig("socket", options.socket);
+    this.config.setConfig(
+      "isAutoUpdateUserStatus",
+      options.isAutoUpdateUserStatus === void 0 ? isAutoUpdateUserStatusDefault : options.isAutoUpdateUserStatus
+    );
+    this.logger = new Logger(this, options.log);
+    this.logger.debug("callKit init", options);
+    this.api = new Api(this);
+    this.connect = new Connect(this);
+    this.callCenter = new Call(this);
+    this.socket = new Socket(this);
+    this.user = new User(this);
+  }
+  async login(username, password, extra = {}) {
+    if (this.config.isLogin()) {
+      this.logger.warn("already login");
+      return;
+    }
+    this.logger.debug("login info:", {
+      username,
+      password
+    });
+    const user = await this.api.login({
+      userName: username,
+      password: md5(username + md5(password))
+    }).catch((err) => {
+      this.logger.error(err, { errCode: ErrorCode.API_USER_LOGIN_ERROR });
+    });
+    if (user) {
+      this.config.setConfig("userInfo", {
+        wsUrl: `wss://${user.wsUrl}`,
+        sessionId: user.sessionId,
+        username,
+        password,
+        agentId: user.agentId,
+        fsUserId: user.fsUserId,
+        userPart: user.userPart,
+        fsPassword: user.fsPassword,
+        fsIp: user.fsIp,
+        fsPort: user.fsPort,
+        iceInfo: user.iceInfo,
+        iceGatheringTimeout: user.iceGatheringTimeout,
+        ...extra
+      });
+      this.socket.init();
+      this.trigger(KitEvent.KIT_LOGIN_CHANGE, true);
+      this.user.setUserStatus(UserStatus.offline);
+    }
+  }
+  async logout() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("logout");
+    await this.user.setUserStatus(UserStatus.offline);
+    if (this.config.isLogin()) {
+      const { sessionId } = this.config.getConfig().userInfo;
+      this.api.loginOut({ sessionId }).catch((err) => {
+        this.logger.error(err, { errCode: ErrorCode.API_USER_LOGOUT_ERROR });
+      });
+    }
+    await this.hangup();
+    this.socket.reset(false);
+    this.connect.reset();
+    this.config.reset();
+    this.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
+  }
+  async call(extno) {
+    if (!this.config.check())
+      return;
+    if (!this.connect.isRegistered()) {
+      this.logger.warn("Currently not registered");
+      return;
+    }
+    if (extno) {
+      this.config.setUserInfo("extno", extno);
+    }
+    this.logger.debug("call");
+    this.callCenter.callStart();
+  }
+  async register() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("register");
+    this.connect.register();
+    await this.user.setUserStatus(UserStatus.online);
+  }
+  async unregister() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("unregister");
+    this.connect.unregister();
+    await this.user.setUserStatus(UserStatus.offline);
+  }
+  async hangup() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("hangup", this.connect.connectStatus);
+    if (!this.connect.isConnecting() && !this.connect.isRinging() && !this.connect.isCalling() && !this.connect.isHolding()) {
+      this.logger.warn("Currently not in a call");
+      return;
+    }
+    await this.callCenter.callEnd(true);
+    this.user.setUserStatus(UserStatus.catNap);
+  }
+  hold() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("hold");
+    this.callCenter.callHold();
+  }
+  unhold() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("unhold");
+    this.callCenter.callUnhold();
+  }
+  async setFree() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("setFree");
+    await this.user.setUserStatus(UserStatus.online);
+  }
+  async setSleep() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("setSleep");
+    await this.user.setUserStatus(UserStatus.catNap);
+  }
+  async setBusy() {
+    if (!this.config.check())
+      return;
+    this.logger.debug("setBusy");
+    await this.user.setUserStatus(UserStatus.busy);
+  }
+  async reset() {
+    this.logger.debug("reset");
+    this.connect.reset();
+    if (this.config.isLogin()) {
+      await this.user.setUserStatus(UserStatus.online);
+    } else {
+      await this.user.setUserStatus(UserStatus.offline);
+    }
+  }
+  on(event, callback) {
+    this.logger.debug(`on ${event}`);
+    this.listener.push({
+      event,
+      callback
+    });
+  }
+  off(event, callback) {
+    this.logger.debug(`off ${event}`);
+    if (callback) {
+      this.listener = this.listener.filter(
+        (item) => !(item.event === event && item.callback === callback)
+      );
+    } else {
+      this.listener = this.listener.filter((item) => item.event !== event);
+    }
+  }
+  removeAllListeners() {
+    this.listener = this.listener.splice(0, this.listener.length);
+    this.logger.debug("removeAllListeners");
+  }
+  trigger(event, data) {
+    this.logger.debug(`trigger ${event}`, { data });
+    this.listener.forEach((item) => {
+      if (item.event === event) {
+        try {
+          item.callback(data);
+        } catch (err) {
+          this.logger.error("Event callback error:", err);
+        }
+      }
+    });
+  }
+};
+export {
+  CallKit
+};
+//# sourceMappingURL=index.mjs.map