@voicenter-team/events-sdk 0.0.1 → 0.0.3

package/interface.ts

@@ -0,0 +1,261 @@
+interface options {
+
+    /**
+     * the authentication payload sent when connecting to the Namespace
+     */
+    auth?: {
+        [key: string]: any;
+    } | ((cb: (data: object) => void) => void);
+    /**
+     * The maximum number of retries. Above the limit, the packet will be discarded.
+     *
+     * Using `Infinity` means the delivery guarantee is "at-least-once" (instead of "at-most-once" by default), but a
+     * smaller value like 10 should be sufficient in practice.
+     */
+    retries?: number;
+    /**
+     * The default timeout in milliseconds used when waiting for an acknowledgement.
+     */
+    ackTimeout?: number;
+
+    /**
+     * The host that we're connecting to. Set from the URI passed when connecting
+     */
+    host: string;
+    /**
+     * The hostname for our connection. Set from the URI passed when connecting
+     */
+    hostname: string;
+    /**
+     * If this is a secure connection. Set from the URI passed when connecting
+     */
+    secure: boolean;
+    /**
+     * The port for our connection. Set from the URI passed when connecting
+     */
+    port: string | number;
+    /**
+     * Any query parameters in our uri. Set from the URI passed when connecting
+     */
+    query: {
+        [key: string]: any;
+    };
+    /**
+     * `http.Agent` to use, defaults to `false` (NodeJS only)
+     *
+     * Note: the type should be "undefined | http.Agent | https.Agent | false", but this would break browser-only clients.
+     *
+     * @see https://nodejs.org/api/http.html#httprequestoptions-callback
+     */
+    agent: string | boolean;
+    /**
+     * Whether the client should try to upgrade the transport from
+     * long-polling to something better.
+     * @default true
+     */
+    upgrade: boolean;
+    /**
+     * Forces base 64 encoding for polling transport even when XHR2
+     * responseType is available and WebSocket even if the used standard
+     * supports binary.
+     */
+    forceBase64: boolean;
+    /**
+     * The param name to use as our timestamp key
+     * @default 't'
+     */
+    timestampParam: string;
+    /**
+     * Whether to add the timestamp with each transport request. Note: this
+     * is ignored if the browser is IE or Android, in which case requests
+     * are always stamped
+     * @default false
+     */
+    timestampRequests: boolean;
+    /**
+     * A list of transports to try (in order). Engine.io always attempts to
+     * connect directly with the first one, provided the feature detection test
+     * for it passes.
+     *
+     * @default ['polling','websocket', 'webtransport']
+     */
+    transports: string[];
+    /**
+     * If true and if the previous websocket connection to the server succeeded,
+     * the connection attempt will bypass the normal upgrade process and will
+     * initially try websocket. A connection attempt following a transport error
+     * will use the normal upgrade process. It is recommended you turn this on
+     * only when using SSL/TLS connections, or if you know that your network does
+     * not block websockets.
+     * @default false
+     */
+    rememberUpgrade: boolean;
+    /**
+     * Are we only interested in transports that support binary?
+     */
+    onlyBinaryUpgrades: boolean;
+    /**
+     * Timeout for xhr-polling requests in milliseconds (0) (only for polling transport)
+     */
+    requestTimeout: number;
+    /**
+     * Transport options for Node.js client (headers etc)
+     */
+    transportOptions: Object;
+    /**
+     * (SSL) Certificate, Private key and CA certificates to use for SSL.
+     * Can be used in Node.js client environment to manually specify
+     * certificate information.
+     */
+    pfx: string;
+    /**
+     * (SSL) Private key to use for SSL. Can be used in Node.js client
+     * environment to manually specify certificate information.
+     */
+    key: string;
+    /**
+     * (SSL) A string or passphrase for the private key or pfx. Can be
+     * used in Node.js client environment to manually specify certificate
+     * information.
+     */
+    passphrase: string;
+    /**
+     * (SSL) Public x509 certificate to use. Can be used in Node.js client
+     * environment to manually specify certificate information.
+     */
+    cert: string;
+    /**
+     * (SSL) An authority certificate or array of authority certificates to
+     * check the remote host against.. Can be used in Node.js client
+     * environment to manually specify certificate information.
+     */
+    ca: string | string[];
+    /**
+     * (SSL) A string describing the ciphers to use or exclude. Consult the
+     * [cipher format list]
+     * (http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT) for
+     * details on the format.. Can be used in Node.js client environment to
+     * manually specify certificate information.
+     */
+    ciphers: string;
+    /**
+     * (SSL) If true, the server certificate is verified against the list of
+     * supplied CAs. An 'error' event is emitted if verification fails.
+     * Verification happens at the connection level, before the HTTP request
+     * is sent. Can be used in Node.js client environment to manually specify
+     * certificate information.
+     */
+    rejectUnauthorized: boolean;
+    /**
+     * Headers that will be passed for each request to the server (via xhr-polling and via websockets).
+     * These values then can be used during handshake or for special proxies.
+     */
+    extraHeaders?: {
+        [header: string]: string;
+    };
+    /**
+     * Whether to include credentials (cookies, authorization headers, TLS
+     * client certificates, etc.) with cross-origin XHR polling requests
+     * @default false
+     */
+    withCredentials: boolean;
+    /**
+     * Whether to automatically close the connection whenever the beforeunload event is received.
+     * @default false
+     */
+    closeOnBeforeunload: boolean;
+    /**
+     * Whether to always use the native timeouts. This allows the client to
+     * reconnect when the native timeout functions are overridden, such as when
+     * mock clocks are installed.
+     * @default false
+     */
+    useNativeTimers: boolean;
+    /**
+     * weather we should unref the reconnect timer when it is
+     * create automatically
+     * @default false
+     */
+    autoUnref: boolean;
+    /**
+     * parameters of the WebSocket permessage-deflate extension (see ws module api docs). Set to false to disable.
+     * @default false
+     */
+    perMessageDeflate: {
+        threshold: number;
+    };
+    /**
+     * The path to get our client file from, in the case of the server
+     * serving it
+     * @default '/engine.io'
+     */
+    path: string;
+    /**
+     * Whether we should add a trailing slash to the request path.
+     * @default true
+     */
+    addTrailingSlash: boolean;
+    /**
+     * Either a single protocol string or an array of protocol strings. These strings are used to indicate sub-protocols,
+     * so that a single server can implement multiple WebSocket sub-protocols (for example, you might want one server to
+     * be able to handle different types of interactions depending on the specified protocol)
+     * @default []
+     */
+    protocols: string | string[];
+
+    /**
+     * Should we force a new Manager for this connection?
+     * @default false
+     */
+    forceNew: boolean;
+    /**
+     * Should we multiplex our connection (reuse existing Manager) ?
+     * @default true
+     */
+    multiplex: boolean;
+    /**
+     * The path to get our client file from, in the case of the server
+     * serving it
+     * @default '/socket.io'
+     */
+    path: string;
+    /**
+     * Should we allow reconnections?
+     * @default true
+     */
+    reconnection: boolean;
+    /**
+     * How many reconnection attempts should we try?
+     * @default Infinity
+     */
+    reconnectionAttempts: number;
+    /**
+     * The time delay in milliseconds between reconnection attempts
+     * @default 1000
+     */
+    reconnectionDelay: number;
+    /**
+     * The max time delay in milliseconds between reconnection attempts
+     * @default 5000
+     */
+    reconnectionDelayMax: number;
+    /**
+     * Used in the exponential backoff jitter when reconnecting
+     * @default 0.5
+     */
+    randomizationFactor: number;
+    /**
+     * The timeout in milliseconds for our connection attempt
+     * @default 20000
+     */
+    timeout: number;
+    /**
+     * Should we automatically connect?
+     * @default true
+     */
+    autoConnect: boolean;
+    /**
+     * the parser to use. Defaults to an instance of the Parser that ships with socket.io.
+     */
+    parser: any;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicenter-team/events-sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "",
   "main": "dist/voicenter-events-sdk.cjs.js",
   "jsdelivr": "dist/voicenter-events-sdk.umd.js",

package/src/classes/events-sdk/events-sdk.class.ts

@@ -57,6 +57,7 @@ class EventsSdkClass{
         [EventsEnum.ALL_USERS_STATUS]: [],
         [EventsEnum.QUEUE_EVENT]: [],
         [EventsEnum.EXTENSION_EVENT]: [],
+        [EventsEnum.DIALER_EVENT]: [],
         [EventsEnum.LOGIN_SUCCESS]: [],
         [EventsEnum.LOGIN_STATUS]: [],
         [EventsEnum.KEEP_ALIVE_RESPONSE]: [],

package/src/classes/socket-io/socket-io.class.ts

@@ -72,6 +72,7 @@ export class SocketIoClass{
                 .on(EventsEnum.LOGIN_SUCCESS, (data) => this.eventsSdkClass.emit(EventsEnum.LOGIN_SUCCESS, data))
                 .on(EventsEnum.QUEUE_EVENT, (data) => this.eventsSdkClass.emit(EventsEnum.QUEUE_EVENT, data))
                 .on(EventsEnum.EXTENSION_EVENT, (data) => this.eventsSdkClass.emit(EventsEnum.EXTENSION_EVENT, data))
+                .on(EventsEnum.DIALER_EVENT, (data) => this.eventsSdkClass.emit(EventsEnum.DIALER_EVENT, data))
                 .on(EventsEnum.LOGIN_STATUS, (data) => this.eventsSdkClass.emit(EventsEnum.LOGIN_STATUS, data))
                 .on(EventsEnum.ALL_EXTENSION_STATUS, (data) => this.eventsSdkClass.emit(EventsEnum.ALL_EXTENSION_STATUS, data))
                 .on(EventsEnum.ALL_DIALER_STATUS, (data) => this.eventsSdkClass.emit(EventsEnum.ALL_DIALER_STATUS, data))

package/src/enum/events.enum.ts

@@ -19,7 +19,8 @@ export enum EventsEnum {
     // In case of wrong username or password or token, you will receive a 401 (“Unauthorized”) or 500 (“Unexpected token”) http error.
     LOGIN_SUCCESS = 'loginSuccess',
     QUEUE_EVENT = 'QueueEvent',
-    ONLINE_STATUS_EVENT = 'onlineStatusEvent'
+    ONLINE_STATUS_EVENT = 'onlineStatusEvent',
+    DIALER_EVENT = 'DialerEvent',
 }
 
 /**
@@ -58,6 +59,7 @@ export enum DialerType {
 export enum EventNameEnum {
     EXTENSION = 'extension',
     QUEUE = 'queue',
+    DIALER = 'dialer',
 }
 
 export enum ExtensionHangupCauseEnum {

package/src/index.ts

@@ -1,3 +1,9 @@
 import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
+import { Environment } from '@/classes/events-sdk/events-sdk.types'
+import { EventsEnum } from '@/enum/events.enum'
 
+export {
+    Environment,
+    EventsEnum
+}
 export default EventsSdkClass

package/src/types/events.d.ts

@@ -81,6 +81,20 @@ export interface ExtensionEvent extends CommonEventProperties {
     cause?: ExtensionHangupCauseEnum
 }
 
+/**
+ * Data structure for dialer event.
+ */
+export interface DialerEvent extends CommonEventProperties {
+    data: Dialer
+    eventName: EventNameEnum.DIALER
+    //reason: ExtensionEventReasonEnum // TODO: do research for dialer 'reason' prop
+    telephonyServerTime?: number
+    callerID?: string
+    ivrUniqueId?: string
+    dialStatus?: string
+    //cause?: ExtensionHangupCauseEnum // TODO: do research for dialer 'cause' prop
+}
+
 /**
  * Data structure for keep alive response event.
  */
@@ -101,6 +115,7 @@ export interface EventDataMap {
     [EventsEnum.ALL_USERS_STATUS]: AllUsersStatusEvent
     [EventsEnum.QUEUE_EVENT]: QueueEvent
     [EventsEnum.EXTENSION_EVENT]: ExtensionEvent
+    [EventsEnum.DIALER_EVENT]: DialerEvent
     [EventsEnum.LOGIN_SUCCESS]: LoginSuccessEvent
     [EventsEnum.LOGIN_STATUS]: LoginStatusEvent
     [EventsEnum.KEEP_ALIVE_RESPONSE]: KeepAliveResponseEvent