@telia-ace/knowledge-widget-bot-provider 0.0.1-alpha.5 → 0.0.1-alpha.52

package/dist/index2.js

@@ -0,0 +1,914 @@
+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 { ConversationMessageListItemType, ConversationPlatform, registerCustomMessageComponent } from "@telia-ace/widget-conversation";
+import { readStorage, createStorageWriter, StorageCategory } from "@telia-ace/widget-services";
+import { uuid } from "@telia-ace/widget-utilities";
+import { FormBuilder, submitButton } from "@telia-ace/widget-forms";
+var CustomMessageTypes = /* @__PURE__ */ ((CustomMessageTypes2) => {
+  CustomMessageTypes2["ContactMethod"] = "ace-knowledge-bot-contact-method";
+  CustomMessageTypes2["ContactList"] = "ace-knowledge-bot-contact-list";
+  CustomMessageTypes2["FeedbackList"] = "ace-knowledge-bot-feedback-list";
+  CustomMessageTypes2["NotificationList"] = "ace-knowledge-bot-notification-list";
+  CustomMessageTypes2["NoGoodAlternative"] = "ace-knowledge-bot-no-good-alternative";
+  return CustomMessageTypes2;
+})(CustomMessageTypes || {});
+const convertLegacySymbol = (symbol) => {
+  if (symbol) {
+    const { type, content } = symbol;
+    if (type && content) {
+      return { type, content };
+    }
+  }
+};
+const createGroup = ({
+  isUser,
+  items = [],
+  meta = {}
+}) => {
+  const groupId = uuid();
+  const group = {
+    id: groupId,
+    isUser,
+    items: items.map((i) => {
+      return {
+        id: i.id || uuid(),
+        isUser,
+        groupId,
+        message: i.message || []
+      };
+    }),
+    meta
+  };
+  return group;
+};
+const contactMethodFromLegacy = ({
+  id,
+  title,
+  defaultIcon,
+  exits: [exit],
+  exitType,
+  confirmationText,
+  expandFormAutomatically,
+  form,
+  description
+}, options = {}) => {
+  const { adapter } = exit || { Adapter: {} };
+  const { clientName = "", settings: adapterSettings = {}, customClientName = "" } = adapter;
+  const { validation } = options;
+  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;
+    }
+    settings.body = updateForm(settings, { submit: "Submit" });
+  }
+  if (options.guideId) {
+    settings.body.guideId = options.guideId;
+  }
+  return settings;
+};
+const 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 CustomMessageTypes.FeedbackList;
+  } else if ((state == null ? void 0 : state.$type) === "Humany.Matching.Bots.Conversations.States.ContactState, Humany.Matching") {
+    return CustomMessageTypes.ContactList;
+  } else
+    return ConversationMessageListItemType.ButtonList;
+};
+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 updateForm = (contactMethod, {
+  submit,
+  errors,
+  meta
+}) => {
+  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.submit) {
+      builder.createComponent(submitButton(submit, "submit"));
+    }
+    if (errors) {
+      builder.setValidationErrors(errors);
+    }
+    if (meta) {
+      builder.setMeta(meta);
+    }
+    return __spreadProps(__spreadValues({}, body), {
+      form: builder.get()
+    });
+  }
+  return (contactMethod == null ? void 0 : contactMethod.body) || {};
+};
+const createGroupItem = ({
+  messageId,
+  message,
+  group
+}) => {
+  return {
+    id: messageId,
+    message,
+    groupId: group.id,
+    isUser: group.isUser
+  };
+};
+const processEntries = (entries, prevGroup) => __async(this, null, function* () {
+  const createListContent = (listType, entry, groupId, listContent = {
+    actions: [],
+    entryId: entry.id,
+    groupId
+  }) => {
+    const contactMethodIds = [];
+    listContent.actions = entry.content.items.map((i) => {
+      var _a;
+      const action = {
+        label: i.title,
+        actionKey: i.actionKey
+      };
+      if (i.data) {
+        const entryAction = entry.actions[i.actionKey];
+        if (listType === CustomMessageTypes.ContactList) {
+          contactMethodIds.push(i.data.id);
+          action.data = contactMethodFromLegacy(i.data, {
+            guideId: (_a = entryAction == null ? void 0 : entryAction.guideId) == null ? void 0 : _a.toString()
+          });
+        } else {
+          action.data = i.data;
+        }
+      }
+      return action;
+    });
+    if (listType === CustomMessageTypes.ContactList) {
+      listContent.contactMethodIds = contactMethodIds;
+    }
+    return listContent;
+  };
+  const transform = (_0, _1, ..._2) => __async(this, [_0, _1, ..._2], function* (entry, group, related = [], prevGroup2) {
+    const messageId = uuid();
+    switch (entry.type) {
+      case "List": {
+        const { header, items, html } = entry.content;
+        const result2 = [];
+        let listContent = {
+          actions: [],
+          entryId: entry.id,
+          groupId: group.id
+        };
+        if (header) {
+          listContent.header = header;
+        }
+        if ((items == null ? void 0 : items.length) > 0) {
+          const listType = getListType(entry.localState);
+          listContent = createListContent(listType, entry, group.id, listContent);
+          if (!!related.length) {
+            const pagingEntry = related.find((e) => e.tags.includes("paging"));
+            const fallbackEntry = related.find((e) => e.tags.includes("fallback"));
+            if (pagingEntry == null ? void 0 : pagingEntry.content) {
+              group.meta.paging = {
+                actions: pagingEntry.actions,
+                items: pagingEntry.content.items,
+                localState: pagingEntry.localState
+              };
+              pagingEntry.content.items.forEach((i) => {
+                listContent.actions.push({
+                  label: i.title,
+                  actionKey: i.actionKey,
+                  data: {
+                    groupId: !!prevGroup2 ? prevGroup2.id : group.id
+                  }
+                });
+              });
+            }
+            if (fallbackEntry) {
+              const fallbackAction = fallbackEntry.content.items.find((i) => i.actionKey === "help");
+              if (fallbackAction) {
+                result2.push(createGroupItem({
+                  messageId,
+                  message: [
+                    ConversationMessageListItemType.Separator,
+                    void 0
+                  ],
+                  group
+                }));
+                result2.push(createGroupItem({
+                  messageId,
+                  message: [
+                    CustomMessageTypes.NoGoodAlternative,
+                    { body: fallbackAction.title }
+                  ],
+                  group
+                }));
+              }
+            }
+          }
+          result2.unshift(createGroupItem({
+            messageId,
+            message: [listType, listContent],
+            group
+          }));
+        }
+        if (html) {
+          result2.unshift(createGroupItem({
+            messageId,
+            message: [ConversationMessageListItemType.HTML, { body: html }],
+            group
+          }));
+        }
+        return result2;
+      }
+      case "Text": {
+        const result2 = [];
+        result2.push(createGroupItem({
+          messageId,
+          message: [
+            ConversationMessageListItemType.HTML,
+            { body: entry.content.html }
+          ],
+          group
+        }));
+        if (!!related.length) {
+          const contactMethodListEntry = related.find((e) => {
+            var _a;
+            return e.type === "List" && ((_a = e.localState) == null ? void 0 : _a.$type) === "Humany.Matching.Bots.Conversations.States.ContactState, Humany.Matching";
+          });
+          const dialogListEntry = related.find((e) => e.tags.includes("dialog"));
+          const feedbackEntry = related.find((e) => e.tags.includes("feedback"));
+          if (dialogListEntry) {
+            result2.push(createGroupItem({
+              messageId,
+              message: [
+                ConversationMessageListItemType.ButtonList,
+                {
+                  actions: dialogListEntry.content.items.map((i) => {
+                    return {
+                      label: i.title,
+                      actionKey: i.actionKey
+                    };
+                  })
+                }
+              ],
+              group
+            }));
+          }
+          if (contactMethodListEntry) {
+            const listContent = createListContent(CustomMessageTypes.ContactList, contactMethodListEntry, group.id);
+            result2.push(createGroupItem({
+              messageId,
+              message: [ConversationMessageListItemType.Separator, void 0],
+              group
+            }));
+            result2.push(createGroupItem({
+              messageId,
+              message: [CustomMessageTypes.ContactList, listContent],
+              group
+            }));
+          }
+          if (feedbackEntry) {
+            if (feedbackEntry.content.html) {
+              result2.push(createGroupItem({
+                messageId,
+                group,
+                message: [
+                  ConversationMessageListItemType.HTML,
+                  {
+                    body: feedbackEntry.content.html
+                  }
+                ]
+              }));
+            }
+            result2.push(createGroupItem({
+              messageId,
+              group,
+              message: [
+                CustomMessageTypes.FeedbackList,
+                {
+                  actions: feedbackEntry.content.items.map((i) => {
+                    return {
+                      actionKey: i.actionKey,
+                      label: i.title
+                    };
+                  })
+                }
+              ]
+            }));
+          }
+        }
+        return result2;
+      }
+      case "Contact": {
+        return [
+          createGroupItem({
+            messageId,
+            message: [
+              CustomMessageTypes.ContactMethod,
+              {
+                contactMethodId: entry.content.id,
+                groupId: group.id,
+                guideId: entry.content.guideId
+              }
+            ],
+            group
+          })
+        ];
+      }
+      case "CategorizedNoticeList": {
+        const result2 = [
+          createGroupItem({
+            messageId,
+            message: [
+              CustomMessageTypes.NotificationList,
+              {
+                id: entry.content.item.id.toString(),
+                header: entry.content.item.title,
+                items: entry.content.item.listNotices,
+                symbol: entry.content.item.defaultIcon
+              }
+            ],
+            group
+          })
+        ];
+        (entry.content.notices || []).forEach((notice) => {
+          result2.push(createGroupItem({
+            messageId,
+            message: [
+              ConversationMessageListItemType.HTML,
+              {
+                body: notice.body
+              }
+            ],
+            group
+          }));
+        });
+        return result2;
+      }
+      case "footerNotice": {
+        return [
+          createGroupItem({
+            messageId,
+            message: [
+              ConversationMessageListItemType.HTML,
+              {
+                body: entry.content.item.body
+              }
+            ],
+            group
+          })
+        ];
+      }
+      case "Error": {
+        return [
+          createGroupItem({
+            messageId,
+            message: [
+              ConversationMessageListItemType.HTML,
+              {
+                body: entry.content.message || "Something went wrong."
+              }
+            ],
+            group
+          })
+        ];
+      }
+      default:
+        return [];
+    }
+  });
+  const splitEntry = (entry) => {
+    if (["CategorizedNoticeList", "NoticeList"].includes(entry.type)) {
+      return (entry.content.items || []).reduce((acc, item) => {
+        if (!entry.content.isInitialNotices) {
+          return acc;
+        }
+        acc.push(__spreadProps(__spreadValues({}, entry), {
+          id: uuid(),
+          type: item.type || entry.type,
+          content: {
+            $type: entry.content.$type,
+            isInitialNotices: entry.content.isInitialNotices,
+            notices: item.notices,
+            item
+          }
+        }));
+        return acc;
+      }, []);
+    }
+    return entry;
+  };
+  const sortMap = /* @__PURE__ */ new Map([
+    ["Text", 1],
+    ["List", 2],
+    ["Contact", 3],
+    ["CategorizedNoticeList", 10]
+  ]);
+  const result = [];
+  const filteredEntries = entries.sort((item, other) => {
+    const defaultSortValue = 20;
+    var sortValue = sortMap.get(item.type) || defaultSortValue;
+    var sortValueOther = sortMap.get(other.type) || defaultSortValue;
+    return sortValue - sortValueOther;
+  }).filter((entry) => !entry.relation).reduce((acc, entry) => {
+    return acc.concat(splitEntry(entry));
+  }, []);
+  for (const entry of filteredEntries) {
+    const relatedEntries = entries.filter((other) => other.relation === entry.id);
+    const group = createGroup({ isUser: false });
+    const items = yield transform(entry, group, relatedEntries, prevGroup);
+    items.forEach((item) => {
+      group.items.push(item);
+    });
+    if (group.items.length) {
+      result.push(group);
+    }
+  }
+  return result;
+});
+class HttpClient {
+  constructor(endpoint, events, store, container) {
+    this.endpoint = endpoint;
+    this.events = events;
+    this.store = store;
+    this.container = container;
+    this.clientId = uuid();
+    this.entries = [];
+  }
+  start() {
+    return __async(this, null, function* () {
+      const storedMessages = yield this.store.read();
+      if (storedMessages && storedMessages.length > 0) {
+        const storedGlobalState = this.store.readGlobalState();
+        this.globalState = storedGlobalState;
+        return storedMessages;
+      } else {
+        const envelope = this.createInitialEnvelope();
+        const initialResponse = yield this.postEnvelope(envelope);
+        return initialResponse;
+      }
+    });
+  }
+  sendMessage(message) {
+    return __async(this, null, function* () {
+      const envelope = {
+        command: { phrase: message },
+        globalState: this.globalState,
+        clientId: this.clientId
+      };
+      const result = yield this.postEnvelope(envelope);
+      return result;
+    });
+  }
+  helpAction() {
+    return __async(this, null, function* () {
+      return this.postEnvelope({
+        action: {
+          key: "help",
+          content: {
+            $type: "Humany.Matching.Bots.Conversations.Actions.Help, Humany.Matching"
+          }
+        },
+        globalState: this.globalState,
+        clientId: this.clientId
+      });
+    });
+  }
+  nextAction(group) {
+    return __async(this, null, function* () {
+      var _a;
+      const { paging } = group.meta;
+      if (!((_a = paging.actions) == null ? void 0 : _a.next)) {
+        return;
+      }
+      return this.postEnvelope({
+        action: {
+          key: "next",
+          content: paging.actions.next
+        },
+        localState: paging.localState,
+        globalState: this.globalState,
+        clientId: this.clientId
+      }, group).then((response) => {
+        const listItemIndex = group.items.findIndex((item) => item.message[0] === "link-list");
+        if (listItemIndex === -1 || !response) {
+          return group;
+        }
+        return __spreadProps(__spreadValues({}, group), {
+          meta: __spreadValues(__spreadValues({}, group.meta), response[0].meta),
+          items: [
+            ...group.items.slice(0, listItemIndex),
+            __spreadProps(__spreadValues({}, group.items[listItemIndex]), {
+              message: [
+                response[0].items[0].message[0],
+                __spreadValues(__spreadValues({}, group.items[listItemIndex].message[1]), response[0].items[0].message[1])
+              ]
+            }),
+            ...group.items.slice(listItemIndex + 1)
+          ]
+        });
+      });
+    });
+  }
+  showContactMethodAction(data) {
+    return __async(this, null, function* () {
+      const entry = this.entries.find((e) => e.id === data.entryId);
+      const actionItem = entry == null ? void 0 : entry.actions[data.actionKey];
+      if (!actionItem) {
+        return;
+      }
+      return this.postEnvelope({
+        action: {
+          key: data.actionKey,
+          content: actionItem
+        },
+        localState: entry.localState,
+        globalState: this.globalState,
+        clientId: this.clientId
+      });
+    });
+  }
+  defaultAction(action) {
+    return __async(this, null, function* () {
+      const entry = this.getEntryOfAction(action);
+      if (!entry) {
+        return;
+      }
+      return this.postEnvelope({
+        action: {
+          key: action,
+          content: entry.actions[action]
+        },
+        localState: entry.localState,
+        globalState: this.globalState,
+        clientId: this.clientId
+      });
+    });
+  }
+  createInitialEnvelope() {
+    return {
+      command: { site: this.endpoint },
+      clientId: this.clientId,
+      globalState: {}
+    };
+  }
+  postEnvelope(envelope, prevGroup) {
+    return __async(this, null, function* () {
+      try {
+        const response = yield fetch(this.endpoint, this.getHttpOptions(envelope));
+        if (!response.ok) {
+          throw response;
+        }
+        const data = yield response.json();
+        return this.handleResponse(data, prevGroup);
+      } catch (error) {
+        let message = "Something went wrong";
+        if (error.message === "Failed to fetch") {
+          message = "Lost connection... Please try again.";
+        }
+        return this.handleResponse({
+          entries: [
+            {
+              id: uuid(),
+              type: "Error",
+              timestamp: new Date().toISOString(),
+              content: {
+                message
+              },
+              actions: {},
+              tags: []
+            }
+          ]
+        });
+      }
+    });
+  }
+  handleResponse(data, prevGroup) {
+    return __async(this, null, function* () {
+      this.entries = this.entries.concat(data.entries);
+      const widgetEntry = data.entries.find((e) => e.type === "Widget");
+      if (widgetEntry) {
+        this.events.dispatch("provider:widget-entry", widgetEntry.content);
+      }
+      if (data.globalState) {
+        this.globalState = data.globalState;
+      }
+      const groups = yield processEntries(data.entries, prevGroup);
+      return groups;
+    });
+  }
+  getHttpOptions(envelope) {
+    const fetchOptions = {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      }
+    };
+    return Object.assign({}, fetchOptions, {
+      body: JSON.stringify(envelope),
+      credentials: "same-origin"
+    });
+  }
+  getEntryOfAction(action) {
+    return this.entries.find((entry) => !!entry.actions[action]);
+  }
+}
+class Store {
+  constructor(container) {
+    this.container = container;
+    this.enabled = false;
+    this.sessionMessageStorageVariable = "knowledge-bot-messages";
+    this.botProviderGlobalStateKey = "bot-provider-global-state";
+    this.botProviderMetaStateKey = "bot-provider-conversation-meta";
+  }
+  readGlobalState() {
+    return __async(this, null, function* () {
+      if (!this.enabled) {
+        return void 0;
+      }
+      const state = yield readStorage(this.container, this.botProviderGlobalStateKey);
+      return state;
+    });
+  }
+  readMetaState() {
+    return __async(this, null, function* () {
+      if (!this.enabled) {
+        return;
+      }
+      return readStorage(this.container, this.botProviderMetaStateKey);
+    });
+  }
+  write(groups) {
+    return __async(this, null, function* () {
+      if (!this.enabled) {
+        return;
+      }
+      return createStorageWriter(this.container, this.sessionMessageStorageVariable, StorageCategory.Necessary).then((write) => {
+        return write(groups);
+      });
+    });
+  }
+  read() {
+    return __async(this, null, function* () {
+      if (!this.enabled) {
+        return [];
+      }
+      return readStorage(this.container, this.sessionMessageStorageVariable).then((groups) => {
+        return groups || [];
+      });
+    });
+  }
+}
+class KnowledgeBotProvider {
+  constructor(container, conversation, component) {
+    this.container = container;
+    this.conversation = conversation;
+    this.groups = [];
+    const { events } = this.container.get("$widget");
+    this.events = events;
+    this.store = new Store(container);
+    this.agent = conversation.createAgent({
+      name: "",
+      avatar: void 0
+    });
+    this.user = conversation.user;
+    const endpoint = getKnowledgeBotEndpoint(container, component);
+    this.httpClient = new HttpClient(endpoint, events, this.store, this.container);
+    this.events.subscribe("provider:widget-entry", (_event, data) => {
+      this.onWidgetEntryReceived(data);
+    });
+    this.events.subscribe("provider:open-contact-method", (_event, data) => __async(this, null, function* () {
+      const response = yield this.httpClient.showContactMethodAction(data);
+      if (response) {
+        if (!!data.contactMethod.title)
+          this.printUserMessage(data.contactMethod.title);
+        this.onMessagesReceived(response);
+      }
+    }));
+  }
+  initialize() {
+    return __async(this, null, function* () {
+      const loader = this.conversation.loading();
+      const storedMeta = yield this.store.readMetaState();
+      if (storedMeta == null ? void 0 : storedMeta.agent) {
+        this.agent.update({
+          name: storedMeta.agent.name,
+          avatar: storedMeta.agent.avatar
+        });
+      }
+      const response = yield this.httpClient.start();
+      if (response) {
+        this.onMessagesReceived(response);
+      }
+      loader();
+    });
+  }
+  onMessagesReceived(groups) {
+    return __async(this, null, function* () {
+      this.groups = this.groups.concat(groups);
+      yield this.store.write(this.groups);
+      groups.forEach((group) => {
+        const items = group.items.map((item) => item.message);
+        if (group.isUser) {
+          group.writer = this.user.print(items);
+        } else {
+          group.writer = this.agent.print(items);
+        }
+      });
+    });
+  }
+  onInput(action) {
+    return __async(this, null, function* () {
+      const actionKey = typeof action === "string" ? action : action.actionKey;
+      switch (actionKey) {
+        case "next":
+          {
+            if (typeof action === "string") {
+              return;
+            }
+            const group = this.groups.find((other) => {
+              var _a;
+              return other.id === ((_a = action.data) == null ? void 0 : _a.groupId);
+            });
+            if (group) {
+              const response = yield this.httpClient.nextAction(group);
+              if (response) {
+                const combined = response.items.map((item) => item.message);
+                group.meta.paging = response == null ? void 0 : response.meta.paging;
+                group.writer.update(combined);
+              }
+            }
+          }
+          break;
+        case "help":
+          {
+            const loader = this.conversation.loading();
+            const response = yield this.httpClient.helpAction();
+            loader();
+            if (response) {
+              this.onMessagesReceived(response);
+            }
+          }
+          break;
+        default:
+          {
+            if (typeof action !== "string" && action.label) {
+              this.printUserMessage(action.label);
+            }
+            const loader = this.conversation.loading();
+            const response = yield this.httpClient.defaultAction(actionKey);
+            if (response) {
+              this.onMessagesReceived(response);
+            }
+            loader();
+          }
+          break;
+      }
+    });
+  }
+  printUserMessage(message) {
+    const group = createGroup({
+      isUser: true,
+      items: [
+        {
+          id: uuid(),
+          isUser: true,
+          message: [ConversationMessageListItemType.HTML, { body: message }]
+        }
+      ]
+    });
+    this.onMessagesReceived([group]);
+    return group;
+  }
+  onMessageSend(message) {
+    return __async(this, null, function* () {
+      const loader = this.conversation.loading();
+      const response = yield this.httpClient.sendMessage(message);
+      this.printUserMessage(message);
+      if (response) {
+        this.onMessagesReceived(response);
+      }
+      loader();
+    });
+  }
+  onWidgetEntryReceived(data) {
+    return __async(this, null, function* () {
+      const agentSettings = {
+        name: data.agent.name,
+        avatar: data.agent.avatar
+      };
+      this.agent.update(agentSettings);
+      const write = yield createStorageWriter(this.container, "bot-provider-conversation-meta", StorageCategory.Necessary);
+      write({
+        agent: agentSettings
+      });
+    });
+  }
+}
+const KnowledgeBotProviderPlugin = (container) => __async(this, null, function* () {
+  const platform = yield ConversationPlatform.getInstance(container);
+  registerCustomMessageComponent(container, CustomMessageTypes.ContactList, import("./contact-method-list.js"));
+  registerCustomMessageComponent(container, CustomMessageTypes.ContactMethod, import("./contact-method.js"));
+  registerCustomMessageComponent(container, CustomMessageTypes.NotificationList, import("./notification-list.js"));
+  registerCustomMessageComponent(container, CustomMessageTypes.NoGoodAlternative, import("./no-good-alternative.js"));
+  registerCustomMessageComponent(container, CustomMessageTypes.FeedbackList, import("./feedback-list.js"));
+  platform.registerProvider("ace-knowledge-bot", (conversation, component) => {
+    const provider = new KnowledgeBotProvider(container, conversation, component);
+    provider.initialize();
+    component.actions.watch("conversation.user-submit", (input, next) => {
+      provider.onMessageSend(input.text);
+    });
+    component.actions.watch("conversation.action", (input, next) => {
+      provider.onInput(input);
+      return next(input);
+    });
+    component.actions.create("evaluate", (input) => {
+      const { events } = container.get("$widget");
+      events.dispatch("bot-provider:evaluate", input);
+    });
+    component.actions.create("submit", (input) => {
+      const { events } = container.get("$widget");
+      events.dispatch("bot-provider:form-submitted", input);
+    });
+  });
+});
+export { KnowledgeBotProviderPlugin as K, updateForm as u };
+//# sourceMappingURL=index2.js.map