@telia-ace/widget-conversation 1.0.23 → 1.0.24

package/dist/index.js

@@ -1,371 +1,235 @@
-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 __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-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());
-  });
+var U = Object.defineProperty, L = Object.defineProperties;
+var _ = Object.getOwnPropertyDescriptors;
+var C = Object.getOwnPropertySymbols;
+var N = Object.prototype.hasOwnProperty, M = Object.prototype.propertyIsEnumerable;
+var T = (r, t, e) => t in r ? U(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, p = (r, t) => {
+  for (var e in t || (t = {}))
+    N.call(t, e) && T(r, e, t[e]);
+  if (C)
+    for (var e of C(t))
+      M.call(t, e) && T(r, e, t[e]);
+  return r;
+}, g = (r, t) => L(r, _(t));
+var R = (r, t) => {
+  var e = {};
+  for (var s in r)
+    N.call(r, s) && t.indexOf(s) < 0 && (e[s] = r[s]);
+  if (r != null && C)
+    for (var s of C(r))
+      t.indexOf(s) < 0 && M.call(r, s) && (e[s] = r[s]);
+  return e;
 };
-import { ComponentPlatform } from "@telia-ace/widget-core";
-import { createStorageWriter, StorageCategory, StorageMedium, StorageScope, readStorage } from "@telia-ace/widget-services";
-import { uuid, lock } from "@telia-ace/widget-utilities";
-import { FormBuilder } from "@telia-ace/widget-forms";
-import { closeAllModals } from "@telia-ace/widget-plugins";
-import { createReactComponent } from "@telia-ace/widget-ui";
-import { lazy } from "react";
-class Agent {
-  constructor(provider, settings) {
-    this.provider = provider;
-    this.print = (settings2) => {
-      const sender = { name: this.name, avatar: this.avatar };
-      const normalized = getNormalizedMessageSettings(settings2);
-      return this.provider.createEntry(normalized.key, normalized.content, ConversationMessageType.Agent, sender, normalized.timestamp);
-    };
-    this.typing = () => {
-      return this.provider.setTypingState({ name: this.name, avatar: this.avatar });
-    };
-    this.name = settings.name;
-    this.avatar = settings.avatar;
-  }
-  update(settings) {
-    const { name, avatar } = settings;
-    if (avatar === null) {
-      this.avatar = void 0;
-    } else if (avatar) {
-      this.avatar = avatar;
+var P = (r, t, e) => new Promise((s, n) => {
+  var i = (c) => {
+    try {
+      a(e.next(c));
+    } catch (h) {
+      n(h);
     }
-    if (name === null) {
-      this.name = void 0;
-    } else if (name) {
-      this.name = name;
+  }, o = (c) => {
+    try {
+      a(e.throw(c));
+    } catch (h) {
+      n(h);
     }
+  }, a = (c) => c.done ? s(c.value) : Promise.resolve(c.value).then(i, o);
+  a((e = e.apply(r, t)).next());
+});
+import { ComponentPlatform as z } from "@telia-ace/widget-core";
+import { createStorageWriter as H, StorageCategory as $, StorageMedium as m, StorageScope as F, readStorage as A } from "@telia-ace/widget-services";
+import { uuid as j, lock as q } from "@telia-ace/widget-utilities";
+import { FormBuilder as G } from "@telia-ace/widget-forms";
+import { closeAllModals as D } from "@telia-ace/widget-plugins";
+import { createReactComponent as Q } from "@telia-ace/widget-ui";
+import { lazy as J } from "react";
+class K {
+  constructor(t, e) {
+    this.provider = t, this.print = (s) => {
+      const n = { name: this.name, avatar: this.avatar }, i = x(s);
+      return this.provider.createEntry(i.key, i.content, E.Agent, n, i.timestamp);
+    }, this.typing = () => this.provider.setTypingState({ name: this.name, avatar: this.avatar }), this.name = e.name, this.avatar = e.avatar;
+  }
+  update(t) {
+    const { name: e, avatar: s } = t;
+    s === null ? this.avatar = void 0 : s && (this.avatar = s), e === null ? this.name = void 0 : e && (this.name = e);
   }
 }
-class ConversationProvider {
-  constructor(name, container, controller) {
-    this.name = name;
-    this.container = container;
-    this.controller = controller;
-    this.subscriptions = [];
-    this.user = controller == null ? void 0 : controller.user;
-  }
-  static create(name, container, controller) {
-    return new ConversationProvider(name, container, controller);
-  }
-  createAgent(settings = {}) {
-    if (this.controller) {
-      return new Agent(this, settings);
-    }
+class k {
+  constructor(t, e, s) {
+    this.name = t, this.container = e, this.controller = s, this.subscriptions = [], this.user = s == null ? void 0 : s.user;
+  }
+  static create(t, e, s) {
+    return new k(t, e, s);
   }
-  print(settings) {
-    var _a;
-    return (_a = this.controller) == null ? void 0 : _a.print(settings);
+  createAgent(t = {}) {
+    if (this.controller)
+      return new K(this, t);
   }
-  setTypingState(sender, type) {
-    var _a;
-    return (_a = this.controller) == null ? void 0 : _a.setTypingState(sender, type);
+  print(t) {
+    var e;
+    return (e = this.controller) == null ? void 0 : e.print(t);
+  }
+  setTypingState(t, e) {
+    var s;
+    return (s = this.controller) == null ? void 0 : s.setTypingState(t, e);
   }
   loading() {
-    if (!this.controller) {
-      return () => () => {
-      };
-    }
-    return this.controller.loader();
+    return this.controller ? this.controller.loader() : () => () => {
+    };
   }
-  createEntry(key, content, type, sender, timestamp) {
-    var _a;
-    return (_a = this.controller) == null ? void 0 : _a.createEntry(key, content, type, sender, timestamp);
+  createEntry(t, e, s, n, i) {
+    var o;
+    return (o = this.controller) == null ? void 0 : o.createEntry(t, e, s, n, i);
   }
   dispose() {
-    var _a;
-    (_a = this.controller) == null ? void 0 : _a.disposeProvider(this);
-    this.controller = null;
-    this.subscriptions.forEach((unsub) => unsub());
+    var t;
+    process.env.NODE_ENV !== "production" && console.log(`conversation-provider: dispose (${this.name})`), (t = this.controller) == null || t.disposeProvider(this), this.controller = null, this.subscriptions.forEach((e) => e());
   }
-  onUnreadMessage(fn) {
-    var _a;
+  onUnreadMessage(t) {
+    var e;
     if (this.controller) {
-      const unsubscribe = (_a = this.controller) == null ? void 0 : _a.onUnreadMessage(fn);
-      this.subscriptions.push(unsubscribe);
-      return () => {
-        unsubscribe();
+      const s = (e = this.controller) == null ? void 0 : e.onUnreadMessage(t);
+      return this.subscriptions.push(s), () => {
+        s();
       };
     }
   }
-  onMounted(fn) {
-    var _a;
+  onMounted(t) {
+    var e;
     if (this.controller) {
-      const unsubscribe = (_a = this.controller) == null ? void 0 : _a.events.subscribe("conversation:component-mount-changed", fn);
-      this.subscriptions.push(unsubscribe);
-      fn({}, this.controller.getComponentMountedState());
-      return () => {
-        unsubscribe();
+      const s = (e = this.controller) == null ? void 0 : e.events.subscribe("conversation:component-mount-changed", t);
+      return this.subscriptions.push(s), t({}, this.controller.getComponentMountedState()), () => {
+        s();
       };
     }
   }
 }
-class User {
-  constructor(controller) {
-    this.controller = controller;
-    this.print = (settings) => {
-      const normalized = getNormalizedMessageSettings(settings);
-      return this.controller.createEntry(normalized.key, normalized.content, ConversationMessageType.User, void 0, normalized.timestamp);
+class V {
+  constructor(t) {
+    this.controller = t, this.print = (e) => {
+      const s = x(e);
+      return this.controller.createEntry(s.key, s.content, E.User, void 0, s.timestamp);
     };
   }
 }
-class ConversationEntry {
-  constructor(writer) {
-    this.writer = writer;
+class Y {
+  constructor(t) {
+    this.writer = t;
   }
-  update(content) {
-    const normalized = this.getNormalizedSettings(content);
-    this.writer(normalized);
+  update(t) {
+    const e = this.getNormalizedSettings(t);
+    this.writer(e);
   }
   remove() {
     this.writer(null);
   }
-  getNormalizedSettings(content) {
-    if (typeof content === "string")
-      return { body: content };
-    else if (content.length > -1 && typeof content === "object")
-      return { items: content };
-    else
-      return content;
+  getNormalizedSettings(t) {
+    return typeof t == "string" ? { body: t } : t.length > -1 && typeof t == "object" ? { items: t } : t;
   }
 }
-var ConversationMessageType = /* @__PURE__ */ ((ConversationMessageType2) => {
-  ConversationMessageType2["User"] = "user";
-  ConversationMessageType2["Agent"] = "agent";
-  ConversationMessageType2["System"] = "system";
-  return ConversationMessageType2;
-})(ConversationMessageType || {});
-const getNormalizedMessageSettings = (settings) => {
-  let content;
-  let key = uuid();
-  let timestamp = Date.now();
-  if (Array.isArray(settings) && settings.length > -1) {
-    if (typeof settings[0] === "string") {
-      content = { items: [settings] };
-    } else {
-      content = { items: settings };
-    }
-  } else if (typeof settings === "string") {
-    content = { body: settings };
-  } else {
-    settings = settings || {};
-    if (settings.type) {
-      content = __spreadValues({}, settings);
-    } else {
-      content = {
-        body: settings.body,
-        actions: settings.actions,
-        title: settings.title
-      };
-      if (settings.key) {
-        key = settings.key;
-      }
-      if (settings.timestamp) {
-        timestamp = settings.timestamp;
-      }
-      if (settings.form) {
-        const builder = FormBuilder.create(key);
-        settings.form(builder);
-        const builtForm = builder.get();
-        content.form = builtForm;
-      }
-      if (settings.timestamp === null) {
-        timestamp = null;
-      }
+var E = /* @__PURE__ */ ((r) => (r.User = "user", r.Agent = "agent", r.System = "system", r))(E || {});
+const x = (r) => {
+  let t, e = j(), s = Date.now();
+  if (Array.isArray(r) && r.length > -1)
+    typeof r[0] == "string" ? t = { items: [r] } : t = { items: r };
+  else if (typeof r == "string")
+    t = { body: r };
+  else if (r = r || {}, r.type)
+    t = p({}, r);
+  else {
+    if (t = {
+      body: r.body,
+      actions: r.actions,
+      title: r.title
+    }, r.key && (e = r.key), r.timestamp && (s = r.timestamp), r.form) {
+      const n = G.create(e);
+      r.form(n);
+      const i = n.get();
+      t.form = i;
     }
+    r.timestamp === null && (s = null);
   }
-  return { content, key, timestamp };
-};
-const removeTypingState = (typingActors, sender) => {
-  if (!sender) {
+  return { content: t, key: e, timestamp: s };
+}, O = (r, t) => {
+  if (!t)
     return;
-  }
-  const senderString = JSON.stringify(sender);
-  const indexToRemove = typingActors.findIndex((item) => {
-    return senderString === JSON.stringify(item);
-  });
-  if (indexToRemove > -1) {
-    return typingActors.splice(indexToRemove, 1);
-  }
+  const e = JSON.stringify(t), s = r.findIndex((n) => e === JSON.stringify(n));
+  if (s > -1)
+    return r.splice(s, 1);
 };
-class ConversationController {
-  constructor(container, id) {
-    this.container = container;
-    this.id = id;
-    this.formHandlers = {};
-    this.user = new User(this);
-    this.providers = [];
-    this.active = false;
-    this.registeredProviders = [];
-    this.loaders = 0;
-    this.componentMounted = false;
-    this.messages = [];
-    this.typingActors = [];
-    this.print = (settings) => {
-      const normalized = getNormalizedMessageSettings(settings);
-      return this.createEntry(normalized.key, normalized.content, "system", void 0, normalized.timestamp);
+class X {
+  constructor(t, e) {
+    this.container = t, this.id = e, this.formHandlers = {}, this.user = new V(this), this.providers = [], this.active = !1, this.registeredProviders = [], this.loaders = 0, this.componentMounted = !1, this.messages = [], this.typingActors = [], this.print = (n) => {
+      const i = x(n);
+      return this.createEntry(i.key, i.content, "system", void 0, i.timestamp);
     };
-    const widget = container.get("$widget");
-    this.events = widget.events.createChild(this);
-  }
-  setProviders(providers) {
-    const removed = [];
-    const added = [];
-    this.providers.reduce((acc, provider) => {
-      if (providers.indexOf(provider) === -1) {
-        acc.push(provider);
-      }
-      return acc;
-    }, []).forEach((providerToRemove) => {
-      const indexToRemove = this.providers.indexOf(providerToRemove);
-      if (indexToRemove > -1) {
-        removed.push(providerToRemove);
-        this.providers.splice(indexToRemove, 1);
-      }
-    });
-    providers.forEach((provider) => {
-      if (this.providers.indexOf(provider) === -1) {
-        added.push(provider);
-        this.providers.push(provider);
-      }
-    });
-    if (added.length || removed.length) {
-      this.events.dispatch("conversation:providers-changed", { added, removed });
-    }
+    const s = t.get("$widget");
+    this.events = s.events.createChild(this);
+  }
+  setProviders(t) {
+    const e = [], s = [];
+    this.providers.reduce((n, i) => (t.indexOf(i) === -1 && n.push(i), n), []).forEach((n) => {
+      const i = this.providers.indexOf(n);
+      i > -1 && (e.push(n), this.providers.splice(i, 1));
+    }), t.forEach((n) => {
+      this.providers.indexOf(n) === -1 && (s.push(n), this.providers.push(n));
+    }), (s.length || e.length) && this.events.dispatch("conversation:providers-changed", { added: s, removed: e });
+  }
+  createProvider(t) {
+    const e = this.providerIndex(t);
+    if (e > -1)
+      return this.registeredProviders[e];
+    const s = k.create(t, this.container, this);
+    return this.registeredProviders.push(s), s;
+  }
+  providerIndex(t) {
+    return this.registeredProviders.findIndex((e) => e.name === t);
   }
-  createProvider(name) {
-    const index = this.providerIndex(name);
-    if (index > -1) {
-      return this.registeredProviders[index];
-    }
-    const provider = ConversationProvider.create(name, this.container, this);
-    this.registeredProviders.push(provider);
-    return provider;
+  dispose() {
+    this.registeredProviders.forEach((t) => t.dispose()), this.messages = [], this.events.dispatch("conversation:controller-disposed", this), this.active = !1;
   }
-  providerIndex(name) {
-    return this.registeredProviders.findIndex((p) => p.name === name);
+  onDispose(t) {
+    return this.events.subscribe("conversation:controller-disposed", t);
   }
-  dispose() {
-    this.registeredProviders.forEach((provider) => provider.dispose());
-    this.messages = [];
-    this.events.dispatch("conversation:controller-disposed", this);
-    this.active = false;
-  }
-  onDispose(fn) {
-    return this.events.subscribe("conversation:controller-disposed", fn);
-  }
-  onStarted(fn) {
-    return this.events.subscribe("conversation:started", fn);
-  }
-  disposeProvider(target) {
-    const index = this.providerIndex(target.name);
-    index > -1 && this.registeredProviders.splice(index, 1);
-    this.events.dispatch("conversation:providers-changed", { removed: [target.name] });
-    if (!this.registeredProviders.length) {
-      this.dispose();
-    }
+  onStarted(t) {
+    return this.events.subscribe("conversation:started", t);
   }
-  onProvidersChange(fn) {
-    return this.events.subscribe("conversation:providers-changed", fn);
+  disposeProvider(t) {
+    const e = this.providerIndex(t.name);
+    e > -1 && this.registeredProviders.splice(e, 1), this.events.dispatch("conversation:providers-changed", { removed: [t.name] }), this.registeredProviders.length || this.dispose();
   }
-  setComponentMountedState(mounted) {
-    if (this.componentMounted === mounted) {
-      return;
-    }
-    this.componentMounted = mounted;
-    if (mounted) {
-      this.events.dispatch("conversation:unread-message", false);
-      this.events.dispatch("conversation:started", true);
-      this.active = true;
-    }
-    this.events.dispatch("conversation:component-mount-changed", mounted);
+  onProvidersChange(t) {
+    return this.events.subscribe("conversation:providers-changed", t);
+  }
+  setComponentMountedState(t) {
+    this.componentMounted !== t && (this.componentMounted = t, t && (this.events.dispatch("conversation:unread-message", !1), this.events.dispatch("conversation:started", !0), this.active = !0), this.events.dispatch("conversation:component-mount-changed", t));
   }
   getComponentMountedState() {
     return this.componentMounted;
   }
-  onUnreadMessage(fn) {
-    return this.events.subscribe("conversation:unread-message", fn);
+  onUnreadMessage(t) {
+    return this.events.subscribe("conversation:unread-message", t);
   }
-  createEntry(key, content, type, sender, timestamp) {
-    const message = {
-      key,
-      content,
-      type,
-      sender: sender || null,
-      timestamp: timestamp || timestamp === null ? timestamp : Date.now()
+  createEntry(t, e, s, n, i) {
+    const o = {
+      key: t,
+      content: e,
+      type: s,
+      sender: n || null,
+      timestamp: i || i === null ? i : Date.now()
     };
-    this.messages.push(message);
-    message.type === "agent" && removeTypingState(this.typingActors, sender);
-    const entry = new ConversationEntry((updated) => {
-      if (updated !== null) {
-        const _a = updated, { timestamp: updatedTimestamp = void 0 } = _a, content2 = __objRest(_a, ["timestamp"]);
-        message.content = content2;
-        if (updatedTimestamp) {
-          message.timestamp = updatedTimestamp;
-        }
+    this.messages.push(o), o.type === "agent" && O(this.typingActors, n);
+    const a = new Y((c) => {
+      if (c !== null) {
+        const h = c, { timestamp: u = void 0 } = h, f = R(h, ["timestamp"]);
+        o.content = f, u && (o.timestamp = u);
       } else {
-        const indexToRemove = this.messages.indexOf(message);
-        message.content = null;
-        if (indexToRemove > -1) {
-          this.messages.splice(indexToRemove, 1);
-        }
+        const u = this.messages.indexOf(o);
+        o.content = null, u > -1 && this.messages.splice(u, 1);
       }
-      this.events.dispatch("conversation:message-updated", { message });
-      this.update();
+      this.events.dispatch("conversation:message-updated", { message: o }), this.update();
     });
-    this.events.dispatch("conversation:message-created", { message });
-    this.update();
-    if (!this.componentMounted) {
-      this.events.dispatch("conversation:unread-message", true);
-    }
-    return entry;
+    return this.events.dispatch("conversation:message-created", { message: o }), this.update(), this.componentMounted || this.events.dispatch("conversation:unread-message", !0), a;
   }
   update() {
     this.events.dispatch("conversation:updated", {
@@ -381,507 +245,333 @@ class ConversationController {
       typingActors: this.typingActors
     };
   }
-  setTypingState(sender, type) {
-    if (this.typingActors.indexOf(sender) === -1) {
-      this.typingActors.push(sender);
-      this.update();
-    }
-    return () => {
-      removeTypingState(this.typingActors, sender);
-      this.update();
+  setTypingState(t, e) {
+    return this.typingActors.indexOf(t) === -1 && (this.typingActors.push(t), this.update()), () => {
+      O(this.typingActors, t), this.update();
     };
   }
   loader() {
     this.loaders = this.loaders + 1;
-    let dismissed = false;
-    if (this.loaders === 1) {
-      this.update();
-    }
-    return () => {
-      if (!dismissed) {
-        dismissed = true;
-        this.loaders = this.loaders - 1;
-        if (this.loaders === 0) {
-          this.update();
-        }
-      }
+    let t = !1;
+    return this.loaders === 1 && this.update(), () => {
+      t || (t = !0, this.loaders = this.loaders - 1, this.loaders === 0 && this.update());
     };
   }
-  submitForm(key, handler) {
-    this.formHandlers[key] = __spreadProps(__spreadValues({}, this.formHandlers[key]), { submit: handler });
+  submitForm(t, e) {
+    this.formHandlers[t] = g(p({}, this.formHandlers[t]), { submit: e });
   }
-  validateForm(key, handler) {
-    this.formHandlers[key] = __spreadProps(__spreadValues({}, this.formHandlers[key]), { validate: handler });
+  validateForm(t, e) {
+    this.formHandlers[t] = g(p({}, this.formHandlers[t]), { validate: e });
   }
 }
-const getParentWidget = (widgetName, implementation) => {
-  const mainWidgetName = widgetName.split("_contact");
-  return implementation.widgets.get(mainWidgetName[0]);
-};
-const getSeparateWidget = (container) => {
-  const originWidget = container.get("$widget");
-  const { name, implementation } = container.get("$widget");
-  const mainWidget = name.indexOf("_contact") > -1 ? getParentWidget(name, implementation) : originWidget;
-  const { data } = container.get("$settings");
-  const { trigger } = mainWidget.container.get("$settings");
-  const chatWidgetName = `${name.replace("_contact-method", "").replace("_contact", "")}_contact-method`;
-  const chatWidget = implementation.widgets.get(chatWidgetName);
-  if (chatWidget && !trigger) {
-    return { chatWidget, mainWidget, data };
-  }
-  return { mainWidget, data };
-};
-const shouldPreventDefault = (container) => {
-  const { chatWidget } = getSeparateWidget(container);
-  return !!chatWidget;
-};
-const openChatWidget = (container, contactMethod, triggerDOMTarget) => {
-  const { mainWidget, data, chatWidget } = getSeparateWidget(container);
-  if (chatWidget) {
-    if (chatWidget.state === "activated") {
-      return chatWidget.invoke("open").then(() => {
-        chatWidget.container.getAsync("conversation").then((conversation) => {
-          conversation.navigateToConversationIfActive(contactMethod.id).then(() => closeAllModals(container));
-        });
-      });
-    }
-    return chatWidget.activate().then(() => {
-      const { trigger } = chatWidget.container.get("$settings");
-      trigger.action = "hide";
-      return chatWidget.invoke("setSettings", () => ({
-        data,
-        trigger,
-        activate: true
-      })).then(() => {
-        return chatWidget.container.getAsync("components").then((components) => {
-          const contactMethodsQuery = components.components().ofType("contact-method");
-          components.write({
-            key: "setContactMethodId",
-            attributes: {
-              properties: {
-                id: contactMethod.id,
-                guideId: contactMethod.guideId
-              }
-            },
-            target: contactMethodsQuery,
-            provider: "localStorage"
-          });
-          const conversationsQuery = components.components().ofType("conversation");
-          components.write({
-            key: "setConversationProvider",
-            attributes: {
-              properties: { providers: [contactMethod.clientName] }
-            },
-            target: conversationsQuery,
-            provider: "localStorage"
-          });
-        });
+const Z = (r, t) => {
+  const e = r.split("_contact");
+  return t.widgets.get(e[0]);
+}, I = (r) => {
+  const t = r.get("$widget"), { name: e, implementation: s } = r.get("$widget"), n = e.indexOf("_contact") > -1 ? Z(e, s) : t, { data: i } = r.get("$settings"), { trigger: o } = n.container.get("$settings"), a = `${e.replace("_contact-method", "").replace("_contact", "")}_contact-method`, c = s.widgets.get(a);
+  return c && !o ? { chatWidget: c, mainWidget: n, data: i } : { mainWidget: n, data: i };
+}, tt = (r) => {
+  const { chatWidget: t } = I(r);
+  return !!t;
+}, B = (r, t, e) => {
+  const { mainWidget: s, data: n, chatWidget: i } = I(r);
+  return i ? i.state === "activated" ? i.invoke("open").then(() => {
+    i.container.getAsync("conversation").then((o) => {
+      o.navigateToConversationIfActive(t.id).then(() => D(r));
+    });
+  }) : i.activate().then(() => {
+    const { trigger: o } = i.container.get("$settings");
+    return o.action = "hide", i.invoke("setSettings", () => ({
+      data: n,
+      trigger: o,
+      activate: !0
+    })).then(() => i.container.getAsync("components").then((a) => {
+      const c = a.components().ofType("contact-method");
+      a.write({
+        key: "setContactMethodId",
+        attributes: {
+          properties: {
+            id: t.id,
+            guideId: t.guideId
+          }
+        },
+        target: c,
+        provider: "localStorage"
       });
-    }).then(() => {
-      return chatWidget.invoke("attach", {
-        key: "contact-method",
-        triggerDOMElement: triggerDOMTarget,
-        withRenderState: "open"
+      const h = a.components().ofType("conversation");
+      a.write({
+        key: "setConversationProvider",
+        attributes: {
+          properties: { providers: [t.clientName] }
+        },
+        target: h,
+        provider: "localStorage"
       });
-    }).then(() => {
-      createStorageWriter(chatWidget.container, "activeStickyWidget", StorageCategory.Necessary, {
-        medium: StorageMedium.Local,
-        scope: StorageScope.Implementation
-      }).then((write) => write(chatWidget.name));
-      return chatWidget.container.getAsync("conversation").then((platform) => {
-        platform.setConversationEndedBehavior(ConversationEndedBehavior.Deactivate);
-      }).then(() => closeAllModals(container)).then(() => false);
-    });
-  }
-  mainWidget.container.getAsync("conversation").then((platform) => {
-    return platform.navigateToConversationIfActive(contactMethod.id).then(() => platform.setConversationEndedBehavior(ConversationEndedBehavior.Navigate));
-  });
-  return chatWidget ? false : true;
-};
-const navigateToConversation = (container, contactMethod, routeName = "conversation") => {
-  const { mainWidget, chatWidget } = getSeparateWidget(container);
-  if (chatWidget) {
-    return chatWidget.container.getAsync("router").then((router) => {
-      router.navigate(routeName, { id: contactMethod.id });
-    });
-  }
-  return mainWidget.container.getAsync("conversation").then((platform) => {
-    var _a;
-    (_a = platform.setConversationEndedBehavior(ConversationEndedBehavior.Navigate)) == null ? void 0 : _a.then(() => {
-      mainWidget.container.getAsync("router").then((router) => {
-        mainWidget.container.getAsync("components").then((components) => {
-          const conversationQuery = components.components().ofType("conversation");
-          components.write({
+    }));
+  }).then(() => i.invoke("attach", {
+    key: "contact-method",
+    triggerDOMElement: e,
+    withRenderState: "open"
+  })).then(() => (H(i.container, "activeStickyWidget", $.Necessary, {
+    medium: m.Local,
+    scope: F.Implementation
+  }).then((o) => o(i.name)), i.container.getAsync("conversation").then((o) => {
+    o.setConversationEndedBehavior(S.Deactivate);
+  }).then(() => D(r)).then(() => !1))) : (s.container.getAsync("conversation").then((o) => o.navigateToConversationIfActive(t.id).then(() => o.setConversationEndedBehavior(S.Navigate))), !i);
+}, et = (r, t, e = "conversation") => {
+  const { mainWidget: s, chatWidget: n } = I(r);
+  return n ? n.container.getAsync("router").then((i) => {
+    i.navigate(e, { id: t.id });
+  }) : s.container.getAsync("conversation").then((i) => {
+    var o;
+    (o = i.setConversationEndedBehavior(S.Navigate)) == null || o.then(() => {
+      s.container.getAsync("router").then((a) => {
+        s.container.getAsync("components").then((c) => {
+          const h = c.components().ofType("conversation");
+          c.write({
             key: "setConversationProvider",
-            attributes: { properties: { providers: [contactMethod.clientName] } },
-            target: conversationQuery,
+            attributes: { properties: { providers: [t.clientName] } },
+            target: h,
             provider: "localStorage"
           });
         }).then(() => {
-          router.navigate(routeName, { id: contactMethod.id });
+          a.navigate(e, { id: t.id });
         });
       });
     });
   });
-};
-const STORAGE_KEY = "conversations";
-var ConversationEndedBehavior = /* @__PURE__ */ ((ConversationEndedBehavior2) => {
-  ConversationEndedBehavior2["Deactivate"] = "deactivate";
-  ConversationEndedBehavior2["Navigate"] = "navigate";
-  ConversationEndedBehavior2["None"] = "none";
-  return ConversationEndedBehavior2;
-})(ConversationEndedBehavior || {});
-class ConversationPlatform {
-  constructor(container, components) {
-    this.container = container;
-    this.components = components;
-    this.controllers = [];
-    this.providers = [];
-    this.disposeProviders = {};
-    this.subscriptions = [];
-    this.storageWriter = null;
-    this.router = null;
-    this.buttonQuery = null;
-    this.sessionInfo = null;
-    const widget = container.get("$widget");
-    this.events = widget.events.createChild(this);
+}, y = "conversations";
+var S = /* @__PURE__ */ ((r) => (r.Deactivate = "deactivate", r.Navigate = "navigate", r.None = "none", r))(S || {});
+class b {
+  constructor(t, e) {
+    this.container = t, this.components = e, this.controllers = [], this.providers = [], this.disposeProviders = {}, this.subscriptions = [], this.storageWriter = null, this.router = null, this.buttonQuery = null, this.sessionInfo = null;
+    const s = t.get("$widget");
+    this.events = s.events.createChild(this);
   }
   initialize() {
-    createStorageWriter(this.container, STORAGE_KEY, StorageCategory.Necessary, {
-      medium: StorageMedium.Local
-    }).then((writer) => this.storageWriter = writer);
-    readStorage(this.container, STORAGE_KEY, StorageMedium.Local).then((storedSession) => {
-      this.buttonQuery = this.components.components().ofType("conversation-return-button");
-      if (storedSession) {
-        this.sessionInfo = storedSession;
-        if (storedSession.id && storedSession.route) {
-          this.writeToComponents({ active: true, alert: { show: false } });
-        }
-      }
-    });
-    this.container.getAsync("router").then((router) => this.router = router);
-    this.events.subscribe("conversation:ended", (event, data) => {
-      var _a, _b, _c;
-      switch ((_a = this.sessionInfo) == null ? void 0 : _a.conversationEndedBehavior) {
+    H(this.container, y, $.Necessary, {
+      medium: m.Local
+    }).then((t) => this.storageWriter = t), A(this.container, y, m.Local).then((t) => {
+      this.buttonQuery = this.components.components().ofType("conversation-return-button"), t && (this.sessionInfo = t, t.id && t.route && this.writeToComponents({ active: !0, alert: { show: !1 } }));
+    }), this.container.getAsync("router").then((t) => this.router = t), this.events.subscribe("conversation:ended", (t, e) => {
+      var s, n, i;
+      switch ((s = this.sessionInfo) == null ? void 0 : s.conversationEndedBehavior) {
         case "deactivate":
-          const widget = this.container.get("$widget");
-          widget.deactivate();
+          this.container.get("$widget").deactivate();
           break;
         case "navigate":
-          const initialRoute = (_b = this.router) == null ? void 0 : _b.getInitialRoute();
-          if (initialRoute) {
-            (_c = this.router) == null ? void 0 : _c.navigate(initialRoute.name);
-          }
+          const a = (n = this.router) == null ? void 0 : n.getInitialRoute();
+          a && ((i = this.router) == null || i.navigate(a.name));
           break;
       }
-      this.writeToComponents({ active: false });
-      this.sessionInfo = null;
-      this.storageWriter && this.storageWriter();
-    });
-  }
-  addSubscription(sub) {
-    this.subscriptions.push(sub);
-  }
-  static getInstance(container, key = "conversation") {
-    return lock(container)(() => {
-      return container.getAsync(key).then((value) => {
-        let conversation = value;
-        if (!conversation) {
-          return ComponentPlatform.getInstance(container).then((components) => {
-            conversation = new ConversationPlatform(container, components);
-            conversation.initialize();
-            container.registerAsync(key, () => conversation);
-            return conversation;
-          });
-        }
-        return conversation;
-      });
+      this.writeToComponents({ active: !1 }), this.sessionInfo = null, this.storageWriter && this.storageWriter();
     });
   }
-  navigateToConversationIfActive(id) {
-    return readStorage(this.container, STORAGE_KEY, StorageMedium.Local).then((storedSession) => {
-      var _a;
-      if (storedSession && storedSession.id === id) {
-        if (storedSession.route) {
-          const { name, params } = storedSession.route;
-          (_a = this.router) == null ? void 0 : _a.navigate(name, params);
-        }
+  addSubscription(t) {
+    this.subscriptions.push(t);
+  }
+  static getInstance(t, e = "conversation") {
+    return q(t)(() => t.getAsync(e).then((s) => {
+      let n = s;
+      return n || z.getInstance(t).then((i) => (n = new b(t, i), n.initialize(), t.registerAsync(e, () => n), n));
+    }));
+  }
+  navigateToConversationIfActive(t) {
+    return A(this.container, y, m.Local).then((e) => {
+      var s;
+      if (e && e.id === t && e.route) {
+        const { name: n, params: i } = e.route;
+        (s = this.router) == null || s.navigate(n, i);
       }
     });
   }
-  setConversationEndedBehavior(behavior) {
-    return readStorage(this.container, STORAGE_KEY, StorageMedium.Local).then((stored) => {
-      let storedSession = stored;
-      if (storedSession) {
-        storedSession.conversationEndedBehavior = behavior;
-      } else {
-        storedSession = { conversationEndedBehavior: behavior };
-      }
-      this.sessionInfo = storedSession;
-      return this.storageWriter && this.storageWriter(this.sessionInfo) || Promise.resolve();
+  setConversationEndedBehavior(t) {
+    return A(this.container, y, m.Local).then((e) => {
+      let s = e;
+      return s ? s.conversationEndedBehavior = t : s = { conversationEndedBehavior: t }, this.sessionInfo = s, this.storageWriter && this.storageWriter(this.sessionInfo) || Promise.resolve();
     });
   }
-  createController(id) {
-    const index = this.controllers.findIndex((c) => c.conversation.id === id);
-    if (index > -1) {
-      return this.controllers[index].conversation;
-    }
-    return new ConversationController(this.container, id);
+  createController(t) {
+    const e = this.controllers.findIndex((s) => s.conversation.id === t);
+    return e > -1 ? this.controllers[e].conversation : new X(this.container, t);
   }
-  registerProvider(name, handler) {
-    const provider = {
-      name,
-      handler
+  registerProvider(t, e) {
+    const s = {
+      name: t,
+      handler: e
     };
-    this.providers.push(provider);
-    this.controllers.filter((controller) => controller.conversation.providers.indexOf(name) > -1).forEach((controller) => {
-      this.invokeHandler(provider, controller);
+    this.providers.push(s), this.controllers.filter((n) => n.conversation.providers.indexOf(t) > -1).forEach((n) => {
+      this.invokeHandler(s, n);
     });
   }
-  registerController(conversation, component) {
-    const index = this.controllers.findIndex((c) => c.conversation.id === conversation.id);
-    let controller;
-    if (index < 0) {
-      controller = { conversation, component };
-      this.controllers.push(controller);
-      const invokeHandlers = (providers) => {
-        if (providers) {
-          this.providers.filter((provider) => providers.indexOf(provider.name) > -1).forEach((provider) => {
-            this.invokeHandler(provider, controller);
-          });
-        }
+  registerController(t, e) {
+    const s = this.controllers.findIndex((i) => i.conversation.id === t.id);
+    let n;
+    if (s < 0) {
+      n = { conversation: t, component: e }, this.controllers.push(n);
+      const i = (o) => {
+        o && this.providers.filter((a) => o.indexOf(a.name) > -1).forEach((a) => {
+          this.invokeHandler(a, n);
+        });
       };
-      this.subscriptions.push(conversation.onDispose((event, data) => {
-        const index2 = this.controllers.findIndex((c) => c.conversation === data);
-        index2 > -1 && this.controllers.splice(index2, 1);
-        this.components.components().ofType("conversation-return-button").select().writeProperties({ active: false });
-        this.events.dispatch("conversation:ended", {}, { bubbles: true });
-      }));
-      this.subscriptions.push(conversation.onProvidersChange((event, data) => {
-        const { added, removed } = data;
-        removed.forEach((removedProvider) => {
-          this.disposeProviders[removedProvider].forEach((dispose) => {
-            dispose();
+      return this.subscriptions.push(t.onDispose((o, a) => {
+        const c = this.controllers.findIndex((h) => h.conversation === a);
+        c > -1 && this.controllers.splice(c, 1), this.components.components().ofType("conversation-return-button").select().writeProperties({ active: !1 }), this.events.dispatch("conversation:ended", {}, { bubbles: !0 });
+      })), this.subscriptions.push(t.onProvidersChange((o, a) => {
+        const { added: c, removed: h } = a;
+        h.forEach((u) => {
+          this.disposeProviders[u].forEach((f) => {
+            f();
           });
-        });
-        invokeHandlers(added);
-      }));
-      this.subscriptions.push(conversation.onStarted((event, isActive) => {
-        var _a, _b;
-        const session = {
-          id: conversation.id,
-          route: (_a = this.router) == null ? void 0 : _a.getRouteData(),
-          conversationEndedBehavior: (_b = this.sessionInfo) == null ? void 0 : _b.conversationEndedBehavior
+        }), i(c);
+      })), this.subscriptions.push(t.onStarted((o, a) => {
+        var h, u;
+        const c = {
+          id: t.id,
+          route: (h = this.router) == null ? void 0 : h.getRouteData(),
+          conversationEndedBehavior: (u = this.sessionInfo) == null ? void 0 : u.conversationEndedBehavior
         };
-        this.sessionInfo = session;
-        this.storageWriter && this.storageWriter(session);
-        this.writeToComponents({ active: isActive });
-      }));
-      this.subscriptions.push(conversation.onUnreadMessage((event, data) => {
-        this.events.dispatch("conversation:unread-message", data);
-        this.writeToComponents({ alert: { show: data } });
-      }));
-      invokeHandlers(conversation.providers);
-      return true;
-    }
-    controller = this.controllers[index];
-    return false;
-  }
-  writeToComponents(properties, key = "conversationReturnButtonState") {
-    if (this.buttonQuery) {
-      this.components.write({
-        key: "conversationReturnButtonState",
-        attributes: { properties },
-        target: this.buttonQuery,
-        provider: "localStorage"
-      });
+        this.sessionInfo = c, this.storageWriter && this.storageWriter(c), this.writeToComponents({ active: a });
+      })), this.subscriptions.push(t.onUnreadMessage((o, a) => {
+        this.events.dispatch("conversation:unread-message", a), this.writeToComponents({ alert: { show: a } });
+      })), i(t.providers), !0;
     }
+    return n = this.controllers[s], !1;
+  }
+  writeToComponents(t, e = "conversationReturnButtonState") {
+    this.buttonQuery && this.components.write({
+      key: "conversationReturnButtonState",
+      attributes: { properties: t },
+      target: this.buttonQuery,
+      provider: "localStorage"
+    });
   }
-  invokeHandler(provider, controller) {
-    const dispose = provider.handler(controller.conversation.createProvider(provider.name), controller.component);
-    if (dispose) {
-      if (!this.disposeProviders[provider.name]) {
-        this.disposeProviders[provider.name] = [];
-      }
-      this.disposeProviders[provider.name].push(dispose);
-    }
+  invokeHandler(t, e) {
+    const s = t.handler(e.conversation.createProvider(t.name), e.component);
+    s && (this.disposeProviders[t.name] || (this.disposeProviders[t.name] = []), this.disposeProviders[t.name].push(s));
   }
   getComponentRoute() {
-    return readStorage(this.container, STORAGE_KEY, StorageMedium.Local).then((stored) => stored == null ? void 0 : stored.route);
+    return A(this.container, y, m.Local).then((t) => t == null ? void 0 : t.route);
   }
   dispose() {
-    Object.keys(this.disposeProviders).forEach((key) => {
-      this.disposeProviders[key].forEach((dispose) => {
-        dispose();
+    Object.keys(this.disposeProviders).forEach((t) => {
+      this.disposeProviders[t].forEach((e) => {
+        e();
       });
-    });
-    this.subscriptions.forEach((unsubscribe) => {
-      unsubscribe();
-    });
-    this.controllers = [];
-    this.providers = [];
-  }
-  static handleContactMethodClick(event, container, contactMethod, callback) {
-    return __async(this, null, function* () {
-      if (shouldPreventDefault(container)) {
-        event.preventDefault();
-        let triggerEl = document.getElementById("humany-dynamic-anchor");
-        if (!triggerEl) {
-          triggerEl = document.createElement("a");
-          triggerEl.setAttribute("href", "#");
-          triggerEl.id = "humany-dynamic-anchor";
-          document.body.appendChild(triggerEl);
-        }
-        openChatWidget(container, contactMethod, triggerEl);
+    }), this.subscriptions.forEach((t) => {
+      t();
+    }), this.controllers = [], this.providers = [];
+  }
+  static handleContactMethodClick(t, e, s, n) {
+    return P(this, null, function* () {
+      if (tt(e)) {
+        t.preventDefault();
+        let i = document.getElementById("humany-dynamic-anchor");
+        i || (i = document.createElement("a"), i.setAttribute("href", "#"), i.id = "humany-dynamic-anchor", document.body.appendChild(i)), B(e, s, i);
       }
-      openChatWidget(container, contactMethod);
+      B(e, s);
     });
   }
-  static handleContactMethodSubmit(container, contactMethod) {
-    return __async(this, null, function* () {
-      return navigateToConversation(container, contactMethod);
+  static handleContactMethodSubmit(t, e) {
+    return P(this, null, function* () {
+      return et(t, e);
     });
   }
 }
-const groupedMessages = (messages, timeout) => {
-  return messages.reduce((acc, current, index) => {
-    var _a, _b;
-    const newItem = __spreadProps(__spreadValues({}, current), {
-      content: [__spreadProps(__spreadValues({}, current.content), { key: current.key })]
-    });
-    if (acc.length > 0 && current.type !== ConversationMessageType.System) {
-      const previous = acc[acc.length - 1];
-      if (!timeout && timeout !== 0 || Math.abs(previous.timestamp - current.timestamp) < timeout) {
-        if (((_a = previous.sender) == null ? void 0 : _a.name) === ((_b = current.sender) == null ? void 0 : _b.name) && previous.type === current.type) {
-          previous.timestamp = current.timestamp;
-          previous.content.push(__spreadProps(__spreadValues({}, current.content), { key: current.key }));
-          return acc;
-        }
-      }
+const st = (r, t) => r.reduce((e, s, n) => {
+  var o, a;
+  const i = g(p({}, s), {
+    content: [g(p({}, s.content), { key: s.key })]
+  });
+  if (e.length > 0 && s.type !== E.System) {
+    const c = e[e.length - 1];
+    if ((!t && t !== 0 || Math.abs(c.timestamp - s.timestamp) < t) && ((o = c.sender) == null ? void 0 : o.name) === ((a = s.sender) == null ? void 0 : a.name) && c.type === s.type)
+      return c.timestamp = s.timestamp, c.content.push(g(p({}, s.content), { key: s.key })), e;
+  }
+  return e.push(i), e;
+}, []), lt = (r) => Promise.all([
+  b.getInstance(r),
+  r.getAsync("router")
+]).then(([t, e]) => Q(r, "conversation", import("./conversation.edf14596.js"), (s) => {
+  const i = e.getRouteData().params.id || s.node.name || "component", o = t.createController(i), a = t.registerController(o, s), c = 3 * 60 * 1e3, h = (l) => {
+    const { providers: d = [] } = l;
+    if (d) {
+      const v = Array.isArray(d) ? d : [d];
+      return o.setProviders(v), v;
     }
-    acc.push(newItem);
-    return acc;
-  }, []);
-};
-const ConversationComponent = (container) => {
-  return Promise.all([
-    ConversationPlatform.getInstance(container),
-    container.getAsync("router")
-  ]).then(([platform, router]) => {
-    return createReactComponent(container, "conversation", import("./conversation.js"), (component) => {
-      const routeData = router.getRouteData();
-      const name = routeData.params.id || component.node.name || "component";
-      const conversation = platform.createController(name);
-      const isNewController = platform.registerController(conversation, component);
-      const messageGroupingTimeout = 3 * 60 * 1e3;
-      const setProperties = (properties) => {
-        const { providers = [] } = properties;
-        if (providers) {
-          const providerKeys = Array.isArray(providers) ? providers : [providers];
-          conversation.setProviders(providerKeys);
-          return providerKeys;
-        }
-      };
-      setProperties(component.properties(setProperties));
-      conversation.setComponentMountedState(true);
-      const writeMessages = (messageStream) => {
-        const { loading, typingActors, messages } = messageStream;
-        component.writeProperties({
-          loading,
-          typingActors,
-          messages: groupedMessages(messages, messageGroupingTimeout)
-        });
-      };
-      writeMessages(conversation.getMessageStream());
-      if (isNewController) {
-        component.actions.create("user-submit", (data, options) => {
-          if (options) {
-            const { preventDefault, validationPromise } = options;
-            if (preventDefault) {
-              if (validationPromise) {
-                validationPromise().then((text) => {
-                  if (text) {
-                    conversation.user.print(text);
-                  }
-                });
-              }
-              return;
-            }
-          }
-          conversation.user.print(data.text);
-        });
-        component.actions.create("user-typing", (data, options) => {
-        });
-        component.actions.create("form", (data, options) => {
-        });
-        component.actions.create("action", (data, options) => {
-        });
-        component.actions.create("overlay-mounted", (data, options) => {
-        });
-        component.actions.create("show-overlay", (data, options) => {
-          component.writeProperties({
-            overlay: { conversation: false, secondary: false }
-          });
-        });
-        component.actions.create("hide-overlay", (data, options) => {
-          component.writeProperties({
-            overlay: null
-          });
-        });
-        component.actions.create("show-overlay-conversation", (data, options) => {
-          component.writeProperties({
-            overlay: { conversation: true, secondary: false }
-          });
-        });
-        component.actions.create("hide-overlay-conversation", (data, options) => {
-          component.writeProperties({
-            overlay: { conversation: false, secondary: false }
-          });
+  };
+  h(s.properties(h)), o.setComponentMountedState(!0);
+  const u = (l) => {
+    const { loading: d, typingActors: v, messages: w } = l;
+    s.writeProperties({
+      loading: d,
+      typingActors: v,
+      messages: st(w, c)
+    });
+  };
+  u(o.getMessageStream()), a && (s.actions.create("user-submit", (l, d) => {
+    if (d) {
+      const { preventDefault: v, validationPromise: w } = d;
+      if (v) {
+        w && w().then((W) => {
+          W && o.user.print(W);
         });
+        return;
       }
-      const unsubscribe = conversation.events.subscribe("conversation:updated", (e, conversationData) => {
-        writeMessages(conversationData);
-      });
-      return () => {
-        conversation.setComponentMountedState(false);
-        unsubscribe();
-        if (!conversation.active) {
-          writeMessages({ messages: [], typingActors: [], loading: false });
-        }
-      };
-    }, { reuseController: true });
+    }
+    o.user.print(l.text);
+  }), s.actions.create("user-typing", (l, d) => {
+  }), s.actions.create("form", (l, d) => {
+  }), s.actions.create("action", (l, d) => {
+  }), s.actions.create("overlay-mounted", (l, d) => {
+  }), s.actions.create("show-overlay", (l, d) => {
+    s.writeProperties({
+      overlay: { conversation: !1, secondary: !1 }
+    });
+  }), s.actions.create("hide-overlay", (l, d) => {
+    s.writeProperties({
+      overlay: null
+    });
+  }), s.actions.create("show-overlay-conversation", (l, d) => {
+    s.writeProperties({
+      overlay: { conversation: !0, secondary: !1 }
+    });
+  }), s.actions.create("hide-overlay-conversation", (l, d) => {
+    s.writeProperties({
+      overlay: { conversation: !1, secondary: !1 }
+    });
+  }));
+  const f = o.events.subscribe("conversation:updated", (l, d) => {
+    u(d);
   });
-};
-const ConversationReturnButtonComponent = (container) => {
-  return Promise.all([
-    ComponentPlatform.getInstance(container),
-    ConversationPlatform.getInstance(container),
-    container.getAsync("router")
-  ]).then(([components, platform, router]) => {
-    return createReactComponent(container, "conversation-return-button", import("./return-button.js"), (component) => {
-      component.actions.create("toggle", (options = {}) => {
-        var _a;
-        (_a = platform.getComponentRoute()) == null ? void 0 : _a.then((route) => {
-          route && router.navigate(route.name, route.params);
-        });
-      });
+  return () => {
+    o.setComponentMountedState(!1), f(), o.active || u({ messages: [], typingActors: [], loading: !1 });
+  };
+}, { reuseController: !0 })), pt = (r) => Promise.all([
+  z.getInstance(r),
+  b.getInstance(r),
+  r.getAsync("router")
+]).then(([t, e, s]) => Q(r, "conversation-return-button", import("./return-button.facf6a45.js"), (n) => {
+  n.actions.create("toggle", (i = {}) => {
+    var o;
+    (o = e.getComponentRoute()) == null || o.then((a) => {
+      a && s.navigate(a.name, a.params);
     });
   });
+}));
+var rt = /* @__PURE__ */ ((r) => (r.LinkList = "link-list", r.Separator = "separator", r.ButtonList = "button-list", r.Text = "text", r.HTML = "html", r.VideoRequest = "video-request", r))(rt || {});
+const vt = (r, t, e) => r.getAsync("componentResolver").then((s) => P(void 0, null, function* () {
+  (yield b.getInstance(r)).addSubscription(s.registerComponent(t, J(() => e)));
+}));
+export {
+  lt as ConversationComponent,
+  X as ConversationController,
+  S as ConversationEndedBehavior,
+  Y as ConversationEntry,
+  rt as ConversationMessageListItemType,
+  E as ConversationMessageType,
+  b as ConversationPlatform,
+  pt as ConversationReturnButtonComponent,
+  vt as registerCustomMessageComponent
 };
-var ConversationMessageListItemType = /* @__PURE__ */ ((ConversationMessageListItemType2) => {
-  ConversationMessageListItemType2["LinkList"] = "link-list";
-  ConversationMessageListItemType2["Separator"] = "separator";
-  ConversationMessageListItemType2["ButtonList"] = "button-list";
-  ConversationMessageListItemType2["Text"] = "text";
-  ConversationMessageListItemType2["HTML"] = "html";
-  ConversationMessageListItemType2["VideoRequest"] = "video-request";
-  return ConversationMessageListItemType2;
-})(ConversationMessageListItemType || {});
-const registerCustomMessageComponent = (container, type, component) => {
-  return container.getAsync("componentResolver").then((o) => __async(this, null, function* () {
-    const platform = yield ConversationPlatform.getInstance(container);
-    platform.addSubscription(o.registerComponent(type, lazy(() => component)));
-  }));
-};
-export { ConversationComponent, ConversationController, ConversationEndedBehavior, ConversationEntry, ConversationMessageListItemType, ConversationMessageType, ConversationPlatform, ConversationReturnButtonComponent, registerCustomMessageComponent };
 //# sourceMappingURL=index.js.map