@telia-ace/knowledge-widget-bot-provider 0.0.1-alpha.2 → 0.0.1-alpha.3

package/lib/client/chat.client.d.ts

@@ -0,0 +1,15 @@
+import { Message } from '../contract/model/conversation-api-model/message.model';
+import EntryInterface from '../interface/entry.interface';
+export default class ChatClient {
+    entryInterface: EntryInterface;
+    constructor();
+    static initialize(user: any, agent: any): void;
+    processMessageArrayAndStoreIt(messages: Message[]): void;
+    updateMessageArrayAndStoreIt(messages: Message[]): void;
+    printUserMessageAndStoreIt(action: string): void;
+    private postUserMessage;
+    private postAgentMessage;
+    private getTitleFromEntry;
+    private getTitleFromText;
+    private getTitleFromList;
+}

package/lib/client/chat.client.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var uuid_1 = require("uuid");
+var server_entry_type_enum_1 = require("../contract/enum/server-entry-type.enum");
+var chat_helper_1 = require("../helper/chat.helper");
+var store_helper_1 = require("../helper/store.helper");
+var entry_interface_1 = __importDefault(require("../interface/entry.interface"));
+var ChatClient = /** @class */ (function () {
+    function ChatClient() {
+        this.entryInterface = new entry_interface_1.default();
+    }
+    ChatClient.initialize = function (user, agent) {
+        chat_helper_1.ChatHelper.setUser(user);
+        chat_helper_1.ChatHelper.setAgent(agent);
+    };
+    ChatClient.prototype.processMessageArrayAndStoreIt = function (messages) {
+        var _this = this;
+        messages
+            .filter(function (o) { return o && o != null; })
+            .forEach(function (o) {
+            if (o.isUser)
+                _this.postUserMessage(o);
+            else
+                _this.postAgentMessage(o);
+        });
+        store_helper_1.StoreHelper.insertOrUpdateMessageArrayStore(messages);
+    };
+    ChatClient.prototype.updateMessageArrayAndStoreIt = function (messages) {
+        var conversationEntry = undefined;
+        messages.forEach(function (o) {
+            var message = store_helper_1.StoreHelper.getMessage(o.id);
+            message === null || message === void 0 ? void 0 : message.conversationEntry.update(o.message);
+            conversationEntry = message === null || message === void 0 ? void 0 : message.conversationEntry;
+        });
+        store_helper_1.StoreHelper.insertOrUpdateMessageArrayStore(messages, conversationEntry);
+    };
+    ChatClient.prototype.printUserMessageAndStoreIt = function (action) {
+        if (action == 'next' || action == 'help')
+            return;
+        var entry = store_helper_1.StoreHelper.getEntry(action);
+        var message = {
+            id: (0, uuid_1.v4)(),
+            message: !entry ? action : this.getTitleFromEntry(entry, action),
+            isUser: true,
+        };
+        this.postUserMessage(message);
+        store_helper_1.StoreHelper.insertOrUpdateMessageArrayStore([message]);
+    };
+    ChatClient.prototype.postUserMessage = function (message) {
+        chat_helper_1.ChatHelper.getUser().print(message.message);
+    };
+    ChatClient.prototype.postAgentMessage = function (message) {
+        message.conversationEntry = chat_helper_1.ChatHelper.getAgent().print(message.message);
+    };
+    ChatClient.prototype.getTitleFromEntry = function (entry, action) {
+        var entryType = server_entry_type_enum_1.ServerEntryTypeEnum[entry.type];
+        switch (entryType) {
+            case server_entry_type_enum_1.ServerEntryTypeEnum.List:
+                return this.getTitleFromList(entry, action);
+            case server_entry_type_enum_1.ServerEntryTypeEnum.Text:
+                return this.getTitleFromText(entry, action);
+            default:
+                return '';
+        }
+    };
+    ChatClient.prototype.getTitleFromText = function (entry, action) {
+        if (!!entry.content.items)
+            return this.getTitleFromList(entry, action);
+        else
+            return entry.content.html;
+    };
+    ChatClient.prototype.getTitleFromList = function (entry, action) {
+        return entry.content.items.find(function (o) { return o.actionKey == action; }).title;
+    };
+    return ChatClient;
+}());
+exports.default = ChatClient;

package/lib/client/contact-method.client.d.ts

@@ -0,0 +1,22 @@
+import { ContactMethodPlatform } from '@telia-ace/knowledge-widget-adapters';
+import { DataClient } from '@telia-ace/knowledge-widget-types-grid';
+export declare class ContactMethodClient {
+    private static dataClient;
+    private static contactMethodPlatform;
+    private static contactMessageEntryArray;
+    private static agent;
+    private chatClient;
+    static initialize(dataClient: DataClient, contactMethodPlatform: ContactMethodPlatform, agent: any): void;
+    handleNewForm: (errors: any, entry: any) => Promise<void>;
+    handleContactMethod: (input?: string) => Promise<void>;
+    validate(form: any): void;
+    private handleContactCategoryList;
+    private handleForm;
+    private handleContactMethodList;
+    private handleSingleContactMethod;
+    private submit;
+    private removeForm;
+    private printMessage;
+    private loadContactMethods;
+    private updateForm;
+}

package/lib/client/contact-method.client.js

@@ -0,0 +1,276 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContactMethodClient = void 0;
+var knowledge_widget_types_grid_1 = require("@telia-ace/knowledge-widget-types-grid");
+var widget_forms_1 = require("@telia-ace/widget-forms");
+var uuid_1 = require("uuid");
+var store_helper_1 = require("../helper/store.helper");
+var chat_client_1 = __importDefault(require("./chat.client"));
+var ContactMethodClient = /** @class */ (function () {
+    function ContactMethodClient() {
+        var _this = this;
+        this.chatClient = new chat_client_1.default();
+        this.handleNewForm = function (errors, entry) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.updateForm(entry.contactMethods, {
+                    submit: 'Submit',
+                    errors: errors,
+                });
+                entry.entry.update({
+                    contactMethods: entry.contactMethods,
+                    type: 'ace-knowledge-contact-method',
+                    noPadding: true,
+                });
+                return [2 /*return*/];
+            });
+        }); };
+        this.handleContactMethod = function (input) {
+            if (input === void 0) { input = ''; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var contactMethods;
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!(input == 'contact')) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.handleContactCategoryList(input)];
+                        case 1:
+                            _b.sent();
+                            return [3 /*break*/, 4];
+                        case 2: return [4 /*yield*/, this.loadContactMethods(input.split('/')[1], // type
+                            input.split('/')[0] // id
+                            )];
+                        case 3:
+                            contactMethods = _b.sent();
+                            if (!!((_a = contactMethods.body) === null || _a === void 0 ? void 0 : _a.form)) {
+                                this.handleForm(input, contactMethods);
+                            }
+                            else if (!contactMethods.expanded && contactMethods.inline) {
+                                this.handleSingleContactMethod(contactMethods);
+                            }
+                            else if (!!contactMethods.contactMethods) {
+                                this.handleContactMethodList(input, contactMethods);
+                            }
+                            _b.label = 4;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        this.handleContactCategoryList = function (input) { return __awaiter(_this, void 0, void 0, function () {
+            var newGuid, type, contactMethods;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        newGuid = (0, uuid_1.v4)();
+                        type = knowledge_widget_types_grid_1.DataType.ContactMethodCategories;
+                        return [4 /*yield*/, this.loadContactMethods(type)];
+                    case 1:
+                        contactMethods = _a.sent();
+                        this.chatClient.printUserMessageAndStoreIt(input);
+                        this.printMessage(newGuid, contactMethods);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this.updateForm = function (contactMethod, properties) {
+            var _a;
+            if ((_a = contactMethod === null || contactMethod === void 0 ? void 0 : contactMethod.body) === null || _a === void 0 ? void 0 : _a.form) {
+                var body = contactMethod.body;
+                var builder = new widget_forms_1.FormBuilder(body.form);
+                if (!body.form.layout || !body.form.layout.submit) {
+                    builder.createComponent((0, widget_forms_1.submitButton)(properties.submit, 'submit'));
+                }
+                if (properties.errors) {
+                    builder.setValidationErrors(properties.errors);
+                }
+                return __assign(__assign({}, body), { form: builder.get() });
+            }
+            return (contactMethod === null || contactMethod === void 0 ? void 0 : contactMethod.body) || {};
+        };
+    }
+    ContactMethodClient.initialize = function (dataClient, contactMethodPlatform, agent) {
+        this.dataClient = dataClient;
+        this.contactMethodPlatform = contactMethodPlatform;
+        this.agent = agent;
+    };
+    ContactMethodClient.prototype.validate = function (form) {
+        var _this = this;
+        var entry = ContactMethodClient.contactMessageEntryArray.find(function (o) { return o.id == form.schema.id; });
+        ContactMethodClient.contactMethodPlatform.validate(entry.contactMethods).then(function (result) {
+            _this.handleNewForm(result.errors, entry);
+            if (result.valid) {
+                _this.submit(entry);
+                _this.removeForm(entry);
+            }
+        });
+    };
+    ContactMethodClient.prototype.handleForm = function (input, contactMethods) {
+        var title = input.split('/')[2];
+        contactMethods.expanded = true;
+        this.updateForm(contactMethods, {
+            submit: 'Submit',
+            errors: undefined,
+        });
+        this.printMessage(contactMethods.id, contactMethods, title);
+    };
+    ContactMethodClient.prototype.handleContactMethodList = function (input, contactMethods) {
+        var title = input.split('/')[2];
+        var newGuid = (0, uuid_1.v4)();
+        this.printMessage(newGuid, contactMethods, title);
+    };
+    ContactMethodClient.prototype.handleSingleContactMethod = function (contactMethods) {
+        var entry = ContactMethodClient.contactMessageEntryArray.find(function (o) {
+            return o.contactMethods.contactMethods.find(function (t) { return t.id == contactMethods.id; });
+        });
+        var curCM = entry.contactMethods.contactMethods.find(function (t) { return t.id == contactMethods.id; });
+        curCM.expanded = true;
+        var message = {
+            contactMethods: entry.contactMethods,
+            type: 'ace-knowledge-contact-method',
+            noPadding: true,
+        };
+        store_helper_1.StoreHelper.insertOrUpdateMessageArrayStore([
+            {
+                id: entry.id,
+                message: message,
+                isUser: false,
+            },
+        ]);
+        entry.entry.update(message);
+    };
+    ContactMethodClient.prototype.submit = function (entry) {
+        ContactMethodClient.contactMethodPlatform.submit(entry.contactMethods).then(function (result) {
+            if (!!result)
+                ContactMethodClient.agent.print(result);
+        });
+    };
+    ContactMethodClient.prototype.removeForm = function (entry) {
+        entry.entry.remove();
+        ContactMethodClient.contactMessageEntryArray.splice(ContactMethodClient.contactMessageEntryArray.indexOf(entry), 1);
+    };
+    ContactMethodClient.prototype.printMessage = function (newGuid, contactMethods, title) {
+        if (title === void 0) { title = undefined; }
+        if (ContactMethodClient.contactMessageEntryArray.find(function (o) { return o.id == contactMethods.id; })) {
+            var entry = ContactMethodClient.contactMessageEntryArray.find(function (o) { return o.id == contactMethods.id; });
+            var message = {
+                contactMethods: contactMethods,
+                type: 'ace-knowledge-contact-method',
+                noPadding: true,
+            };
+            entry.entry.update(message);
+            store_helper_1.StoreHelper.insertOrUpdateMessageArrayStore([
+                {
+                    id: entry.guid,
+                    message: message,
+                    isUser: false,
+                },
+            ]);
+        }
+        else {
+            if (title)
+                this.chatClient.printUserMessageAndStoreIt(title);
+            var message = {
+                contactMethods: contactMethods,
+                type: 'ace-knowledge-contact-method',
+                noPadding: true,
+            };
+            var entry = ContactMethodClient.agent.print(message);
+            store_helper_1.StoreHelper.insertOrUpdateMessageArrayStore([
+                {
+                    id: newGuid,
+                    message: message,
+                    isUser: false,
+                },
+            ]);
+            ContactMethodClient.contactMessageEntryArray.push({
+                id: newGuid,
+                contactMethods: contactMethods,
+                entry: entry,
+            });
+        }
+    };
+    ContactMethodClient.prototype.loadContactMethods = function (dataType, id) {
+        if (id === void 0) { id = undefined; }
+        switch (dataType) {
+            case knowledge_widget_types_grid_1.DataType.ContactMethodCategories: {
+                return ContactMethodClient.dataClient
+                    .fetch(knowledge_widget_types_grid_1.DataType.ContactMethods, { contactMethodCategoryId: id })
+                    .then(function (contactMethods) { return contactMethods; });
+            }
+            case knowledge_widget_types_grid_1.DataType.ContactMethods: {
+                if (!!id) {
+                    return ContactMethodClient.dataClient
+                        .fetch(knowledge_widget_types_grid_1.DataType.ContactMethod, { contactMethodId: id })
+                        .then(function (contactMethods) { return contactMethods; });
+                }
+                else {
+                    return ContactMethodClient.dataClient
+                        .fetch(knowledge_widget_types_grid_1.DataType.ContactMethods, {})
+                        .then(function (contactMethods) { return contactMethods; });
+                }
+            }
+            case knowledge_widget_types_grid_1.DataType.ContactMethodCategories: {
+                return ContactMethodClient.dataClient
+                    .fetch(knowledge_widget_types_grid_1.DataType.ContactMethods, { contactMethodCategoryId: id })
+                    .then(function (contactMethods) { return contactMethods; });
+            }
+            default: {
+                return Promise.resolve(undefined);
+            }
+        }
+    };
+    ContactMethodClient.contactMessageEntryArray = [];
+    return ContactMethodClient;
+}());
+exports.ContactMethodClient = ContactMethodClient;

package/lib/client/http.client.d.ts

@@ -0,0 +1,22 @@
+import { ServerEntry } from '../contract/model/http/server-entry.model';
+export declare class HttpClient {
+    private endpointUrl;
+    private clientId;
+    private projectionPath;
+    private apiEndpoint;
+    private options;
+    private middlewareClient;
+    private chatClient;
+    constructor(endpoint: string);
+    firstHit(): void;
+    handleUpdate(action: string): Promise<ServerEntry[]>;
+    handleInput(action: string): void;
+    handlePhrase(phrase: string): void;
+    private postAndHandleTheData;
+    private postAndReturnTheData;
+    private getHttpOptions;
+    private constructInputEnvelope;
+    private constructPhraseEnvelope;
+    private constructFirstHitEnvelope;
+    private handleResponseData;
+}

package/lib/client/http.client.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+var http_helper_1 = require("../helper/http.helper");
+var middleware_helper_1 = require("../helper/middleware.helper");
+var store_helper_1 = require("../helper/store.helper");
+var chat_client_1 = __importDefault(require("./chat.client"));
+var middleware_client_1 = __importDefault(require("./middleware.client"));
+var HttpClient = /** @class */ (function () {
+    function HttpClient(endpoint) {
+        this.options = {
+            credentials: http_helper_1.HttpHelper.getCredentials(),
+            clientId: '84d96a63-b8ba-33ec-22d5-515255f866f8',
+        };
+        console.log(endpoint);
+        this.apiEndpoint = endpoint;
+        this.projectionPath = window.location.href;
+        this.endpointUrl = http_helper_1.HttpHelper.combineUrl(this.projectionPath, 'conversations');
+        this.clientId = this.options.clientId;
+        this.middlewareClient = new middleware_client_1.default();
+        this.chatClient = new chat_client_1.default();
+    }
+    HttpClient.prototype.firstHit = function () {
+        var _this = this;
+        // On first hit if there are entries stored in the storage, use them
+        // Otherwise start a new session
+        middleware_helper_1.MiddlewareHelper.getEntrySessionStorage().then(function (o) {
+            if (o && o.length > 0)
+                _this.chatClient.processMessageArrayAndStoreIt(o);
+            else {
+                var envelope = _this.constructFirstHitEnvelope();
+                _this.postAndHandleTheData(envelope);
+            }
+        });
+    };
+    // for updates, such as paging changes
+    HttpClient.prototype.handleUpdate = function (action) {
+        var envelope = this.constructInputEnvelope(action);
+        return this.postAndReturnTheData(envelope, action).then(function (o) {
+            return o.entries;
+        });
+    };
+    // for action clicks
+    HttpClient.prototype.handleInput = function (action) {
+        var envelope = this.constructInputEnvelope(action);
+        this.postAndHandleTheData(envelope, action);
+    };
+    // for text entries by user
+    HttpClient.prototype.handlePhrase = function (phrase) {
+        var envelope = this.constructPhraseEnvelope(phrase);
+        this.postAndHandleTheData(envelope);
+    };
+    HttpClient.prototype.postAndHandleTheData = function (envelope, action) {
+        var _this = this;
+        return fetch(this.apiEndpoint, this.getHttpOptions(envelope))
+            .then(function (response) {
+            if (response.ok)
+                return response.json();
+            throw response;
+        })
+            .then(function (data) {
+            _this.handleResponseData(data, action);
+        })
+            .catch(function (err) { return console.log(err); });
+    };
+    HttpClient.prototype.postAndReturnTheData = function (envelope, action) {
+        return fetch(this.apiEndpoint, this.getHttpOptions(envelope))
+            .then(function (response) {
+            if (response.ok)
+                return response.json();
+            throw response;
+        })
+            .then(function (data) {
+            return data;
+        })
+            .catch(function (err) { return console.log(err); });
+    };
+    HttpClient.prototype.getHttpOptions = function (envelope) {
+        return Object.assign({}, http_helper_1.HttpHelper.fetchOptions, {
+            body: JSON.stringify(envelope),
+            credentials: this.options.credentials,
+        });
+    };
+    HttpClient.prototype.constructInputEnvelope = function (action) {
+        return {
+            action: store_helper_1.StoreHelper.getAction(action),
+            localState: store_helper_1.StoreHelper.getLocalState(action),
+            globalState: store_helper_1.StoreHelper.getGlobalState(),
+            clientId: this.clientId,
+        };
+    };
+    HttpClient.prototype.constructPhraseEnvelope = function (phrase) {
+        return {
+            command: { phrase: phrase },
+            globalState: store_helper_1.StoreHelper.getGlobalState(),
+            clientId: this.clientId,
+        };
+    };
+    HttpClient.prototype.constructFirstHitEnvelope = function () {
+        return {
+            command: { site: this.endpointUrl },
+            clientId: this.clientId,
+            globalState: {},
+        };
+    };
+    HttpClient.prototype.handleResponseData = function (envelope, action) {
+        store_helper_1.StoreHelper.setGlobalState(envelope.globalState);
+        this.middlewareClient.handleEntries(envelope.entries, action);
+    };
+    return HttpClient;
+}());
+exports.HttpClient = HttpClient;

package/lib/client/middleware.client.d.ts

@@ -0,0 +1,13 @@
+import { ServerEntry } from '../contract/model/http/server-entry.model';
+export default class MiddlewareClient {
+    private paging;
+    private processor;
+    private entryInterface;
+    private chatClient;
+    constructor();
+    static initialize(container: any, widget: any): void;
+    handleEntries(entries: ServerEntry[], action?: string): void;
+    handleUpdate(input: string, endpoint: string): void;
+    checkForUpdate(input: string): boolean;
+    private executeMiddlewares;
+}

package/lib/client/middleware.client.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var middleware_helper_1 = require("../helper/middleware.helper");
+var store_helper_1 = require("../helper/store.helper");
+var entry_interface_1 = __importDefault(require("../interface/entry.interface"));
+// import ContactExpandedInterface from "../interface/middleware/contact-expanded.interface";
+// import ContactInterface from "../interface/middleware/legacy-contact-methods.interface";
+var paging_interface_1 = __importDefault(require("../interface/middleware/paging.interface"));
+var processor_interface_1 = __importDefault(require("../interface/middleware/processor.interface"));
+var chat_client_1 = __importDefault(require("./chat.client"));
+var http_client_1 = require("./http.client");
+var MiddlewareClient = /** @class */ (function () {
+    function MiddlewareClient() {
+        // this.contactExpanded = new ContactExpandedInterface();
+        // this.legacyContact = new ContactInterface();
+        this.paging = new paging_interface_1.default();
+        this.processor = new processor_interface_1.default();
+        this.entryInterface = new entry_interface_1.default();
+        this.chatClient = new chat_client_1.default();
+    }
+    MiddlewareClient.initialize = function (container, widget) {
+        middleware_helper_1.MiddlewareHelper.setContainer(container);
+        middleware_helper_1.MiddlewareHelper.setWidget(widget);
+    };
+    // called on all standart scenarios like actions and user messages
+    MiddlewareClient.prototype.handleEntries = function (entries, action) {
+        var o = this.executeMiddlewares(entries, false, action);
+        var messageArray = this.entryInterface.transformArray(o);
+        this.chatClient.processMessageArrayAndStoreIt(messageArray);
+    };
+    // called on situations such as paging changes
+    // when no new entries will be printed
+    MiddlewareClient.prototype.handleUpdate = function (input, endpoint) {
+        var _this = this;
+        var httpClient = new http_client_1.HttpClient(endpoint);
+        httpClient.handleUpdate(input).then(function (entries) {
+            var o = _this.executeMiddlewares(entries, true, input);
+            var messageArray = _this.entryInterface.transformArray(o);
+            _this.chatClient.updateMessageArrayAndStoreIt(messageArray);
+        });
+    };
+    // checks whether the action was of an update type
+    MiddlewareClient.prototype.checkForUpdate = function (input) {
+        return input === 'next';
+    };
+    MiddlewareClient.prototype.executeMiddlewares = function (entries, isUpdate, action) {
+        if (isUpdate && action)
+            entries = this.processor.processUpdate(store_helper_1.StoreHelper.getEntry(action), entries);
+        else {
+            entries = this.processor.process(entries);
+        }
+        entries = this.paging.process(entries);
+        return entries;
+    };
+    return MiddlewareClient;
+}());
+exports.default = MiddlewareClient;

package/lib/contract/custom-component/contact-method-item.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface PropsType {
+    contactMethod: any;
+    type: any;
+    className?: any;
+}
+declare const ContactMethodItem: React.FC<PropsType>;
+export default ContactMethodItem;