@phonghq/go-chat 1.0.72 → 1.0.74

package/dist/composable/useListentEvent.d.ts

@@ -0,0 +1,5 @@
+import type { PAGE_RESPONSIVE } from '../types/chat/global';
+export declare const responsiveObserver: import("vue").Ref<PAGE_RESPONSIVE, PAGE_RESPONSIVE>;
+export declare function useListenEvent(callBackResizeChange?: (data?: any) => void): {
+    getResponsiveObserver: (is_init?: boolean) => void;
+};

package/dist/composable/useListentEvent.js

@@ -0,0 +1,69 @@
+import { onMounted, onUnmounted, ref } from 'vue';
+import { currentPage } from '../utils/chat/chat-router';
+import { PAGE } from '../constant/general';
+import { useDebounce } from '../utils/debounce';
+// import router from '../router'
+//PINIA
+export const responsiveObserver = ref('tablet');
+export function useListenEvent(callBackResizeChange) {
+    onMounted(() => {
+        addResponsiveObserver();
+        // window.addEventListener('resize', getResponsiveObserverDebounce)
+    });
+    onUnmounted(() => {
+        removeResponsiveObserver();
+        // window.removeEventListener('resize', getResponsiveObserverDebounce)
+    });
+    let observer;
+    const getResponsiveObserver = (is_init) => {
+        const appChatRef = document.getElementById('appChatMain');
+        if (!appChatRef)
+            return;
+        const width = appChatRef?.offsetWidth ?? 0;
+        // const width = entry.contentRect.width ?? 0
+        if (width >= 1281) {
+            if (responsiveObserver.value != 'window') {
+                if (!is_init)
+                    callBackResizeChange?.();
+                responsiveObserver.value = 'window';
+            }
+        }
+        else if (width >= 640) {
+            if (responsiveObserver.value != 'tablet') {
+                if (!is_init)
+                    callBackResizeChange?.();
+                responsiveObserver.value = 'tablet';
+            }
+        }
+        else {
+            if (responsiveObserver.value != 'mobile') {
+                if (!is_init)
+                    callBackResizeChange?.();
+                if (currentPage.value == PAGE.HOME) {
+                    currentPage.value = PAGE.CHAT_LIST;
+                }
+                responsiveObserver.value = 'mobile';
+            }
+        }
+    };
+    const addResponsiveObserver = () => {
+        const appChatRef = document.getElementById('appChatMain');
+        if (!appChatRef)
+            return;
+        observer = new ResizeObserver(([entry]) => {
+            getResponsiveObserverDebounce();
+        });
+        if (appChatRef) {
+            observer.observe(appChatRef);
+        }
+    };
+    const removeResponsiveObserver = () => {
+        observer?.disconnect();
+    };
+    const getResponsiveObserverDebounce = useDebounce(() => {
+        getResponsiveObserver();
+    }, 50);
+    return {
+        getResponsiveObserver
+    };
+}

package/dist/composable/usePlivo.d.ts

@@ -0,0 +1,15 @@
+import { type PlivoCallStatusType } from '../types/chat/call';
+export declare function usePlivo(callback: (status: PlivoCallStatusType, data?: any) => void): {
+    plivoLogin: (data: {
+        token: string;
+        isRefresh?: boolean;
+    }) => Promise<void>;
+    plivoCallAnswer: () => Promise<void>;
+    plivoCallReject: () => void;
+    plivoCall: (phone: string) => Promise<void>;
+    plivoEndCall: (status: PlivoCallStatusType) => void;
+    plivoCallSwishMute: (isMute: boolean) => void;
+    plivoCallSwishSpeaker: (id: any) => void;
+    plivoRemoveCallBack: () => void;
+    checkTimeLimit: () => Promise<number>;
+};

package/dist/composable/usePlivo.js

@@ -0,0 +1,201 @@
+import { PLIVO_CALL_STATUS } from '../types/chat/call';
+import { createSipAccount } from '../utils/chat/store/call';
+import { dataProfile } from '../utils/chat/store/auth';
+import { getPhoneTimeLimit } from '../utils/chat/store/time-limit';
+import { onBeforeUnmount } from 'vue';
+export function usePlivo(callback) {
+    var options = {
+        debug: 'ALL',
+        deviceParams: {
+            micEnabled: true,
+            audioConstraints: { audio: true, video: false }
+        }
+    };
+    var plivoBrowserSdk = null;
+    var plivoBrowserSdk2 = null;
+    let CallUuid = '';
+    let custom_resolve = null;
+    let custom_reject = null;
+    onBeforeUnmount(() => {
+        plivoRemoveCallBack();
+    });
+    const plivoLogin = async (data) => {
+        try {
+            if (!plivoBrowserSdk) {
+                plivoBrowserSdk = new window.Plivo(options);
+                plivoBrowserSdk?.client?.on?.('onCallAnswered', handleCallAnswered);
+                plivoBrowserSdk?.client?.on?.('onCallTerminated', handleCallTerminated);
+                plivoBrowserSdk.client?.on?.('onCallFailed', handleCallFailed);
+                plivoBrowserSdk.client?.on?.('onIncomingCallCanceled', handleIncomingCallCanceled);
+                // plivoBrowserSdk.client.on('onCalling', (data: any) => console.log('onCallFailed', data))
+                plivoBrowserSdk?.client?.on?.('onIncomingCall', handleIncomingCall);
+                plivoBrowserSdk.client?.on?.('onCallRemoteRinging', handleCallRemoteRinging);
+                plivoBrowserSdk.client?.on?.('onMediaPermission', handleMediaPermission);
+                plivoBrowserSdk?.client?.on?.('onLoginFailed', handleLoginFailed);
+            }
+            if (!data.isRefresh) {
+                const payload = JSON.parse(atob(data.token.split('.')[1]));
+                await createSipAccount({
+                    sip_username: `${payload.sub}_${payload.iss}`,
+                    did_number: dataProfile.value?.phone ?? ''
+                });
+            }
+            // await plivoBrowserSdk?.client?.tokenLogin(payload.sub ?? '', token)
+            // await plivoBrowserSdk?.client?.login('webcall003079673454891827', '123456abcA!')
+            // await plivoBrowserSdk?.client?.login(payload.sub , null, token)
+            await plivoBrowserSdk?.client?.loginWithAccessToken(data.token);
+            plivoBrowserSdk?.client?.setRingTone(false);
+            // await plivoBrowserSdk?.client?.on?.(payload)
+            // console.log('Registered with token')
+            console.log(plivoBrowserSdk);
+        }
+        catch (err) {
+            console.log('Login error: ' + err);
+        }
+    };
+    const handleLoginFailed = (e) => {
+        console.log('Login failed', e);
+    };
+    const handleIncomingCall = async (callerID, extraHeaders, call) => {
+        try {
+            const data = {
+                phone: _getPhone(call.src)
+            };
+            callback(PLIVO_CALL_STATUS.CHECK_USER_OFFER, data);
+            const limit_time = await checkTimeLimit();
+            plivoBrowserSdk?.client?.setRingTone(true);
+            callback(PLIVO_CALL_STATUS.RINGING, { ...data, limit_time });
+            CallUuid = call?.callUUID;
+        }
+        catch (error) {
+            callback(PLIVO_CALL_STATUS.CALL_END);
+        }
+    };
+    const handleCallRemoteRinging = (callInfo) => {
+        CallUuid = callInfo.callUUID;
+        callback(PLIVO_CALL_STATUS.CALLING);
+        custom_resolve?.();
+    };
+    const handleCallAnswered = (call) => {
+        if (call.callUUID == CallUuid) {
+            custom_resolve?.();
+            callback(PLIVO_CALL_STATUS.CALL_START);
+        }
+    };
+    const handleCallTerminated = (data, callInfo) => {
+        if (CallUuid === callInfo.callUUID) {
+            callback(PLIVO_CALL_STATUS.CALL_END, { message: data?.reason });
+            CallUuid = '';
+        }
+    };
+    const _getPhone = (text, dial = '1') => {
+        let result = text.replace(/[^0-9]/g, '');
+        return result?.startsWith(dial) ? result.slice(dial.toString().length) : result;
+    };
+    const _waitEventOrTimeout = (timeoutMs = 3000) => {
+        return new Promise((resolve, reject) => {
+            custom_resolve = null;
+            const timer = setTimeout(() => {
+                reject('Time out error!');
+                custom_resolve = null;
+                custom_reject = null;
+            }, timeoutMs);
+            custom_resolve = () => {
+                resolve(true);
+                custom_resolve = null;
+                clearTimeout(timer);
+            };
+            custom_reject = (data) => {
+                reject(data);
+                custom_reject = null;
+                clearTimeout(timer);
+            };
+        });
+    };
+    const plivoCallAnswer = async () => {
+        plivoBrowserSdk?.client?.answer?.(CallUuid);
+        await _waitEventOrTimeout(3000);
+    };
+    const plivoCallReject = () => {
+        plivoBrowserSdk?.client?.reject?.(CallUuid);
+    };
+    const plivoCallIgnore = () => {
+        if (CallUuid)
+            plivoBrowserSdk?.client?.ignore?.(CallUuid);
+    };
+    const plivoCallSwishMute = (isMute) => {
+        plivoBrowserSdk?.client?.mute();
+        if (isMute)
+            plivoBrowserSdk?.client?.mute?.();
+        else
+            plivoBrowserSdk?.client?.unmute?.();
+    };
+    const plivoCall = async (phone) => {
+        plivoBrowserSdk?.client?.call('+' + phone, { number_phone: phone });
+        await _waitEventOrTimeout(5000);
+    };
+    const plivoEndCall = (status) => {
+        if (status == PLIVO_CALL_STATUS.RINGING) {
+            plivoBrowserSdk?.client?.reject?.(CallUuid);
+        }
+        else if (status == PLIVO_CALL_STATUS.CALL_START || status == PLIVO_CALL_STATUS.CALLING) {
+            plivoBrowserSdk?.client?.hangup?.();
+        }
+        plivoBrowserSdk?.client?.setRingTone(false);
+    };
+    const handleCallFailed = (data, callInfo) => {
+        console.log('handleCallFailed', data);
+        if (custom_reject)
+            custom_reject?.(data);
+        callback(PLIVO_CALL_STATUS.CALL_END, { message: data });
+        if (data == 'User Denied Media Access') {
+            alert('Microphone access is blocked. Please enable the microphone permission to make a call.');
+        }
+    };
+    const handleIncomingCallCanceled = (callInfo) => {
+        callback(PLIVO_CALL_STATUS.CALL_END, { reason: callInfo.reason ?? '' });
+    };
+    const handleMediaPermission = (e) => {
+        console.log('MediaPermission', e);
+        if (e?.status == 'failure') {
+            callback(PLIVO_CALL_STATUS.MEDIA_PERMISSION_FAIL);
+        }
+    };
+    const plivoCallSwishSpeaker = (id) => {
+        alert(id);
+        plivoBrowserSdk?.client?.audio?.set?.(id);
+    };
+    const checkTimeLimit = async () => {
+        // await sleep()
+        const res = await getPhoneTimeLimit({
+            tenant_id: dataProfile.value?.tenant_id ?? '',
+            phone: dataProfile.value?.phone ?? ''
+        });
+        return res;
+    };
+    const plivoRemoveCallBack = () => {
+        plivoBrowserSdk?.client?.off?.('onCallAnswered', handleCallAnswered);
+        plivoBrowserSdk?.client?.off?.('onCallTerminated', handleCallTerminated);
+        plivoBrowserSdk?.client?.off?.('onCallFailed', handleCallFailed);
+        plivoBrowserSdk?.client?.off?.('onIncomingCallCanceled', handleIncomingCallCanceled);
+        plivoBrowserSdk?.client?.off?.('onIncomingCall', handleIncomingCall);
+        plivoBrowserSdk?.client?.off?.('onCallRemoteRinging', handleCallRemoteRinging);
+        plivoBrowserSdk?.client?.off?.('onMediaPermission', handleMediaPermission);
+        plivoBrowserSdk?.client?.off?.('onLoginFailed', handleLoginFailed);
+        plivoBrowserSdk = null;
+    };
+    const sleep = () => {
+        return new Promise((resolve) => setTimeout(resolve, 2000));
+    };
+    return {
+        plivoLogin,
+        plivoCallAnswer,
+        plivoCallReject,
+        plivoCall,
+        plivoEndCall,
+        plivoCallSwishMute,
+        plivoCallSwishSpeaker,
+        plivoRemoveCallBack,
+        checkTimeLimit,
+    };
+}

package/dist/constant/color.d.ts

@@ -0,0 +1,22 @@
+export declare const enum Status_Color {
+    Orange = "#F2994A",
+    Blue_Teal = "#F2994A"
+}
+declare const enum Color {
+    Primary = "#0051E6",
+    Primary_Hover = "#699FF5",
+    Primary_RGB = "41, 121, 255",
+    Error = "#ef4444",
+    Error_Hover = "#FF8A75",
+    Success = "#4ade80",
+    Success_Hover = "#5FD9A0",
+    Success_Bg = "#E9FFE4",
+    Warning = "#f3a22c",
+    Text = "#333333",
+    Link = "#1890ff",
+    Default_Appointment = "#rgb(244, 185, 124)",
+    Done_Appointment = "#00d652",
+    Cancel_Appointment = "#ff0000"
+}
+export default Color;
+export declare function defineRootColor(): void;

package/dist/constant/color.js

@@ -0,0 +1,47 @@
+export var Status_Color;
+(function (Status_Color) {
+    Status_Color["Orange"] = "#F2994A";
+    Status_Color["Blue_Teal"] = "#F2994A";
+})(Status_Color || (Status_Color = {}));
+var Color;
+(function (Color) {
+    Color["Primary"] = "#0051E6";
+    Color["Primary_Hover"] = "#699FF5";
+    Color["Primary_RGB"] = "41, 121, 255";
+    // Error = '#ff3b3b',
+    // Error = '#EF4444',
+    Color["Error"] = "#ef4444";
+    Color["Error_Hover"] = "#FF8A75";
+    // Success = '#1DA91D',
+    // Success = '#22C55E',
+    Color["Success"] = "#4ade80";
+    Color["Success_Hover"] = "#5FD9A0";
+    Color["Success_Bg"] = "#E9FFE4";
+    Color["Warning"] = "#f3a22c";
+    Color["Text"] = "#333333";
+    Color["Link"] = "#1890ff";
+    Color["Default_Appointment"] = "#rgb(244, 185, 124)";
+    Color["Done_Appointment"] = "#00d652";
+    Color["Cancel_Appointment"] = "#ff0000";
+})(Color || (Color = {}));
+export default Color;
+export function defineRootColor() {
+    const root = document.querySelector(':root');
+    if (root) {
+        root.style?.setProperty('--chat-color-primary', Color.Primary);
+        // root.style?.setProperty('--chat-color-primary_hover', Color.Primary_Hover)
+        // root.style?.setProperty('--chat-color-primary_rgb', Color.Primary_RGB)
+        root.style?.setProperty('--chat-color-error', Color.Error);
+        // root.style?.setProperty('--chat-color-error_hover', Color.Error_Hover)
+        root.style?.setProperty('--chat-color-success', Color.Success);
+        // root.style?.setProperty('--chat-color-success-bg', Color.Success_Bg)
+        // root.style?.setProperty('--chat-color-success_hover', Color.Success_Hover)
+        // root.style?.setProperty('--chat-color-second-success', Color.Success)
+        // root.style?.setProperty('--chat-color-warning', Color.Warning)
+        // root.style?.setProperty('--chat-color-text', Color.Text)
+        // root.style?.setProperty('--chat-color-link', Color.Link)
+        // root.style?.setProperty('--chat-color-default_appointment', Color.Default_Appointment)
+        // root.style?.setProperty('--chat-color-done_appointment', Color.Done_Appointment)
+        // root.style?.setProperty('--chat-color-cancel_appointment', Color.Cancel_Appointment)
+    }
+}

package/dist/constant/datetime.d.ts

@@ -0,0 +1,7 @@
+export declare const DATE_FORMATS: {
+    readonly DATE_FORMAT: "YYYY-MM-DD";
+    readonly DATE_FORMAT_FULL: "YYYY-MM-DD HH:mm:ss";
+    readonly DATE_FORMAT_MEDIUM: "MMM D, YYYY";
+    readonly TIME_12_FORMAT: "hh:mm A";
+};
+export declare const TIME_ZONE_UTC = "Africa/Freetown";

package/dist/constant/datetime.js

@@ -0,0 +1,7 @@
+export const DATE_FORMATS = {
+    DATE_FORMAT: 'YYYY-MM-DD',
+    DATE_FORMAT_FULL: 'YYYY-MM-DD HH:mm:ss',
+    DATE_FORMAT_MEDIUM: 'MMM D, YYYY',
+    TIME_12_FORMAT: 'hh:mm A',
+};
+export const TIME_ZONE_UTC = 'Africa/Freetown';

package/dist/constant/general.d.ts

@@ -0,0 +1,11 @@
+export declare enum PAGE {
+    HOME = "home",
+    CUSTOMER_DETAIL = "customer_detail",
+    CUSTOMER_CHECK_IN = "customer_check_in",
+    CUSTOMER_APPOINTMENT = "customer_appointment",
+    TENANT_ERROR = "tenant_error",
+    CHAT_LIST = "chat_list",
+    REGISTER_TENANT = "register_tenant",
+    REGISTER_SUCCESS = "register_success",
+    NOT_TENANT_PHONE = "not_tenant_phone"
+}

package/dist/constant/general.js

@@ -0,0 +1,12 @@
+export var PAGE;
+(function (PAGE) {
+    PAGE["HOME"] = "home";
+    PAGE["CUSTOMER_DETAIL"] = "customer_detail";
+    PAGE["CUSTOMER_CHECK_IN"] = "customer_check_in";
+    PAGE["CUSTOMER_APPOINTMENT"] = "customer_appointment";
+    PAGE["TENANT_ERROR"] = "tenant_error";
+    PAGE["CHAT_LIST"] = "chat_list";
+    PAGE["REGISTER_TENANT"] = "register_tenant";
+    PAGE["REGISTER_SUCCESS"] = "register_success";
+    PAGE["NOT_TENANT_PHONE"] = "not_tenant_phone";
+})(PAGE || (PAGE = {}));

package/dist/constant/message.d.ts

@@ -0,0 +1,8 @@
+export declare const MessageState: {
+    readonly Sending: "sending";
+    readonly Sent: "sent";
+    readonly Read: "read";
+    readonly Failed: "failed";
+    readonly Uploading: "uploading";
+    readonly Uploaded: "uploaded";
+};

package/dist/constant/message.js

@@ -0,0 +1,8 @@
+export const MessageState = {
+    Sending: "sending",
+    Sent: "sent",
+    Read: "read",
+    Failed: "failed",
+    Uploading: "uploading",
+    Uploaded: "uploaded"
+};

package/dist/constant/mqtt.d.ts

@@ -0,0 +1,7 @@
+export declare const TOPIC_DETAIL_CHAT = "chat/message/";
+export declare const TOPIC_DETAIL_CALL = "call/message/";
+export declare const TOPIC_PLIVO_CALL = "message-call/";
+export declare const TOPIC_PLIVO_SMS = "sms-inbound/";
+export declare const TOPIC_STATUS_USER: string;
+export declare const TOPIC_CUSTOMER_RELOAD: string;
+export declare const TOPIC_HOME: string[];

package/dist/constant/mqtt.js

@@ -0,0 +1,18 @@
+export const TOPIC_DETAIL_CHAT = 'chat/message/';
+export const TOPIC_DETAIL_CALL = 'call/message/';
+export const TOPIC_PLIVO_CALL = 'message-call/';
+export const TOPIC_PLIVO_SMS = 'sms-inbound/';
+export const TOPIC_STATUS_USER = 'user/status/';
+export const TOPIC_CUSTOMER_RELOAD = 'chat/customer/reload/+';
+export const TOPIC_HOME = [
+    // 'chat/conversation/update/',
+    // 'chat/conversation/read_message/',
+    // 'chat/conversation/update_list/',
+    'chat/conversation/update/message-call/',
+    'chat/conversation/update/sms-inbound/',
+    'chat/conversation/read_message/',
+    'chat/conversation/reload/sms-inbound/',
+];
+// export CALL_STATE = {
+//   Offer: 'offer',
+// }

package/dist/constant/user.d.ts

@@ -0,0 +1,8 @@
+export declare const enum CalendarStatus {
+    Confirmed = "confirmed",
+    Scheduled = "scheduled",
+    Canceled = "canceled",
+    Done = "done",
+    Reminder = "reminder",
+    Waiting = "wait_list"
+}

package/dist/constant/user.js

@@ -0,0 +1,9 @@
+export var CalendarStatus;
+(function (CalendarStatus) {
+    CalendarStatus["Confirmed"] = "confirmed";
+    CalendarStatus["Scheduled"] = "scheduled";
+    CalendarStatus["Canceled"] = "canceled";
+    CalendarStatus["Done"] = "done";
+    CalendarStatus["Reminder"] = "reminder";
+    CalendarStatus["Waiting"] = "wait_list";
+})(CalendarStatus || (CalendarStatus = {}));