ue-softphone-sdk-beta 4.0.57 → 4.0.59

package/README.md

@@ -14,4 +14,6 @@
     > a.增加closeSdkMonitor监控关闭方法，type(summary: 监控总览, agent: 座席监控, queue: 服务组监控)
     > b.sdkMonitorMsg方法，开启监控总览 type类型由string改为array
 > 4.0.45 
-    > 登录增加passwordPk参数
+    > 登录增加passwordPk参数
+> 4.0.59 
+    > 新增demo.html测试页面

package/dist/lib/types/config.d.ts

@@ -1,11 +1,14 @@
-export declare const NOT_OPEN_AUDIO: {
-    notOpenAudioMsg: string;
-    notOpenAudioCode: number;
-    notOpenAudioMsgEn: string;
-};
-export declare const AUDIO_FORBIDDEN: {
-    forbiddenAudioMsg: string;
-    forbiddenAudioCode: number;
-    forbiddenAudioMsgEn: string;
-};
-export declare const DENIED = "denied";
+type MicrophoneClosedNotice = Readonly<{
+    ["notOpenAudioMsg"]: string;
+    ["notOpenAudioCode"]: number;
+    ["notOpenAudioMsgEn"]: string;
+}>;
+type MicrophoneDeniedNotice = Readonly<{
+    ["forbiddenAudioMsg"]: string;
+    ["forbiddenAudioCode"]: number;
+    ["forbiddenAudioMsgEn"]: string;
+}>;
+export declare const NOT_OPEN_AUDIO: MicrophoneClosedNotice;
+export declare const AUDIO_FORBIDDEN: MicrophoneDeniedNotice;
+export declare const DENIED: "denied";
+export {};

package/dist/lib/types/core/commands/call-command.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from "./command-executor";
+import type { RequestPipeline } from "../pipeline/request-pipeline";
+import type { Result } from "../types/result";
+interface CallCommandPayload {
+    endpoint: string;
+    body: any;
+    onSuccess?: (data: any) => void;
+    onFail?: (err: any) => void;
+}
+export declare class CallCommand implements Command {
+    private pipeline;
+    private baseUrl;
+    payload: CallCommandPayload;
+    type: string;
+    constructor(pipeline: RequestPipeline, baseUrl: string, payload: CallCommandPayload);
+    execute(): Promise<Result<any, any>>;
+}
+export {};

package/dist/lib/types/core/commands/command-executor.d.ts

@@ -0,0 +1,14 @@
+import type { EventBus } from "../events/event-bus";
+import type { Result } from "../types/result";
+export interface Command<T = any> {
+    type: string;
+    payload: any;
+    execute(): Promise<Result<T, any>>;
+}
+export declare class CommandExecutor {
+    private eventBus;
+    private history;
+    constructor(eventBus: EventBus);
+    execute<T>(command: Command<T>): Promise<Result<T, any>>;
+    getHistory(): Command[];
+}

package/dist/lib/types/core/config/config-manager.d.ts

@@ -0,0 +1,11 @@
+type ConfigValidator<T> = (value: T) => boolean;
+export declare class ConfigManager<T extends Record<string, any>> {
+    private layers;
+    private validators;
+    private cache;
+    addLayer(priority: number, values: Partial<T>): void;
+    setValidator<K extends keyof T>(key: K, validator: ConfigValidator<T[K]>): void;
+    get<K extends keyof T>(key: K, defaultValue: T[K]): T[K];
+    set<K extends keyof T>(key: K, value: T[K], priority?: number): void;
+}
+export {};

package/dist/lib/types/core/events/event-bus.d.ts

@@ -0,0 +1,14 @@
+type EventHandler<T = any> = (data: T) => void | Promise<void>;
+interface Subscription {
+    unsubscribe: () => void;
+}
+export declare class EventBus {
+    private handlers;
+    private onceHandlers;
+    on<T = any>(event: string, handler: EventHandler<T>): Subscription;
+    once<T = any>(event: string, handler: EventHandler<T>): Subscription;
+    off(event: string, handler: EventHandler): void;
+    emit<T = any>(event: string, data: T): Promise<void>;
+    clear(event?: string): void;
+}
+export {};

package/dist/lib/types/core/interceptors/common-interceptors.d.ts

@@ -0,0 +1,16 @@
+import type { Interceptor, RequestContext } from "../pipeline/request-pipeline";
+export declare class AuthInterceptor implements Interceptor {
+    private getToken;
+    private getSessionId;
+    name: string;
+    constructor(getToken: () => string | undefined, getSessionId: () => string | undefined);
+    request(ctx: RequestContext): RequestContext;
+}
+export declare class EncryptionInterceptor implements Interceptor {
+    name: string;
+    request(ctx: RequestContext): RequestContext;
+}
+export declare class ErrorHandlerInterceptor implements Interceptor {
+    name: string;
+    error(err: any): any;
+}

package/dist/lib/types/core/pipeline/request-pipeline.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from "../types/result";
+export interface RequestContext {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: any;
+    metadata: Record<string, any>;
+}
+export interface ResponseContext<T = any> {
+    status: number;
+    data: T;
+    headers: Record<string, string>;
+}
+export interface Interceptor {
+    name: string;
+    request?: (ctx: RequestContext) => Promise<RequestContext> | RequestContext;
+    response?: <T>(ctx: ResponseContext<T>) => Promise<ResponseContext<T>> | ResponseContext<T>;
+    error?: (err: any, ctx: RequestContext) => Promise<any> | any;
+}
+export declare class RequestPipeline {
+    private interceptors;
+    use(interceptor: Interceptor): void;
+    execute<T>(ctx: RequestContext, fetcher: (ctx: RequestContext) => Promise<Response>): Promise<Result<ResponseContext<T>, any>>;
+}

package/dist/lib/types/core/runtime.d.ts

@@ -0,0 +1,26 @@
+import { EventBus } from "./events/event-bus";
+import { RequestPipeline } from "./pipeline/request-pipeline";
+import { CommandExecutor } from "./commands/command-executor";
+import { MediaController } from "./webrtc/media-controller";
+import { TransportLayer } from "./transport/transport-layer";
+import { StateManager } from "./state/state-manager";
+interface RuntimeState {
+    loginToken?: string;
+    sessionId?: string;
+    agentInfo?: any;
+    callApiUrl: string;
+    isKickedOff: boolean;
+}
+export declare class CoreRuntime {
+    readonly eventBus: EventBus;
+    readonly pipeline: RequestPipeline;
+    readonly executor: CommandExecutor;
+    readonly mediaController: MediaController;
+    readonly state: StateManager<RuntimeState>;
+    private transports;
+    constructor();
+    createTransport(key: string, config: any, socketFactory: any): TransportLayer;
+    getTransport(key: string): TransportLayer | undefined;
+    cleanup(): void;
+}
+export {};

package/dist/lib/types/core/state/state-manager.d.ts

@@ -0,0 +1,9 @@
+export declare class StateManager<T> {
+    private state;
+    private listeners;
+    constructor(initialState: T);
+    get(): T;
+    set(updater: (prev: T) => T): void;
+    update(partial: Partial<T>): void;
+    subscribe(listener: (state: T) => void): () => void;
+}

package/dist/lib/types/core/transport/transport-layer.d.ts

@@ -0,0 +1,26 @@
+import type { EventBus } from "../events/event-bus";
+export declare enum ConnectionState {
+    IDLE = 0,
+    CONNECTING = 1,
+    CONNECTED = 2,
+    RECONNECTING = 3,
+    DISCONNECTED = 4,
+    FAILED = 5
+}
+export interface TransportConfig {
+    server: string;
+    options: any;
+    reconnectDelay?: number;
+    maxRetries?: number;
+}
+export declare class TransportLayer {
+    private config;
+    private eventBus;
+    private socketFactory;
+    private state;
+    private socket;
+    private retries;
+    private reconnectTimer;
+    constructor(config: TransportConfig, eventBus: EventBus, socketFactory: (server: string, options: any) => any);
+    private handleError;
+}

package/dist/lib/types/core/types/result.d.ts

@@ -0,0 +1,19 @@
+export type Result<T, E = Error> = Success<T> | Failure<E>;
+export declare class Success<T> {
+    readonly value: T;
+    readonly ok = true;
+    constructor(value: T);
+    map<U>(fn: (val: T) => U): Result<U, never>;
+    flatMap<U, E>(fn: (val: T) => Result<U, E>): Result<U, E>;
+    unwrap(): T;
+}
+export declare class Failure<E> {
+    readonly error: E;
+    readonly ok = false;
+    constructor(error: E);
+    map<U>(): Result<U, E>;
+    flatMap<U>(): Result<U, E>;
+    unwrap(): never;
+}
+export declare const ok: <T>(value: T) => Result<T, never>;
+export declare const fail: <E>(error: E) => Result<never, E>;

package/dist/lib/types/core/webrtc/media-controller.d.ts

@@ -0,0 +1,14 @@
+import type { EventBus } from "../events/event-bus";
+import type { WebrtcOptions } from "../../webrtc/webrtc-adapter";
+export declare class MediaController {
+    private eventBus;
+    private webPhone;
+    constructor(eventBus: EventBus);
+    preparePhone(config: WebrtcOptions): Promise<void>;
+    answerIncoming(): void;
+    ensureOnline(): void;
+    releasePhone(): Promise<void>;
+    pushTone(tone: string): void;
+    hasActivePhone(): boolean;
+    currentPhone(): any;
+}

package/dist/lib/types/index.d.ts

@@ -1,223 +1,22 @@
-type DebugType = "trace" | "debug" | "log" | "warn" | "error" | "all";
-type ExtenType = "PSTN" | "SIP" | "WEBRTC";
-interface AudioInfo {
-    notOpenAudioMsg: string;
-    notOpenAudioCode: number;
-    notOpenAudioMsgEn: string;
-    forbiddenAudioMsg: string;
-    forbiddenAudioCode: number;
-    forbiddenAudioMsgEn: string;
-}
-interface InitOptions {
-    accountId?: string;
-    agentNumber?: string;
-    accountName?: string;
-    password?: string;
-    passwordPk?: string;
-    loginType?: ExtenType;
-    debug?: DebugType | DebugType[] | boolean;
-    success?: Function;
-    error?: Function;
-    server?: string;
-    audioInfo?: AudioInfo;
-    sdkMonitorType?: any;
-    isOpenNetwork?: boolean;
-    volume?: {
-        open: boolean;
-        interval: number;
-    };
-    pushHangupStatistics?: boolean;
-    pushCallinRingStatistics?: boolean;
-    isOpenCallQueue?: boolean;
-    openNlsTranslation?: boolean;
-    monitor?: boolean;
-}
-interface OnCallEventParams {
-    success?: Function;
-    message?: Function;
-    error?: Function;
-    event?: Function;
-}
-interface OnCallVolumeParams {
-    success?: Function;
-    message?: Function;
-    error?: Function;
-    event?: Function;
-}
-interface DialoutParams {
-    agentNumber?: String;
-    accountId: String;
-    agentId: String;
-    loginType?: String;
-    customerNumber: String;
-    agentTimeout?: String;
-    customerTimeout?: String;
-    agentDisNumber?: String;
-    customerDisNumber?: String;
-    extras?: any;
-    success?: Function;
-    fail?: Function;
-    numberGroupId?: String;
-    numberGroupName?: String;
-    encrypt?: Number;
-}
-interface HangupParams {
-    success?: Function;
-    fail?: Function;
-}
-interface HoldOrUnHoldParams {
-    type: String;
-    success?: Function;
-    fail?: Function;
-}
-interface MuteOrUnMuteParams {
-    type: String;
-    direction: String;
-    success?: Function;
-    fail?: Function;
-}
-interface TransferParams {
-    type: String;
-    number: String;
-    agentNumber?: String;
-    success?: Function;
-    fail?: Function;
-}
-interface UpdateLoginTypeParams {
-    loginType: ExtenType;
-    loginNumber?: String;
-    success?: Function;
-    fail?: Function;
-}
-interface GetAgentPhoneBarParams {
-    success?: Function;
-    fail?: Function;
-}
-interface GetQueueOnlineAgentsParams {
-    success?: Function;
-    fail?: Function;
-}
-interface AgentOfflineParams {
-    success?: Function;
-    fail?: Function;
-    toAnswerOffline?: String;
-}
-interface UpdateAgentStatusParams {
-    stateNumber: String;
-    success?: Function;
-    fail?: Function;
-}
-interface consultParams {
-    mode: String;
-    number: String;
-    agentNumber: String;
-    success?: Function;
-    fail?: Function;
-}
-interface cancleConsultParams {
-    success?: Function;
-    fail?: Function;
-}
-interface stopConsultParams {
-    success?: Function;
-    fail?: Function;
-}
-interface resumeConsultParams {
-    success?: Function;
-    fail?: Function;
-}
-interface consultTransferParams {
-    success?: Function;
-    fail?: Function;
-}
-interface threeWayCallParams {
-    success?: Function;
-    fail?: Function;
-}
-interface satisfactionParams {
-    type: String;
-    success?: Function;
-    fail?: Function;
-}
-interface meetingParams {
-    number: String;
-    success?: Function;
-    fail?: Function;
-}
-interface listenParams {
-    agentNumber: String;
-    success?: Function;
-    fail?: Function;
-}
-interface lootParams {
-    agentNumber: String;
-    success?: Function;
-    fail?: Function;
-}
-interface whisperParams {
-    agentNumber: String;
-    success?: Function;
-    fail?: Function;
-}
-interface forcedHangupParams {
-    agentNumber: String;
-    success?: Function;
-    fail?: Function;
-}
-interface breakinParams {
-    agentNumber: String;
-    success?: Function;
-    fail?: Function;
-}
+import { type DestroyCallbacks, type InitOptions, type OnCallEventParams, type OnCallVolumeParams } from "./sdk/types";
 export default class ueSoftphone {
-    static summaryUeTimer: any;
-    static agentUeTimer: any;
-    static queueUeTimer: any;
-    static loginToken: String | undefined;
-    static agentInfo: any;
-    static initOptions: InitOptions;
-    static webPhone: any;
-    static callApiUrl: String;
-    static agentextras: any;
-    static Socketinstance: any;
-    static AudioTask: any;
-    static MonitorSocketinstance: any;
-    static UserConfig: any;
-    static isCanRing: any;
-    static argeementType: String;
     static noop(): void;
-    static debug: (msg: any) => void;
-    static log: (msg: any) => void;
-    static warn: (msg: any) => void;
-    static error: (msg: any) => void;
-    static trace: (msg: any) => void;
-    static newWebSocket: (server: string, proto: any) => any;
-    static request: (server: string, proto: any) => any;
-    private attachEventCallbacks;
-    private attachMonitorEventCallbacks;
-    private attachNlsTranslationEventCallbacks;
-    private allMonitorEventCallbacks;
+    private volumeController;
+    private monitorManager;
+    private sessionManager;
+    static get loginToken(): string;
+    static get agentInfo(): any;
+    static get initOptions(): InitOptions;
+    static get callApiUrl(): string;
+    static setLoginToken(token: string): void;
+    static setSessionId(sessionId: string): void;
+    static setAgentInfo(info: any): void;
+    static setCallApiUrl(url: string): void;
     constructor(options?: InitOptions);
-    private init;
-    private getDomain;
+    private bootstrap;
     private login;
-    static createEventHandle(callbacks?: any): void;
     static kickOffEvent: () => void;
-    private getWebrtcInfo;
-    private initAttachEvent;
-    private attachNetworkCallbacks;
-    private initnNetworkMonitoring;
     listenCallNetork: (callbacks: OnCallEventParams) => void;
-    private volumeCallbacks;
-    private stopVolumeCallbacks;
-    private audioContext;
-    private analyser;
-    private dataArray;
-    private stream;
-    private volumeIntervalId;
-    private getMicrophoneVolume;
-    private initAudioDetection;
-    private startVolumeDetection;
     clearVolumeDetection: () => void;
     stopVolumeDetection: () => void;
     listenCallVolume: (callbacks: OnCallVolumeParams) => void;
@@ -226,76 +25,55 @@ export default class ueSoftphone {
     muteRing: (callbacks: OnCallVolumeParams) => void;
     sdkMonitorMsg: (params: any) => void;
     closeSdkMonitor: (params: any) => void;
-    private initAgentQueue;
-    private initQueue;
-    static createQueueMonitorEventHandle(callbacks?: any): void;
-    static createopenNlsTransEventHandle(callbacks?: any): void;
-    static createopenAllMonitorEventHandle(callbacks?: any): void;
-    static changeMonitorEventHandle(callbacks: any, msg: any): void;
-    static handleHttpMonitor(msg: any, callbacks: any): void;
     listenCallQueueEvent: (callbacks: any) => void;
     listenTranslationEvent: (callbacks: any) => void;
     listenMonitor: (callbacks: any) => void;
-    static useDefaultDependencies(deps: any): {
-        newWebSocket(server: string, proto: any): any;
-        request(url: string, options: any): any;
-    };
     private static initWebrtcEvent;
     private openMediaAudio;
     listenCallEvent: (callbacks: OnCallEventParams) => void;
     get agent(): {
-        switchLoginType(params: UpdateLoginTypeParams): Promise<void>;
-        findPhoneBarList(params: GetAgentPhoneBarParams): void;
-        switchPhoneBar(params: UpdateAgentStatusParams): void;
-        logout(params: AgentOfflineParams): void;
-        findIdleAgentsForQueue(params: GetQueueOnlineAgentsParams): void;
-        getAvailableSipNumberList(params: any): void;
+        switchLoginType(params: import("./sdk/types").UpdateLoginTypeParams): Promise<any>;
+        findPhoneBarList(params: import("./sdk/types").GetAgentPhoneBarParams): Promise<any>;
+        switchPhoneBar(params: import("./sdk/types").UpdateAgentStatusParams): Promise<any>;
+        logout(params: import("./sdk/types").AgentOfflineParams): Promise<any>;
+        findIdleAgentsForQueue(params: import("./sdk/types").GetQueueOnlineAgentsParams): Promise<any>;
+        getAvailableSipNumberList(params: any): Promise<any>;
     };
     get webrtc(): {
         accept(): void;
-        connect(): void;
-        disconnect(): void;
-        isConnected(): any;
+        connect(): Promise<void>;
+        disconnect(): Promise<void>;
+        isConnected(): boolean;
         sendDTMF(tone: string): void;
     };
     get call(): {
-        callout(params: DialoutParams): Promise<void>;
-        hangup(params: HangupParams): void;
-        holdOrUnHold(params: HoldOrUnHoldParams): void;
-        muteOrUnMute(params: MuteOrUnMuteParams): void;
-        transfer(params: TransferParams): void;
-        consult(params: consultParams): void;
-        cancelconsult(params: cancleConsultParams): void;
-        endConsult(params: stopConsultParams): void;
-        callbackConsult(params: resumeConsultParams): void;
-        consultTransfer(params: consultTransferParams): void;
-        threeWayCall(params: threeWayCallParams): void;
-        evaluate(params: satisfactionParams): void;
-        meeting(params: meetingParams): void;
-        listen(params: listenParams): void;
-        loot(params: lootParams): void;
-        forcedHangup(params: forcedHangupParams): void;
-        breakIn(params: breakinParams): void;
-        whisper(params: whisperParams): void;
+        callout(params: import("./sdk/types").DialoutParams): Promise<any>;
+        hangup(params: import("./sdk/types").HangupParams): Promise<any>;
+        holdOrUnHold(params: import("./sdk/types").HoldOrUnHoldParams): Promise<any>;
+        muteOrUnMute(params: import("./sdk/types").MuteOrUnMuteParams): Promise<any>;
+        transfer(params: import("./sdk/types").TransferParams): Promise<any>;
+        consult(params: import("./sdk/types").consultParams): Promise<any>;
+        cancelconsult(params: import("./sdk/types").cancleConsultParams): Promise<any>;
+        endConsult(params: import("./sdk/types").stopConsultParams): Promise<any>;
+        callbackConsult(params: import("./sdk/types").resumeConsultParams): Promise<any>;
+        consultTransfer(params: import("./sdk/types").consultTransferParams): Promise<any>;
+        threeWayCall(params: import("./sdk/types").threeWayCallParams): Promise<any>;
+        evaluate(params: import("./sdk/types").satisfactionParams): Promise<any>;
+        meeting(params: import("./sdk/types").meetingParams): Promise<any>;
+        listen(params: import("./sdk/types").listenParams): Promise<any>;
+        loot(params: import("./sdk/types").lootParams): Promise<any>;
+        forcedHangup(params: import("./sdk/types").forcedHangupParams): Promise<any>;
+        breakIn(params: import("./sdk/types").breakinParams): Promise<any>;
+        whisper(params: import("./sdk/types").whisperParams): Promise<any>;
     };
     private _callApi;
     private _agentApi;
     _webPhoneApi: () => {
         accept(): void;
-        connect(): void;
-        disconnect(): void;
-        isConnected(): any;
+        connect(): Promise<void>;
+        disconnect(): Promise<void>;
+        isConnected(): boolean;
         sendDTMF(tone: string): void;
     };
-    /**
-    * 销毁SDK实例，断开所有连接并清理资源
-    * @param callbacks - 回调函数对象
-    * @param callbacks.success - 成功回调
-    * @param callbacks.fail - 失败回调
-    */
-    destroy(callbacks?: {
-        success?: Function;
-        fail?: Function;
-    }): void;
+    destroy(callbacks?: DestroyCallbacks): void;
 }
-export {};

package/dist/lib/types/sdk/agent-api.d.ts

@@ -0,0 +1,10 @@
+import { type AgentApiDependencies } from "./agent-commands";
+import type { AgentOfflineParams, GetAgentPhoneBarParams, GetQueueOnlineAgentsParams, UpdateAgentStatusParams, UpdateLoginTypeParams } from "./types";
+export declare const createAgentApi: (deps: AgentApiDependencies) => {
+    switchLoginType(params: UpdateLoginTypeParams): Promise<any>;
+    findPhoneBarList(params: GetAgentPhoneBarParams): Promise<any>;
+    switchPhoneBar(params: UpdateAgentStatusParams): Promise<any>;
+    logout(params: AgentOfflineParams): Promise<any>;
+    findIdleAgentsForQueue(params: GetQueueOnlineAgentsParams): Promise<any>;
+    getAvailableSipNumberList(params: any): Promise<any>;
+};

package/dist/lib/types/sdk/agent-commands.d.ts

@@ -0,0 +1,10 @@
+import { type SharedApiDependencies } from "./api-support";
+import { CommandRegistry } from "./command-registry";
+export interface AgentApiDependencies extends SharedApiDependencies {
+    request: (url: string, options: any) => any;
+    connectWebPhone: () => void;
+    disconnectWebPhone: () => void;
+    cleanupConnections: (markKickoff: boolean) => void;
+    updateLoginTypeState: (loginType: string) => void;
+}
+export declare const buildAgentRegistry: () => CommandRegistry<any>;

package/dist/lib/types/sdk/api-support.d.ts

@@ -0,0 +1,19 @@
+import type { InitOptions } from "./types";
+export interface SharedApiDependencies {
+    noop: () => void;
+    getLoginToken: () => String | undefined;
+    getAgentInfo: () => any;
+    getInitOptions: () => InitOptions;
+    getCallApiUrl: () => String;
+}
+type WithSuccessFail = {
+    success?: Function;
+    fail?: Function;
+};
+export declare const isNil: (value: any) => boolean;
+export declare const normalizeSuccessFailCallbacks: <T extends WithSuccessFail>(params: T, noop: () => void) => T;
+export declare const getServerUrl: (initOptions: InitOptions, callApiUrl: String) => string;
+export declare const ensureSessionReady: (params: WithSuccessFail, deps: SharedApiDependencies, options?: {
+    checkKickOff?: boolean;
+}) => any | null;
+export {};

package/dist/lib/types/sdk/audio-utils.d.ts

@@ -0,0 +1,18 @@
+export declare const tryPlayAudio: (audio: HTMLAudioElement, retry?: number, interval?: number) => Promise<boolean>;
+export declare const stopMediaStream: (stream: MediaStream) => void;
+export declare const resolveUserMedia: () => {
+    mediaDevices: any;
+    modern: any;
+    legacy: any;
+};
+export declare const mapAudioPermissionError: (err: any) => Readonly<{
+    notOpenAudioMsg: string;
+    notOpenAudioCode: number;
+    notOpenAudioMsgEn: string;
+}> | Readonly<{
+    forbiddenAudioMsg: string;
+    forbiddenAudioCode: number;
+    forbiddenAudioMsgEn: string;
+}>;
+export declare const calcVolumePercent: (analyser: AnalyserNode | null, dataArray: Uint8Array | null) => number;
+export declare const clampInterval: (interval: any) => any;