@telia-ace/knowledge-widget-bot-provider 0.0.1-alpha.45 → 0.0.1-alpha.48

package/dist/index.js

@@ -0,0 +1,1131 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { ContactMethodPlatform } from "@telia-ace/knowledge-widget-adapters";
+import { DataType, DataClient } from "@telia-ace/knowledge-widget-types-grid";
+import { ConversationMessageListItemType, ConversationPlatform, registerCustomMessageComponent } from "@telia-ace/widget-conversation";
+import { v4 } from "uuid";
+import { createStorageWriter, StorageCategory, readStorage } from "@telia-ace/widget-services";
+import { FormBuilder, submitButton } from "@telia-ace/widget-forms";
+var ServerEntryTypeEnum = /* @__PURE__ */ ((ServerEntryTypeEnum2) => {
+  ServerEntryTypeEnum2[ServerEntryTypeEnum2["Widget"] = 0] = "Widget";
+  ServerEntryTypeEnum2[ServerEntryTypeEnum2["Text"] = 1] = "Text";
+  ServerEntryTypeEnum2[ServerEntryTypeEnum2["Contact"] = 2] = "Contact";
+  ServerEntryTypeEnum2[ServerEntryTypeEnum2["List"] = 3] = "List";
+  ServerEntryTypeEnum2[ServerEntryTypeEnum2["Error"] = 4] = "Error";
+  return ServerEntryTypeEnum2;
+})(ServerEntryTypeEnum || {});
+class ChatHelper {
+  static setUser(user) {
+    this.user = user;
+  }
+  static setAgent(agent) {
+    this.agent = agent;
+  }
+  static getUser() {
+    return this.user;
+  }
+  static getAgent() {
+    return this.agent;
+  }
+}
+const _MiddlewareHelper = class {
+  static setContainer(container) {
+    _MiddlewareHelper.container = container;
+  }
+  static setWidget(widget) {
+    this.widget = widget;
+  }
+  static getContainer() {
+    return this.container;
+  }
+  static getWidget() {
+    return this.widget;
+  }
+  static getEntrySessionStorage() {
+    return readStorage(this.container, this.sessionMessageStorageVariable);
+  }
+};
+let MiddlewareHelper = _MiddlewareHelper;
+MiddlewareHelper.sessionMessageStorageVariable = "conversation-plugin-messages";
+MiddlewareHelper.setEntrySessionStorage = (messages) => __async(this, null, function* () {
+  return createStorageWriter(_MiddlewareHelper.container, _MiddlewareHelper.sessionMessageStorageVariable, StorageCategory.Necessary).then((write) => {
+    return write(messages);
+  });
+});
+const botProviderGlobalStateSessionKey = "bot-provider-global-state";
+const _StoreHelper = class {
+  constructor() {
+    _StoreHelper.globalState = {
+      completedInteractionsCount: 0,
+      lastBotGuide: 0,
+      site: "",
+      invincibleParameters: {}
+    };
+  }
+  static insertOrUpdateMessageArrayStore(messageArray, entry) {
+    return __async(this, null, function* () {
+      for (const message of messageArray.filter((o) => !!o)) {
+        if (!this.messageStore.find((o) => o.id == message.id)) {
+          this.insertMessageToStore(message);
+        } else {
+          this.updateMessageInStore(message, entry);
+        }
+      }
+      yield MiddlewareHelper.setEntrySessionStorage(this.messageStore);
+    });
+  }
+  static insertMessageToStore(message) {
+    this.messageStore.push(message);
+  }
+  static updateMessageInStore(message, entry) {
+    message.conversationEntry = entry;
+    let index = this.messageStore.findIndex((o) => o.id == message.id);
+    this.messageStore[index] = message;
+  }
+  static checkIdInMessageStore(id) {
+    return this.messageStore.find((o) => o.id == id) === void 0;
+  }
+  static getLocalState(action) {
+    const entry = this.getEntry(action);
+    return entry == null ? void 0 : entry.localState;
+  }
+  static getGlobalState() {
+    return _StoreHelper.globalState;
+  }
+  static setGlobalState(state) {
+    _StoreHelper.globalState = state;
+    return createStorageWriter(MiddlewareHelper.getContainer(), botProviderGlobalStateSessionKey, StorageCategory.Necessary).then((write) => {
+      return write(state);
+    });
+  }
+  static getAction(action) {
+    const entry = this.getEntry(action);
+    return {
+      key: action,
+      content: entry == null ? void 0 : entry.actions[action]
+    };
+  }
+  static getCommand(text) {
+    return { phrase: text };
+  }
+  static getEntry(action) {
+    let entry = void 0;
+    this.getEntryStore().forEach((o) => {
+      if (o.actions[action]) {
+        entry = o;
+      }
+    });
+    return entry;
+  }
+  static getMessage(id) {
+    return this.messageStore.find((o) => o.id == id);
+  }
+  static getEntryStore() {
+    return this.messageStore.filter((o) => !!o.entry).map((o) => {
+      return o.entry;
+    });
+  }
+  static rehydrateState() {
+    return __async(this, null, function* () {
+      const state = yield readStorage(MiddlewareHelper.getContainer(), botProviderGlobalStateSessionKey);
+      if (state) {
+        this.setGlobalState(state);
+      }
+    });
+  }
+};
+let StoreHelper = _StoreHelper;
+StoreHelper.messageStore = [];
+const _ContactMethodClient = class {
+  constructor(container) {
+    this.handleNewForm = (errors, entry) => __async(this, null, function* () {
+      this.updateForm(entry.contactMethods, {
+        submit: "Submit",
+        errors
+      });
+      entry.entry.update({
+        contactMethods: entry.contactMethods,
+        type: "ace-knowledge-contact-method",
+        noPadding: true
+      });
+    });
+    this.handleContactMethod = (input = "") => __async(this, null, function* () {
+      var _a;
+      if (input == "contact") {
+        yield this.handleContactCategoryList(input);
+      } else {
+        let contactMethods = yield this.loadContactMethods(input.split("/")[1], input.split("/")[0]);
+        if (!!((_a = contactMethods.body) == null ? 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);
+        }
+      }
+    });
+    this.handleContactCategoryList = (input) => __async(this, null, function* () {
+      let newGuid = v4();
+      let type = DataType.ContactMethodCategories;
+      let contactMethods = yield this.loadContactMethods(type);
+      this.chatClient.printUserMessageAndStoreIt(input);
+      this.printMessage(newGuid, contactMethods);
+    });
+    this.updateForm = (contactMethod, properties) => {
+      var _a;
+      if ((_a = contactMethod == null ? void 0 : contactMethod.body) == null ? void 0 : _a.form) {
+        const { body } = contactMethod;
+        const builder = new FormBuilder(body.form);
+        if (!body.form.layout || !body.form.layout.submit) {
+          builder.createComponent(submitButton(properties.submit, "submit"));
+        }
+        if (properties.errors) {
+          builder.setValidationErrors(properties.errors);
+        }
+        return __spreadProps(__spreadValues({}, body), {
+          form: builder.get()
+        });
+      }
+      return (contactMethod == null ? void 0 : contactMethod.body) || {};
+    };
+    this.chatClient = new ChatClient(container);
+  }
+  static initialize(container, dataClient, contactMethodPlatform, agent) {
+    this.dataClient = dataClient;
+    this.contactMethodPlatform = contactMethodPlatform;
+    this.agent = agent;
+    this.container = container;
+  }
+  validate(form) {
+    let entry = _ContactMethodClient.contactMessageEntryArray.find((o) => o.id == form.schema.id);
+    _ContactMethodClient.contactMethodPlatform.validate(entry.contactMethods).then((result) => {
+      this.handleNewForm(result.errors, entry);
+      if (result.valid) {
+        this.submit(entry);
+        this.removeForm(entry);
+      }
+    });
+  }
+  handleForm(input, contactMethods) {
+    let title = input.split("/")[2];
+    contactMethods.expanded = true;
+    this.updateForm(contactMethods, {
+      submit: "Submit",
+      errors: void 0
+    });
+    this.printMessage(contactMethods.id, contactMethods, title);
+  }
+  addContactMethod(contactMethod) {
+    contactMethod.expanded = true;
+    this.updateForm(contactMethod, {
+      submit: "Submit",
+      errors: void 0
+    });
+    return this.printMessage(contactMethod.id, contactMethod);
+  }
+  expandContactMethod(input) {
+    const message = StoreHelper.getMessage(input.entryId);
+    if ((message == null ? void 0 : message.conversationEntry) && Array.isArray(message.message)) {
+      const messageItemIndex = message.message.findIndex(([listType]) => listType === "ace-knowledge-contact-method");
+      if (messageItemIndex > -1) {
+        const [messageItemType, messageItemContent] = message.message[messageItemIndex];
+        const updatedMessageItemContent = __spreadProps(__spreadValues({}, messageItemContent), {
+          contactMethods: messageItemContent.contactMethods.map((cm) => {
+            cm.expanded = true;
+            return cm;
+          })
+        });
+        const updatedMessageItems = [
+          ...message.message.slice(0, messageItemIndex),
+          [messageItemType, updatedMessageItemContent],
+          ...message.message.slice(messageItemIndex + 1)
+        ];
+        message.conversationEntry.writer({ items: updatedMessageItems });
+      }
+    }
+  }
+  handleContactMethodList(input, contactMethods) {
+    let title = input.split("/")[2];
+    let newGuid = v4();
+    this.printMessage(newGuid, contactMethods, title);
+  }
+  handleSingleContactMethod(contactMethods) {
+    let entry = _ContactMethodClient.contactMessageEntryArray.find((o) => o.contactMethods.contactMethods.find((t) => t.id == contactMethods.id));
+    let curCM = entry.contactMethods.contactMethods.find((t) => t.id == contactMethods.id);
+    curCM.expanded = true;
+    let message = {
+      contactMethods: entry.contactMethods,
+      type: "ace-knowledge-contact-method",
+      noPadding: true
+    };
+    StoreHelper.insertOrUpdateMessageArrayStore([
+      {
+        id: entry.id,
+        message,
+        isUser: false
+      }
+    ]);
+    entry.entry.update(message);
+  }
+  submit(entry) {
+    _ContactMethodClient.contactMethodPlatform.submit(entry.contactMethods).then((result) => {
+      if (!!result)
+        _ContactMethodClient.agent.print(result);
+    });
+  }
+  removeForm(entry) {
+    entry.entry.remove();
+    _ContactMethodClient.contactMessageEntryArray.splice(_ContactMethodClient.contactMessageEntryArray.indexOf(entry), 1);
+  }
+  printMessage(newGuid, contactMethods, title = void 0) {
+    if (_ContactMethodClient.contactMessageEntryArray.find((o) => o.id == contactMethods.id)) {
+      let entry = _ContactMethodClient.contactMessageEntryArray.find((o) => o.id == contactMethods.id);
+      let message = {
+        contactMethods,
+        type: "ace-knowledge-contact-method",
+        noPadding: true
+      };
+      entry.entry.update(message);
+      StoreHelper.insertOrUpdateMessageArrayStore([
+        {
+          id: entry.guid,
+          message,
+          isUser: false
+        }
+      ]);
+      return message;
+    } else {
+      if (title)
+        this.chatClient.printUserMessageAndStoreIt(title);
+      let message = {
+        contactMethods,
+        type: "ace-knowledge-contact-method",
+        noPadding: true
+      };
+      let entry = _ContactMethodClient.agent.print(message);
+      StoreHelper.insertOrUpdateMessageArrayStore([
+        {
+          id: newGuid,
+          message,
+          isUser: false
+        }
+      ]);
+      _ContactMethodClient.contactMessageEntryArray.push({
+        id: newGuid,
+        contactMethods,
+        entry
+      });
+      return message;
+    }
+  }
+  loadContactMethods(dataType, id = void 0) {
+    switch (dataType) {
+      case DataType.ContactMethodCategories: {
+        return _ContactMethodClient.container.getAsync("matchingClient").then((matchingClient) => {
+          return matchingClient.customRequest("/contactmethods", "GET", {});
+        }).then((contactMethods) => {
+          return contactMethods;
+        });
+      }
+      case DataType.ContactMethods: {
+        if (!!id) {
+          return _ContactMethodClient.dataClient.fetch(DataType.ContactMethod, { contactMethodId: id }).then((contactMethods) => contactMethods);
+        } else {
+          return _ContactMethodClient.dataClient.fetch(DataType.ContactMethods, {}).then((contactMethods) => contactMethods);
+        }
+      }
+      case DataType.ContactMethodCategories: {
+        return _ContactMethodClient.dataClient.fetch(DataType.ContactMethods, { contactMethodCategoryId: id }).then((contactMethods) => contactMethods);
+      }
+      default: {
+        return Promise.resolve(void 0);
+      }
+    }
+  }
+};
+let ContactMethodClient = _ContactMethodClient;
+ContactMethodClient.contactMessageEntryArray = [];
+const getContactMethodEntry = (contactMethodId) => {
+  const entries = StoreHelper.getEntryStore();
+  return entries.find((e) => e.content.id === +contactMethodId);
+};
+const convertLegacySymbol = (symbol) => {
+  if (symbol) {
+    const { type, content } = symbol;
+    if (type && content) {
+      return { type, content };
+    }
+  }
+};
+const contactMethodFromLegacy = ({
+  id,
+  title,
+  defaultIcon,
+  exits: [exit],
+  exitType,
+  confirmationText,
+  expandFormAutomatically,
+  form,
+  description
+}, validation) => {
+  const { adapter } = exit || { Adapter: {} };
+  const { clientName = "", settings: adapterSettings = {}, customClientName = "" } = adapter;
+  const settings = {
+    id: id.toString(),
+    title,
+    description,
+    symbol: convertLegacySymbol(defaultIcon),
+    clientName: clientName === "custom.adapter" ? customClientName : clientName,
+    expanded: true,
+    inline: true,
+    body: {}
+  };
+  if (clientName.indexOf("phone") > -1 || clientName.indexOf("freetext") > -1) {
+    const { displayTextBeforeClick, textBeforeClick } = adapterSettings;
+    if (displayTextBeforeClick === "true") {
+      settings.expanded = false;
+      settings.title = textBeforeClick;
+    }
+    if (clientName.indexOf("phone.text") > -1) {
+      settings.body.phoneNumber = adapterSettings.phoneNumber;
+    } else {
+      settings.body.freetext = adapterSettings.freetext;
+    }
+  }
+  if (clientName.indexOf("chat.popup") > -1 || clientName.indexOf("link") > -1 || clientName === "custom.adapter" && exitType === "custom") {
+    settings.body = adapterSettings;
+    settings.body.confirmationFallback = confirmationText;
+  }
+  if (clientName.indexOf("ace") > -1) {
+    settings.body = adapterSettings;
+  }
+  if (form && form.hasValueComponents) {
+    if (validation) {
+      settings.body.form = FormBuilder.fromLegacyForm(id.toString(), form, validation).get();
+    } else {
+      settings.body.form = FormBuilder.fromLegacyForm(id.toString(), form).get();
+    }
+    if (!expandFormAutomatically) {
+      settings.expanded = settings.inline = false;
+    }
+  }
+  return settings;
+};
+class EntryInterface {
+  constructor(container) {
+    this.container = container;
+    this.helpActionKey = "help";
+    this.nextActionKey = "next";
+  }
+  transform(entry, feedbackEntry) {
+    return __async(this, null, function* () {
+      const entryType = ServerEntryTypeEnum[entry.type];
+      switch (entryType) {
+        case ServerEntryTypeEnum.List:
+          return {
+            id: entry.id,
+            message: this.listTransform(entry, feedbackEntry),
+            entry,
+            isUser: false
+          };
+        case ServerEntryTypeEnum.Text:
+          return {
+            id: entry.id,
+            message: this.textTransform(entry, feedbackEntry),
+            entry,
+            isUser: false
+          };
+        case ServerEntryTypeEnum.Contact:
+          return {
+            id: entry.id,
+            message: yield this.transformContactMethod(entry),
+            entry,
+            isUser: false
+          };
+      }
+    });
+  }
+  transformContactMethod(entry) {
+    return __async(this, null, function* () {
+      const dataClient = yield this.container.getAsync("dataClient");
+      const contactMethod = yield dataClient.fetch(DataType.ContactMethod, {
+        contactMethodId: entry.content.id
+      });
+      const cmClient = new ContactMethodClient(this.container);
+      cmClient.addContactMethod(contactMethod);
+    });
+  }
+  transformArray(entryArray) {
+    return __async(this, null, function* () {
+      let feedbackEntry = entryArray.find((o) => o.tags.find((t) => t == "gentle" || t == "feedback"));
+      let returnArray = [];
+      for (const o of entryArray.filter((t) => t !== feedbackEntry)) {
+        let x = yield this.transform(o, feedbackEntry);
+        if (!!x)
+          returnArray.push(x);
+      }
+      return returnArray;
+    });
+  }
+  getUserMessage(action) {
+    let entry = StoreHelper.getEntry(action);
+    return this.getTitleFromEntry(entry, action);
+  }
+  listTransform(entry, feedbackEntry) {
+    if (entry.type === "Contact") {
+      return;
+    }
+    if (!entry.content)
+      return;
+    let object = this.getListActions(entry.content.items, this.getContentText(entry), entry.actions, entry.localState);
+    if (!!feedbackEntry) {
+      let feedbackObject = this.getListActions(feedbackEntry.content.items, this.getContentText(feedbackEntry), feedbackEntry.actions, feedbackEntry.localState);
+      StoreHelper.insertMessageToStore({
+        id: feedbackEntry.id,
+        message: void 0,
+        entry: feedbackEntry,
+        isUser: false
+      });
+      return object.concat(feedbackObject);
+    }
+    return object;
+  }
+  getContentText(entry) {
+    if (entry.content.html)
+      return { body: entry.content.html };
+    if (entry.content.header)
+      return { title: entry.content.header };
+  }
+  textTransform(entry, feedbackEntry) {
+    if (!!entry.content.items)
+      return this.listTransform(entry, feedbackEntry);
+    let returnObj = [
+      ConversationMessageListItemType.HTML,
+      { body: entry.content.html.replace("\n", "") }
+    ];
+    if (!!feedbackEntry) {
+      let feedbackObject = this.getListActions(feedbackEntry.content.items, this.getContentText(feedbackEntry), feedbackEntry.actions, feedbackEntry.localState);
+      StoreHelper.insertMessageToStore({
+        id: feedbackEntry.id,
+        message: void 0,
+        entry: feedbackEntry,
+        isUser: false
+      });
+      feedbackObject.unshift(returnObj);
+      return feedbackObject;
+    }
+    return returnObj;
+  }
+  getListActions(items, text, actions, state) {
+    let list = [];
+    let mainListContent = {};
+    const mainListType = this.getListType(state);
+    let mainList = [mainListType, { actions: mainListContent }];
+    if (mainListType === "ace-knowledge-contact-method") {
+      mainList[1] = __spreadProps(__spreadValues({}, mainList[1]), {
+        contactMethods: items.map((item) => {
+          const formatted = contactMethodFromLegacy(item.data);
+          return formatted;
+        }),
+        entry: {
+          entryId: state.entryId
+        }
+      });
+    }
+    if (text && text.title) {
+      list.push([ConversationMessageListItemType.Header, text.title]);
+    }
+    if (text && text.body) {
+      list.push([ConversationMessageListItemType.HTML, { body: text.body }]);
+    }
+    list.push(mainList);
+    items.forEach((o) => {
+      switch (o.actionKey) {
+        case this.helpActionKey: {
+          list.push([ConversationMessageListItemType.Separator, void 0]);
+          list.push([
+            ConversationMessageListItemType.NoGoodAlternative,
+            { body: o.title }
+          ]);
+          break;
+        }
+        case this.nextActionKey: {
+          if (!!actions["next"] && actions["next"].take === items.filter((o2) => o2.actionKey !== "help").length + 2)
+            mainListContent[o.actionKey] = o.title;
+          break;
+        }
+        default: {
+          mainListContent[o.actionKey] = o.title;
+        }
+      }
+    });
+    return list;
+  }
+  getListType(state) {
+    if ((state == null ? void 0 : state.$type) === "Humany.Matching.Bots.Conversations.GuideListState, Humany.Matching") {
+      return ConversationMessageListItemType.LinkList;
+    } else if ((state == null ? void 0 : state.$type) === "Humany.Matching.Bots.Conversations.States.GuideFeedbackState, Humany.Matching") {
+      return ConversationMessageListItemType.FeedbackList;
+    } else if ((state == null ? void 0 : state.$type) === "Humany.Matching.Bots.Conversations.States.ContactState, Humany.Matching") {
+      return "ace-knowledge-contact-method";
+    } else
+      return ConversationMessageListItemType.ButtonList;
+  }
+  getTitleFromEntry(entry, action) {
+    if (!!entry) {
+      const entryType = ServerEntryTypeEnum[entry.type];
+      switch (entryType) {
+        case ServerEntryTypeEnum.List:
+          return this.getTitleFromList(entry, action);
+        case ServerEntryTypeEnum.Text:
+          return this.textTransform(entry);
+      }
+    }
+  }
+  getTitleFromList(entry, action) {
+    return entry.content.items.find((o) => o.actionKey == action).title;
+  }
+}
+class ChatClient {
+  constructor(container) {
+    this.entryInterface = new EntryInterface(container);
+  }
+  static initialize(user, agent) {
+    ChatHelper.setUser(user);
+    ChatHelper.setAgent(agent);
+  }
+  processMessageArrayAndStoreIt(messages) {
+    return __async(this, null, function* () {
+      for (const message of messages.filter((o) => o && o != null && !!o.message)) {
+        if (message.isUser)
+          this.postUserMessage(message);
+        else
+          this.postAgentMessage(message);
+      }
+      yield StoreHelper.insertOrUpdateMessageArrayStore(messages);
+    });
+  }
+  updateMessageArrayAndStoreIt(messages) {
+    let conversationEntry = void 0;
+    messages.forEach((o) => {
+      let message = StoreHelper.getMessage(o.id);
+      message == null ? void 0 : message.conversationEntry.update(o.message);
+      conversationEntry = message == null ? void 0 : message.conversationEntry;
+    });
+    StoreHelper.insertOrUpdateMessageArrayStore(messages, conversationEntry);
+  }
+  printUserMessageAndStoreIt(action) {
+    if (action == "next" || action == "help")
+      return;
+    let entry = StoreHelper.getEntry(action);
+    let message = {
+      id: v4(),
+      message: !entry ? action : this.getTitleFromEntry(entry, action),
+      isUser: true
+    };
+    this.postUserMessage(message);
+    StoreHelper.insertOrUpdateMessageArrayStore([message]);
+  }
+  postUserMessage(message) {
+    ChatHelper.getUser().print(message.message);
+  }
+  postAgentMessage(message) {
+    message.conversationEntry = ChatHelper.getAgent().print(message.message);
+  }
+  getTitleFromEntry(entry, action) {
+    const entryType = ServerEntryTypeEnum[entry.type];
+    switch (entryType) {
+      case ServerEntryTypeEnum.List:
+        return this.getTitleFromList(entry, action);
+      case ServerEntryTypeEnum.Text:
+        return this.getTitleFromText(entry, action);
+      default:
+        return "";
+    }
+  }
+  getTitleFromText(entry, action) {
+    if (!!entry.content.items)
+      return this.getTitleFromList(entry, action);
+    else
+      return entry.content.html;
+  }
+  getTitleFromList(entry, action) {
+    return entry.content.items.find((o) => o.actionKey == action).title;
+  }
+}
+const _HttpHelper = class {
+  static combineUrl(basePath, path) {
+    return basePath + path;
+  }
+  static getCredentials() {
+    return "same-origin";
+  }
+};
+let HttpHelper = _HttpHelper;
+HttpHelper.fetchOptions = {
+  method: "POST",
+  headers: {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  }
+};
+HttpHelper.managedSubdomainSuffixes = ["stage", "alpha", "beta", "gamma"];
+HttpHelper.parseSubdomain = (input) => {
+  const index = input.lastIndexOf("-");
+  const lastPart = input.substr(index + 1);
+  if (_HttpHelper.managedSubdomainSuffixes.indexOf(lastPart) > -1) {
+    return input.substr(0, index);
+  }
+  return input;
+};
+class PagingInterface {
+  process(entries) {
+    const pagingEntry = entries.find((e) => e.tags.indexOf("paging") > -1);
+    if (pagingEntry) {
+      const stream = StoreHelper.getEntryStore().filter((e) => e.tags.indexOf("paging") > -1 && e.id === pagingEntry.id);
+      if (stream.length > 0) {
+        const last = stream.reduce((acc, entry) => {
+          if (entry.actions.next && entry.actions.next.take >= acc.actions.next.take) {
+            return entry;
+          }
+          return acc;
+        }, stream[0]);
+        if (last.actions.next.take > pagingEntry.actions.next.take) {
+          entries.forEach((entry) => {
+            if (entry.id === pagingEntry.id) {
+              entry.actions.next = __spreadProps(__spreadValues({}, entry.actions.next), {
+                take: last.actions.next.take,
+                skip: last.actions.next.skip
+              });
+            }
+          });
+        }
+      }
+      entries.forEach((entry) => {
+        if (entry.id === pagingEntry.id && entry.content && entry.content.timestamp) {
+          entry.content = __spreadProps(__spreadValues({}, entry.content), {
+            items: entry.content && entry.content.items || []
+          });
+        }
+      });
+    }
+    return entries;
+  }
+}
+class ProcessorInterface {
+  process(entries) {
+    let processedEntries = entries;
+    processedEntries = this.deletePaging(processedEntries);
+    processedEntries = this.delete(processedEntries);
+    processedEntries = this.merge(processedEntries);
+    processedEntries = this.moveLoader(processedEntries);
+    return processedEntries;
+  }
+  processUpdate(entry, updateEntryArray) {
+    updateEntryArray.filter((t) => t.type == "List").forEach((o) => {
+      var _a;
+      (_a = o.content) == null ? void 0 : _a.items.forEach((t) => {
+        if (!(entry == null ? void 0 : entry.content.items.find((p) => p.actionKey == t.actionKey)))
+          entry == null ? void 0 : entry.content.items.push(t);
+      });
+      Object.keys(o.actions).forEach((t) => {
+        this.handleActionUpdateOrInsert(entry == null ? void 0 : entry.actions, t, o.actions);
+      });
+    });
+    var itemArray = entry == null ? void 0 : entry.content.items;
+    if (itemArray.find((o) => o.actionKey == "next")) {
+      itemArray.push(itemArray.splice(itemArray.indexOf(itemArray.find((o) => o.actionKey == "next")), 1)[0]);
+    }
+    if (itemArray.find((o) => o.actionKey == "help")) {
+      itemArray.push(itemArray.splice(itemArray.indexOf(itemArray.find((o) => o.actionKey == "help")), 1)[0]);
+    }
+    return entry ? [entry] : [];
+  }
+  handleActionUpdateOrInsert(currentArray, actionKey, action) {
+    if (!!currentArray)
+      currentArray[actionKey] = action[actionKey];
+  }
+  deletePaging(entries) {
+    return entries.filter((entry) => {
+      const isEmptyPaging = entry.type === "List" && entry.tags && entry.tags.indexOf("paging") > -1 && typeof entry.content === "undefined";
+      return !isEmptyPaging;
+    });
+  }
+  delete(entries) {
+    return entries.filter((entry) => entry.content !== null);
+  }
+  merge(entries) {
+    const output = [];
+    const merge = (source, target = {}) => {
+      const content = {};
+      if (source == null) {
+        return null;
+      }
+      if (target) {
+        Object.keys(target).forEach((key) => {
+          content[key] = target[key];
+        });
+      }
+      Object.keys(source).forEach((key) => {
+        if (key == "items") {
+          if (!content[key])
+            content[key] = [];
+          content[key] = content[key].concat(source[key]);
+        } else if (key == "html")
+          content[key] = content[key] + source[key];
+        else
+          content[key] = source[key];
+      });
+      return content;
+    };
+    const mergeLocalState = (source, target) => {
+      if (source == null)
+        return null;
+      if (Object.keys(source.actions).length === 0)
+        return target.localState;
+      if (Object.keys(target.actions).length === 0)
+        return source.localState;
+      return target.localState;
+    };
+    entries.forEach((entry) => {
+      if (entry.relation && !entry.tags.find((o) => o == "gentle" || o == "feedback")) {
+        let existingEntry = entries.find((o) => o.id == entry.relation);
+        if (existingEntry) {
+          const existingIndex = output.indexOf(existingEntry);
+          existingEntry.localState = mergeLocalState(entry, existingEntry);
+          existingEntry.content = merge(entry.content, existingEntry.content);
+          existingEntry.actions = merge(entry.actions, existingEntry.actions);
+          output[existingIndex] = existingEntry;
+        }
+      } else {
+        output.push(entry);
+      }
+    });
+    return output;
+  }
+  moveLoader(entries) {
+    const loaderEntry = entries.find((e) => e.id === "loader");
+    if (!loaderEntry) {
+      return entries;
+    }
+    const loaderIndex = entries.indexOf(loaderEntry);
+    if (loaderIndex > -1) {
+      entries.splice(entries.length - 1, 0, entries.splice(loaderIndex, 1)[0]);
+    }
+    return entries;
+  }
+}
+class MiddlewareClient {
+  constructor(container) {
+    this.paging = new PagingInterface();
+    this.processor = new ProcessorInterface();
+    this.entryInterface = new EntryInterface(container);
+    this.chatClient = new ChatClient(container);
+  }
+  static initialize(container, widget) {
+    MiddlewareHelper.setContainer(container);
+    MiddlewareHelper.setWidget(widget);
+  }
+  handleEntries(entries, action) {
+    return __async(this, null, function* () {
+      const widgetEntry = (entries || []).find((e) => e.type === "Widget");
+      if (widgetEntry) {
+        const agent = ChatHelper.getAgent();
+        if (agent) {
+          agent.update({
+            name: widgetEntry.content.agent.name,
+            avatar: widgetEntry.content.agent.avatar
+          });
+          const write = yield createStorageWriter(MiddlewareHelper.getContainer(), "bot-provider-conversation-meta", StorageCategory.Necessary);
+          write({
+            agent: {
+              name: widgetEntry.content.agent.name,
+              avatar: widgetEntry.content.agent.avatar
+            }
+          });
+        }
+      }
+      let o = this.executeMiddlewares(entries, false, action);
+      let messageArray = yield this.entryInterface.transformArray(o);
+      this.chatClient.processMessageArrayAndStoreIt(messageArray);
+    });
+  }
+  handleUpdate(entries, action) {
+    return __async(this, null, function* () {
+      let o = this.executeMiddlewares(entries, true, action);
+      let messageArray = yield this.entryInterface.transformArray(o);
+      this.chatClient.updateMessageArrayAndStoreIt(messageArray);
+    });
+  }
+  checkForUpdate(input) {
+    return input === "next";
+  }
+  executeMiddlewares(entries, isUpdate, action) {
+    if (isUpdate && action)
+      entries = this.processor.processUpdate(StoreHelper.getEntry(action), entries);
+    else {
+      entries = this.processor.process(entries);
+    }
+    entries = this.paging.process(entries);
+    return entries;
+  }
+}
+class HttpClient {
+  constructor(endpoint, clientId, container) {
+    this.options = {
+      credentials: HttpHelper.getCredentials(),
+      clientId
+    };
+    this.apiEndpoint = endpoint;
+    this.projectionPath = window.location.href;
+    this.endpointUrl = HttpHelper.combineUrl(this.projectionPath, "conversations");
+    this.clientId = this.options.clientId;
+    this.middlewareClient = new MiddlewareClient(container);
+    this.chatClient = new ChatClient(container);
+    this.container = container;
+  }
+  firstHit() {
+    return __async(this, null, function* () {
+      const entries = yield MiddlewareHelper.getEntrySessionStorage();
+      if (entries && entries.length > 0) {
+        yield StoreHelper.rehydrateState();
+        const meta = yield readStorage(this.container, "bot-provider-conversation-meta");
+        if (meta == null ? void 0 : meta.agent) {
+          const agent = ChatHelper.getAgent();
+          agent.update({
+            name: meta.agent.name,
+            avatar: meta.agent.avatar
+          });
+        }
+        yield this.chatClient.processMessageArrayAndStoreIt(entries);
+      } else {
+        let envelope = this.constructFirstHitEnvelope();
+        yield this.postAndHandleTheData(envelope);
+      }
+    });
+  }
+  handleUpdate(action) {
+    let envelope = this.constructInputEnvelope(action);
+    return this.postAndHandleTheUpdateData(envelope, action);
+  }
+  handleInput(action) {
+    let envelope = this.constructInputEnvelope(action);
+    return this.postAndHandleTheData(envelope, action);
+  }
+  handleCategories() {
+    let envelope = this.constructCategoriesEnvelope();
+    return this.postAndHandleTheData(envelope);
+  }
+  handlePhrase(phrase) {
+    const envelope = this.constructPhraseEnvelope(phrase);
+    const id = v4();
+    const entry = {
+      id,
+      type: "Text",
+      timestamp: new Date(),
+      content: {
+        $type: "Humany.Matching.Bots.Conversations.Content.Text, Humany.Matching",
+        html: `${phrase}`
+      },
+      actions: {},
+      tags: {}
+    };
+    const message = {
+      id,
+      message: ["html", { body: `<p>${phrase}</p>` }],
+      entry,
+      isUser: true,
+      conversationEntry: {}
+    };
+    StoreHelper.insertMessageToStore(message);
+    return this.postAndHandleTheData(envelope);
+  }
+  postAndHandleTheData(envelope, action) {
+    return fetch(this.apiEndpoint, this.getHttpOptions(envelope)).then((response) => {
+      if (response.ok)
+        return response.json();
+      throw response;
+    }).then((data) => {
+      this.handleResponseData(data, action);
+    }).catch((err) => console.log(err));
+  }
+  postAndHandleTheUpdateData(envelope, action) {
+    return fetch(this.apiEndpoint, this.getHttpOptions(envelope)).then((response) => {
+      if (response.ok)
+        return response.json();
+      throw response;
+    }).then((data) => {
+      this.handleUpdateResponseData(data, action);
+    }).catch((err) => console.log(err));
+  }
+  getHttpOptions(envelope) {
+    return Object.assign({}, HttpHelper.fetchOptions, {
+      body: JSON.stringify(envelope),
+      credentials: this.options.credentials
+    });
+  }
+  constructInputEnvelope(action) {
+    return {
+      action: StoreHelper.getAction(action),
+      localState: StoreHelper.getLocalState(action),
+      globalState: StoreHelper.getGlobalState(),
+      clientId: this.clientId
+    };
+  }
+  constructCategoriesEnvelope() {
+    return {
+      action: {
+        content: {
+          $type: "Humany.Matching.Bots.Conversations.Actions.BrowseCategories, Humany.Matching"
+        },
+        key: "browseCategories"
+      },
+      globalState: StoreHelper.getGlobalState(),
+      clientId: this.clientId
+    };
+  }
+  constructPhraseEnvelope(phrase) {
+    return {
+      command: { phrase },
+      globalState: StoreHelper.getGlobalState(),
+      clientId: this.clientId
+    };
+  }
+  constructFirstHitEnvelope() {
+    return {
+      command: { site: this.endpointUrl },
+      clientId: this.clientId,
+      globalState: {}
+    };
+  }
+  handleResponseData(envelope, action) {
+    StoreHelper.setGlobalState(envelope.globalState);
+    return this.middlewareClient.handleEntries(envelope.entries, action);
+  }
+  handleUpdateResponseData(envelope, action) {
+    return this.middlewareClient.handleUpdate(envelope.entries, action);
+  }
+}
+const getKnowledgeBotEndpoint = (container, component) => {
+  const { knowledgeBotEndpoint } = component.properties();
+  if (knowledgeBotEndpoint) {
+    return `${knowledgeBotEndpoint}/conversations`;
+  }
+  const { data } = container.get("$settings");
+  if (!data || !data.projection)
+    throw new Error("Missing Knowledge Bot endpoint");
+  return `${data.projection}/conversations`;
+};
+const KnowledgeBotProviderPlugin = (container) => __async(this, null, function* () {
+  const dataClient = yield DataClient.getInstance(container);
+  const platform = yield ConversationPlatform.getInstance(container);
+  const contactMethodPlatform = yield ContactMethodPlatform.getInstance(container);
+  registerCustomMessageComponent(container, "ace-knowledge-contact-method", import("./contact-method.js"));
+  platform.registerProvider("chat.bot", (conversation, component) => {
+    const endpoint = getKnowledgeBotEndpoint(container, component);
+    const clientId = v4();
+    const agent = conversation.createAgent({
+      name: "",
+      avatar: void 0
+    });
+    ChatClient.initialize(conversation.user, agent);
+    ContactMethodClient.initialize(container, dataClient, contactMethodPlatform, agent);
+    MiddlewareClient.initialize(container, container.get("$widget"));
+    const httpClient = new HttpClient(endpoint, clientId, container);
+    const firstLoader = conversation.loading();
+    httpClient.firstHit().then(firstLoader);
+    component.actions.create("expand", (input) => {
+      const cmClient = new ContactMethodClient(container);
+      cmClient.expandContactMethod(input);
+    });
+    component.actions.create("evaluate", (input) => {
+      const cmClient = new ContactMethodClient(container);
+      cmClient.handleNewForm(input.form, input.form.id);
+    });
+    component.actions.create("validate", (input) => {
+      const cmClient = new ContactMethodClient(container);
+      cmClient.validate(input.form);
+    });
+    component.actions.create("submit", (input) => {
+      var _a;
+      if ((_a = input == null ? void 0 : input.form) == null ? void 0 : _a.schema.id) {
+        getContactMethodEntry(input.form.schema.id);
+      }
+      const cmClient = new ContactMethodClient(container);
+      cmClient.validate(input.form);
+    });
+    component.actions.watch("conversation.user-typing", (input, next) => {
+      return next(input);
+    });
+    component.actions.watch("conversation.user-submit", (input, next) => {
+      const httpClient2 = new HttpClient(endpoint, clientId, container);
+      const loader = conversation.loading();
+      httpClient2.handlePhrase(input.text).then(loader);
+      return next(input);
+    });
+    component.actions.watch("conversation.form", (input, next) => {
+      return next(input);
+    });
+    component.actions.watch("conversation.action", (input, next) => {
+      const chatClient = new ChatClient(container);
+      const cmClient = new ContactMethodClient(container);
+      const loader = conversation.loading();
+      if (input.split("/").length > 1) {
+        cmClient.handleContactMethod(input).then(loader);
+        return next(input);
+      }
+      const httpClient2 = new HttpClient(endpoint, clientId, container);
+      if (input == "burger-clicked") {
+        httpClient2.handleCategories().then(loader);
+        return next(input);
+      }
+      const middlewareClient = new MiddlewareClient(container);
+      if (middlewareClient.checkForUpdate(input)) {
+        httpClient2.handleUpdate(input).then(loader);
+        return next(input);
+      }
+      chatClient.printUserMessageAndStoreIt(input);
+      httpClient2.handleInput(input).then(loader);
+      return next(input);
+    });
+  });
+});
+export { KnowledgeBotProviderPlugin as ConversationPlugin };
+//# sourceMappingURL=index.js.map