@convirza/dialer-sdk 1.0.0

package/dist/init.d.ts

@@ -0,0 +1,4 @@
+import type { DialerInitConfig } from './api/DialerAPI.js';
+export declare function initDialer(config: DialerInitConfig): void;
+export declare function destroyDialer(): void;
+export declare function isDialerInitialized(): boolean;

package/dist/media/AudioDeviceManager.d.ts

@@ -0,0 +1,34 @@
+export interface AudioDevice {
+    deviceId: string;
+    label: string;
+    kind: 'audioinput' | 'audiooutput';
+}
+export interface DevicePreferences {
+    microphoneId: string | null;
+    speakerId: string | null;
+}
+export interface AudioDeviceManagerOptions {
+    onDevicesChanged?: (devices: AudioDevice[]) => void;
+    onMicrophoneChanged?: (deviceId: string) => void;
+    onSpeakerChanged?: (deviceId: string) => void;
+}
+export declare class AudioDeviceManager {
+    private static readonly STORAGE_KEY;
+    private devices;
+    private onDevicesChangedCb;
+    private onMicrophoneChangedCb;
+    private onSpeakerChangedCb;
+    private deviceChangeHandler;
+    constructor(options?: AudioDeviceManagerOptions);
+    destroy(): void;
+    private handleDeviceChange;
+    enumerateDevices(): Promise<AudioDevice[]>;
+    refreshDevices(): Promise<AudioDevice[]>;
+    getMicrophones(): AudioDevice[];
+    getSpeakers(): AudioDevice[];
+    setOnDevicesChanged(callback: (devices: AudioDevice[]) => void): void;
+    savePreferences(prefs: DevicePreferences): void;
+    loadPreferences(): DevicePreferences;
+    applyAudioOutputDevice(audioElement: HTMLAudioElement, deviceId: string): Promise<void>;
+    getAudioConstraints(microphoneId: string | null): Promise<MediaStreamConstraints>;
+}

package/dist/media/CallQualityMonitor.d.ts

@@ -0,0 +1,41 @@
+export interface CallQualityMetrics {
+    bitrate: number;
+    packetLoss: number;
+    jitter: number;
+    latency: number;
+    audioLevel: number;
+    quality: 'excellent' | 'good' | 'fair' | 'poor';
+}
+export interface CallQualityThresholds {
+    excellent: {
+        packetLoss: number;
+        jitter: number;
+        latency: number;
+    };
+    good: {
+        packetLoss: number;
+        jitter: number;
+        latency: number;
+    };
+    fair: {
+        packetLoss: number;
+        jitter: number;
+        latency: number;
+    };
+}
+export declare class CallQualityMonitor {
+    private peerConnection;
+    private intervalId;
+    private onQualityChange;
+    private lastMetrics;
+    private thresholds;
+    private previousBytesReceived;
+    private previousTimestamp;
+    constructor(thresholds?: CallQualityThresholds);
+    start(peerConnection: RTCPeerConnection, interval?: number): void;
+    stop(): void;
+    setOnQualityChange(callback: (metrics: CallQualityMetrics) => void): void;
+    getLastMetrics(): CallQualityMetrics | null;
+    private collectMetrics;
+    private calculateQuality;
+}

package/dist/services/CallHistoryService.d.ts

@@ -0,0 +1,41 @@
+import { CallRecord, CallDirection, CallDisposition } from '../types/call-history.js';
+/**
+ * Service layer orchestrating IndexedDB cache and backend API
+ * Handles sync, fallback, and persistence strategy
+ */
+export declare class CallHistoryService {
+    private store;
+    private api;
+    private userId;
+    private sipDomain;
+    private initialized;
+    constructor();
+    init(userId: string, sipDomain: string, apiUrl?: string, authToken?: string): Promise<void>;
+    setAuthToken(token: string): void;
+    private ensureInitialized;
+    addCall(params: {
+        callId: string;
+        phoneNumber: string;
+        callerIdNumber: string;
+        callerIdName?: string;
+        direction: CallDirection;
+        disposition: CallDisposition;
+        startedAt: number;
+        endedAt?: number;
+        durationSeconds: number;
+        recordingUrl?: string;
+    }): Promise<void>;
+    getHistory(limit?: number): Promise<CallRecord[]>;
+    sync(): Promise<void>;
+    updateCall(callId: string, updates: {
+        endedAt?: number;
+        durationSeconds?: number;
+    }): Promise<void>;
+    clear(): Promise<void>;
+    /**
+     * Force clear IndexedDB cache and re-sync from backend
+     * Useful for debugging stale data issues
+     */
+    clearCache(): Promise<void>;
+    destroy(): void;
+}

package/dist/sip/SipAdapter.d.ts

@@ -0,0 +1,99 @@
+import { AudioDevice } from '../media/AudioDeviceManager.js';
+import { CallQualityMetrics } from '../media/CallQualityMonitor.js';
+export interface SipConfig {
+    sipUsername: string;
+    sipPassword: string;
+    sipDomain: string;
+    wsServers: string[];
+    displayName?: string;
+    iceServers?: RTCIceServer[];
+    microphoneId?: string;
+    speakerId?: string;
+    apiUrl?: string;
+    authToken?: string;
+}
+export interface SipCallbacks {
+    onRegistered?: () => void;
+    onUnregistered?: () => void;
+    onRegistrationFailed?: (cause?: string) => void;
+    onTransportError?: (error: Error) => void;
+    onConnecting?: () => void;
+    onCallRinging?: () => void;
+    onCallAnswered?: () => void;
+    onCallEnded?: (reason?: string) => void;
+    onCallFailed?: (error: Error) => void;
+    onIncomingCall?: (phoneNumber: string, callerName?: string) => void;
+    onRemoteHold?: (isOnHold: boolean) => void;
+    onQualityChange?: (metrics: CallQualityMetrics) => void;
+    onRecordingStateChange?: (recording: boolean) => void;
+    onTransferSucceeded?: () => void;
+    onTransferFailed?: (reason: string) => void;
+    onDevicesChanged?: (devices: AudioDevice[]) => void;
+    onError?: (error: Error) => void;
+}
+export declare class SipAdapter {
+    private userAgent;
+    private currentSession;
+    private registerer;
+    private config;
+    private callbacks;
+    private audioElement;
+    private isMuted;
+    private audioDeviceManager;
+    private qualityMonitor;
+    private localHangup;
+    private currentCallUuid;
+    private currentCallIsChannelUuid;
+    private currentCallSipCallId;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private iceDisconnectedTimer;
+    constructor(config: SipConfig, callbacks?: SipCallbacks);
+    private setupQualityMonitor;
+    private getLocalAudioConstraints;
+    private setupAudioElement;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    call(phoneNumber: string, options?: {
+        callerId?: string;
+        callerIdName?: string;
+    }): Promise<void>;
+    endCall(): Promise<void>;
+    mute(enable?: boolean): boolean;
+    hold(enable?: boolean): Promise<void>;
+    sendDTMF(digit: string): void;
+    startRecording(): void;
+    stopRecording(): void;
+    park(parkExtension: string): Promise<void>;
+    private handleIncomingCall;
+    answerCall(): Promise<void>;
+    rejectCall(): Promise<void>;
+    private setupRemoteMedia;
+    private stopLocalTracks;
+    private cleanupSession;
+    private startQualityMonitoring;
+    get isConnected(): boolean;
+    get hasActiveCall(): boolean;
+    setMicrophone(deviceId: string): Promise<void>;
+    setSpeaker(deviceId: string): Promise<void>;
+    getAudioDevices(): Promise<{
+        microphones: Array<{
+            deviceId: string;
+            label: string;
+        }>;
+        speakers: Array<{
+            deviceId: string;
+            label: string;
+        }>;
+    }>;
+    getCallUuid(): string | null;
+    getCurrentDevices(): {
+        microphoneId: string | null;
+        speakerId: string | null;
+    };
+    getCallQuality(): CallQualityMetrics | null;
+    blindTransfer(target: string): Promise<void>;
+    private monitorPeerConnection;
+    private scheduleReconnect;
+    reconnect(): void;
+}

package/dist/storage/CallHistoryStore.d.ts

@@ -0,0 +1,16 @@
+import { CallRecord } from '../types/call-history.js';
+/**
+ * IndexedDB wrapper for call history
+ * Provides local cache with structured queries
+ */
+export declare class CallHistoryStore {
+    private db;
+    init(): Promise<void>;
+    add(call: Omit<CallRecord, 'id'>): Promise<number>;
+    getAll(userId: string, sipDomain: string, limit?: number): Promise<CallRecord[]>;
+    getByCallId(callId: string): Promise<CallRecord | null>;
+    update(id: number, updates: Partial<CallRecord>): Promise<void>;
+    replaceAll(userId: string, sipDomain: string, calls: CallRecord[]): Promise<void>;
+    clear(): Promise<void>;
+    close(): void;
+}

package/dist/types/call-history.d.ts

@@ -0,0 +1,29 @@
+export type CallDirection = 'inbound' | 'outbound';
+export type CallDisposition = 'answered' | 'missed' | 'rejected' | 'failed';
+export interface CallRecord {
+    id?: number;
+    callId: string;
+    userId: string;
+    sipDomain: string;
+    callerIdNumber: string;
+    callerIdName?: string;
+    phoneNumber: string;
+    direction: CallDirection;
+    disposition: CallDisposition;
+    startedAt: number;
+    endedAt?: number;
+    durationSeconds: number;
+    recordingUrl?: string;
+    createdAt: number;
+}
+export interface CallHistoryResponse {
+    calls: CallRecord[];
+    total: number;
+    hasMore: boolean;
+}
+export interface CallHistoryQueryParams {
+    userId: string;
+    sipDomain: string;
+    limit?: number;
+    offset?: number;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,55 @@
+export type WidgetPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export type CallStatus = 'idle' | 'dialing' | 'ringing' | 'connected' | 'ended' | 'error';
+export type WidgetState = 'collapsed' | 'expanded';
+export type ThemeMode = 'light' | 'dark';
+export interface DialerConfig {
+    apiUrl: string;
+    sipDomain: string;
+    sipUsername: string;
+    sipPassword: string;
+    wsServers: string[];
+    authToken?: string;
+    iceServers?: RTCIceServer[];
+    position?: WidgetPosition;
+    zIndex?: number;
+    defaultState?: WidgetState;
+    primaryColor?: string;
+    accentColor?: string;
+    theme?: ThemeMode;
+    brandName?: string;
+    brandLogo?: string;
+    apiBaseUrl?: string;
+    domainId?: number;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+}
+export interface CallOptions {
+    displayName?: string;
+    callerId?: string;
+}
+export interface CallSession {
+    phoneNumber: string;
+    status: CallStatus;
+    duration: number;
+    onAnswered: (callback: () => void) => void;
+    onEnded: (callback: (duration: number) => void) => void;
+    end: () => void;
+}
+export interface CallMetadata {
+    phoneNumber: string;
+    startTime: number;
+    endTime?: number;
+    duration: number;
+    status: CallStatus;
+    errorMessage?: string;
+}
+export interface DialerEvents {
+    onOpen?: () => void;
+    onClose?: () => void;
+    onCallStarted?: (phoneNumber: string) => void;
+    onCallEnded?: (phoneNumber: string, duration: number) => void;
+    onStateChange?: (oldState: CallStatus, newState: CallStatus, metadata?: CallMetadata) => void;
+}
+export type { CallRecord, CallDirection, CallDisposition, CallHistoryResponse, CallHistoryQueryParams, } from './call-history.js';
+export type { PhoneNumberCapabilities, OrderedPhoneNumber, OrderedPhoneNumbersResponse } from './phone-numbers.js';

package/dist/types/phone-numbers.d.ts

@@ -0,0 +1,22 @@
+export interface PhoneNumberCapabilities {
+    voice?: boolean;
+    sms?: boolean;
+    mms?: boolean;
+    cnam?: boolean;
+}
+export interface OrderedPhoneNumber {
+    number_id: number;
+    number: string;
+    number_str: string;
+    number_type: string;
+    city?: string;
+    state?: string;
+    number_status: string;
+    assigned_user_name?: string;
+    capabilities?: PhoneNumberCapabilities;
+    created_at?: string;
+}
+export interface OrderedPhoneNumbersResponse {
+    items: OrderedPhoneNumber[];
+    total: number;
+}

package/dist/ui/ConvirzaDialerElement.d.ts

@@ -0,0 +1,250 @@
+import { CallOptions, CallSession } from '../types/index.js';
+export declare class ConvirzaDialerElement extends HTMLElement {
+    private shadow;
+    private config;
+    private callStatus;
+    private currentCall;
+    private durationInterval;
+    private isMuted;
+    private isOnHold;
+    private isRecording;
+    private phoneInputValue;
+    private selectedCountry;
+    private showCountryDropdown;
+    private longPressTimer;
+    private longPressTriggered;
+    private boundHandlers;
+    private isInitialized;
+    private currentView;
+    private currentHistoryTab;
+    private callHistory;
+    private selectedHistoryItem;
+    private readonly STORAGE_KEY;
+    private sipAdapter;
+    private incomingCallNumber;
+    private incomingCallName;
+    private showInCallKeypad;
+    private dialedDigits;
+    private audioDevices;
+    private callQuality;
+    private isDragging;
+    private dragOffset;
+    private fabPosition;
+    private parkAccounts;
+    private parkApiUrl;
+    private parkPollInterval;
+    private parkPollTimer;
+    private authToken;
+    private showRetrieveModal;
+    private retrieveModalData;
+    private isParking;
+    private parkingSlot;
+    private parkValidationTimer;
+    private parkValidationAttempts;
+    private errorDismissTimer;
+    private dragStartTime;
+    private hasMoved;
+    private ringbackTone;
+    private callConnectedTime;
+    private dialTone;
+    private renderScheduled;
+    private sharedAudioContext;
+    private ringbackBlobUrl;
+    private dialToneBlobUrl;
+    private dialToneBuffer;
+    private callHistoryService;
+    private currentCallId;
+    private callHistorySaved;
+    private showTransferView;
+    private transferTarget;
+    private isTransferring;
+    private domainExtensions;
+    private _activeNotification;
+    private _onOnline;
+    private _onOffline;
+    private phoneNumbersAPI;
+    private orderedPhoneNumbers;
+    private selectedPhoneNumber;
+    private showPhoneNumberDropdown;
+    private loadingPhoneNumbers;
+    private phoneNumbersError;
+    static get observedAttributes(): string[];
+    constructor();
+    private setupAudioTones;
+    private bufferToWave;
+    connectedCallback(): Promise<void>;
+    private initializePosition;
+    disconnectedCallback(): void;
+    private cleanup;
+    attributeChangedCallback(_name: string, oldValue: string, newValue: string): void;
+    private updateConfig;
+    private isDialerEnabled;
+    private autoConfigureFromAccessToken;
+    private autoConfigureFromRefreshToken;
+    private initializeSip;
+    private initializeCallHistory;
+    private loadCallHistory;
+    private mapDirectionToType;
+    private mapDispositionToString;
+    private generateCallId;
+    private isValidTransition;
+    private transitionState;
+    private needsUIRebuild;
+    private getCallMetadata;
+    private persistCallState;
+    private restoreCallState;
+    placeCall(phoneNumber: string, options?: CallOptions): CallSession;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    setTheme(options: {
+        theme?: 'dark' | 'light';
+        primaryColor?: string;
+        accentColor?: string;
+        brandName?: string;
+        brandLogo?: string;
+    }): void;
+    /**
+     * Clear call history cache and reload from backend
+     */
+    clearCallHistoryCache(): Promise<void>;
+    mute(enable?: boolean): boolean;
+    hold(enable?: boolean): boolean;
+    startRecording(): void;
+    stopRecording(): void;
+    private toggleRecording;
+    private parkCall;
+    private validateParkSuccess;
+    private confirmRetrieveParkedCall;
+    private cancelRetrieve;
+    private confirmRetrieve;
+    private retrieveParkedCall;
+    private initiateCall;
+    private handleCallEnded;
+    private addToCallHistory;
+    private getFilteredHistory;
+    private switchView;
+    private updateMainView;
+    private updatePhoneInput;
+    private switchHistoryTab;
+    private updateHistoryView;
+    private startDurationTimer;
+    private handleIncomingCall;
+    answerIncomingCall(): void;
+    rejectIncomingCall(): void;
+    toggleInCallKeypad(): void;
+    notifyCallAnswered(): void;
+    notifyCallRinging(): void;
+    private playRingbackTone;
+    private stopRingbackTone;
+    private playDialTone;
+    private playDTMFTone;
+    endCall(): void;
+    sendDTMF(digit: string): void;
+    private formatPhoneNumber;
+    private formatPhoneNumberDisplay;
+    /**
+     * Format phone input as user types (without country code - that's in the dropdown)
+     * Progressively formats: (825) 252-5065
+     */
+    private formatPhoneInputDisplay;
+    private formatDuration;
+    private formatCallTime;
+    private render;
+    private needsFullRender;
+    private performRender;
+    private performSelectiveUpdate;
+    private updateExpandedContent;
+    private updateDialedDigitsDisplay;
+    private updateActiveCallUI;
+    private updateModalOverlays;
+    private updateButtonStates;
+    private toggleCountryDropdown;
+    private selectCountry;
+    private renderCollapsed;
+    private renderExpanded;
+    private renderCountryDropdown;
+    private renderCountryBackdrop;
+    private renderDialpad;
+    private escapeHtml;
+    private renderTransferPanel;
+    private renderActiveCall;
+    private renderHistory;
+    private renderDialerDisabled;
+    private renderEmptyHistory;
+    private renderHistoryItem;
+    private renderCallBackButton;
+    private renderBottomNav;
+    private renderFooter;
+    private renderIncomingCallModal;
+    private renderRetrieveModal;
+    private renderAccount;
+    private renderPark;
+    private renderEmptyPark;
+    private renderParkedCall;
+    private renderParkItem;
+    private formatParkedDuration;
+    private setupEventListeners;
+    private setupDragHandlers;
+    private attachDragHandlers;
+    private adjustPositionForPanel;
+    private refreshAudioDevicesQuietly;
+    private refreshAudioDevices;
+    private updateAccountDeviceSelectors;
+    private setMicrophone;
+    private setSpeaker;
+    /**
+     * Start polling park slots API (REST fallback - not used in SUBSCRIBE test)
+     */
+    private startParkSlotPolling;
+    /**
+     * Stop polling park slots API
+     */
+    private stopParkSlotPolling;
+    /**
+     * Update history item selection state without full re-render
+     */
+    private updateHistorySelection;
+    /**
+     * Fetch park slots from backend API
+     */
+    private fetchParkSlots;
+    private fetchDomainExtensions;
+    private fetchOrderedPhoneNumbers;
+    /**
+     * Toggle dropdown visibility (open/close)
+     */
+    /**
+     * Render dropdown content (items only, not wrapper)
+     */
+    private renderPhoneNumberDropdownItems;
+    /**
+     * Update dropdown DOM based on showPhoneNumberDropdown state
+     */
+    private updatePhoneNumberDropdownDOM;
+    private togglePhoneNumberDropdown;
+    /**
+     * Open the dropdown (show phone number list)
+     */
+    private openPhoneNumberDropdown;
+    /**
+     * Close the dropdown (hide phone number list)
+     */
+    private closePhoneNumberDropdown;
+    /**
+     * Select a phone number from the dropdown
+     */
+    private selectPhoneNumber;
+    /**
+     * Stop loading spinner and update UI
+     */
+    private stopPhoneNumbersLoading;
+    /**
+     * Start loading spinner
+     */
+    private startPhoneNumbersLoading;
+    private executeTransfer;
+    private requestNotificationPermission;
+    private showIncomingCallNotification;
+    private dismissIncomingCallNotification;
+}