@miso.ai/client-sdk-ui 1.13.2-beta.0 → 1.14.0-beta.2

package/dist/cjs/layout/list/threads.js

@@ -0,0 +1,257 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _clientSdkWorkflow = require("@miso.ai/client-sdk-workflow");
+var _constants = require("../../constants.js");
+var _collection = _interopRequireDefault(require("./collection.js"));
+var _dom = require("../../util/dom.js");
+var _confirm = _interopRequireDefault(require("../../util/confirm.js"));
+var _prompt = _interopRequireDefault(require("../../util/prompt.js"));
+const _excluded = ["className", "templates"];
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
+const TYPE = _constants.LAYOUT_TYPE.THREADS;
+const DEFAULT_CLASSNAME = 'miso-threads';
+
+// the thread template renders the <li> itself (it is the item, carrying the
+// item role and state), so the stock <li> wrapping is skipped
+function item(layout, state, value, index) {
+  const {
+    templates,
+    options
+  } = layout;
+  return templates[options.itemType](layout, state, value, {
+    index
+  });
+}
+
+/**
+ * The thread list of the chat history interface: a list of `thread` items.
+ *
+ * Selection comes with the data: the history workflow stamps
+ * `selectedThreadId` into its value and the role mapping decorates each
+ * thread record with a `selected` flag, so any selection change flows down
+ * the regular data path and refreshes the view. The list renders
+ * incrementally (append-only); in-place state changes on existing items
+ * (selected, unread) are applied by `_syncSelection` after each render,
+ * reading the fresh values off the item bindings — no item re-render needed.
+ *
+ * Each item carries a context menu (vertical dots) with thread actions,
+ * each asking through a shared modal dialog util, then emitting a view event
+ * for the history workflow to act on: `rename` (a prompt dialog pre-filled
+ * with the current title) and `delete` (a confirm dialog).
+ */
+class ThreadsLayout extends _collection.default {
+  static get type() {
+    return TYPE;
+  }
+  static get defaultClassName() {
+    return DEFAULT_CLASSNAME;
+  }
+  constructor(_ref = {}) {
+    let {
+        className = DEFAULT_CLASSNAME,
+        templates
+      } = _ref,
+      options = _objectWithoutPropertiesLoose(_ref, _excluded);
+    super(Object.assign({
+      className,
+      templates: Object.assign({
+        item
+      }, templates)
+    }, options));
+  }
+  initialize(view) {
+    super.initialize(view);
+    // clicking outside the list closes any open context menu
+    if (typeof document !== 'undefined') {
+      const onDocumentClick = event => {
+        const element = this._element;
+        if (element && !element.contains(event.target)) {
+          this._closeMenus();
+        }
+      };
+      document.addEventListener('click', onDocumentClick);
+      this._unsubscribes.push(() => document.removeEventListener('click', onDocumentClick));
+    }
+  }
+
+  // the list is newest-first, so incremental renders PREPEND the fresh items
+  // (the collection layout's stock incremental mode is append-only)
+  _html(state, rendered, incremental) {
+    if (incremental) {
+      const values = this._getItems(state) || [];
+      const fresh = values.slice(0, values.length - rendered.value.length);
+      return fresh.length > 0 ? this.templates.items(this, state, fresh, {
+        offset: 0
+      }) : '';
+    }
+    return this.templates.root(this, state);
+  }
+  _render(element, {
+    state
+  }, {
+    notifyUpdate
+  }) {
+    const {
+      incremental,
+      html
+    } = state;
+    if (incremental) {
+      if (html) {
+        this._getListElement(element).insertAdjacentHTML('afterbegin', html);
+      } else {
+        notifyUpdate(false);
+      }
+    } else {
+      element.innerHTML = html;
+    }
+  }
+  _afterRender(element, state) {
+    super._afterRender(element, state); // syncs bindings to the latest values
+    this._syncItems(element);
+  }
+
+  // sync in-place item changes from the bound values onto the existing item
+  // elements: selection/unread state, and record changes that arrive without
+  // a re-render (rename, a placeholder thread resolving to its real record)
+  _syncItems(element) {
+    for (const item of this._getItemElements(element)) {
+      const binding = this._bindings.get(item);
+      if (!binding) {
+        continue;
+      }
+      const {
+        value
+      } = binding;
+      (0, _dom.setOrRemoveAttribute)(item, 'data-selected', value.selected ? '' : undefined);
+      (0, _dom.setOrRemoveAttribute)(item, 'data-unread', (0, _clientSdkWorkflow.isThreadUnread)(value) ? '' : undefined);
+      (0, _dom.setOrRemoveAttribute)(item, 'data-thread-id', (0, _clientSdkWorkflow.getThreadId)(value) || undefined);
+      const titleElement = item.querySelector(`.${this.className}__title`);
+      const title = value.title || 'Untitled';
+      if (titleElement && titleElement.textContent !== title) {
+        titleElement.textContent = title;
+      }
+    }
+  }
+
+  // a click on a thread item means selection — a navigation action, not a
+  // content-engagement click: emit a select view event and skip click tracking
+  _onClick(event) {
+    if (event.target.closest(`[data-role="thread-menu-button"]`)) {
+      this._toggleMenu(event.target.closest(`[data-role="item"]`));
+      return;
+    }
+    if (event.target.closest(`[data-role="thread-rename"]`)) {
+      this._closeMenus();
+      const binding = this._bindings.get(event.target.closest(`[data-role="item"]`));
+      binding && this._requestRename(binding);
+      return;
+    }
+    if (event.target.closest(`[data-role="thread-delete"]`)) {
+      this._closeMenus();
+      const binding = this._bindings.get(event.target.closest(`[data-role="item"]`));
+      binding && this._requestDelete(binding);
+      return;
+    }
+    if (event.target.closest(`[data-role="thread-menu"]`)) {
+      return; // other clicks inside the menu don't select
+    }
+    this._closeMenus();
+    const element = event.target.closest(`[data-role="item"]`);
+    if (!element) {
+      return;
+    }
+    const binding = this._bindings.get(element);
+    if (!binding) {
+      return;
+    }
+    const {
+      session
+    } = this._view._state;
+    const {
+      value
+    } = binding;
+    this._view._emit('select', {
+      session,
+      value,
+      element: binding.element,
+      domEvent: event
+    });
+  }
+
+  // context menu //
+  _toggleMenu(item) {
+    const menu = item && item.querySelector(`[data-role="thread-menu"]`);
+    if (!menu) {
+      return;
+    }
+    const open = menu.hidden;
+    this._closeMenus();
+    menu.hidden = !open;
+  }
+  _closeMenus() {
+    const element = this._element;
+    if (!element) {
+      return;
+    }
+    for (const menu of element.querySelectorAll(`[data-role="thread-menu"]:not([hidden])`)) {
+      menu.hidden = true;
+    }
+  }
+
+  // rename //
+  async _requestRename(binding) {
+    const {
+      value,
+      element
+    } = binding;
+    const title = await (0, _prompt.default)({
+      title: 'Rename thread',
+      value: value.title || '',
+      placeholder: 'Thread name',
+      confirmText: 'Rename'
+    });
+    if (!title || title === value.title) {
+      return; // cancelled, cleared, or unchanged
+    }
+    const {
+      session
+    } = this._view._state;
+    this._view._emit('rename', {
+      session,
+      value,
+      element,
+      title
+    });
+  }
+
+  // delete //
+  async _requestDelete(binding) {
+    const {
+      value,
+      element
+    } = binding;
+    const confirmed = await (0, _confirm.default)({
+      title: 'Delete thread',
+      message: `Are you sure you want to delete "${value.title || 'this thread'}"? This cannot be undone.`,
+      confirmText: 'Delete',
+      danger: true
+    });
+    if (!confirmed) {
+      return;
+    }
+    const {
+      session
+    } = this._view._state;
+    this._view._emit('delete', {
+      session,
+      value,
+      element
+    });
+  }
+}
+exports.default = ThreadsLayout;

package/dist/cjs/layout/mixin/trackable.js

@@ -8,7 +8,7 @@ exports.makeTrackable = makeTrackable;
 var _commons = require("@miso.ai/commons");
 var _bindings = _interopRequireDefault(require("../../util/bindings.js"));
 var _viewables = _interopRequireDefault(require("../../util/viewables.js"));
-var _trackers = require("../../util/trackers.js");
+var _clientSdkWorkflow = require("@miso.ai/client-sdk-workflow");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function makeTrackable(prototype) {
   (0, _commons.mixin)(prototype, TrackableMixin.prototype);
@@ -36,8 +36,7 @@ class TrackableMixin {
     this._onBindingsUpdate(bounds, unbounds);
   }
   _getItemKey(value) {
-    // TODO: ad-hoc!
-    return value.product_id || value.text || value.id || value;
+    return this._view.tracker.getItemKey(value);
   }
   _getItems(state) {
     throw new Error(`Not implemented.`);
@@ -92,8 +91,8 @@ class TrackableMixin {
     const {
       click: options
     } = this._view.tracker.options || {};
-    if ((0, _trackers.validateClick)(options, event, binding)) {
-      (0, _trackers.markAsTracked)(event);
+    if ((0, _clientSdkWorkflow.validateClick)(options, event, binding)) {
+      (0, _clientSdkWorkflow.markAsTracked)(event);
       this._view.tracker.click([binding.value]);
     }
   }

package/dist/cjs/layout/mixin/triggerable.js

@@ -7,7 +7,7 @@ exports.TriggerableMixin = void 0;
 exports.makeTriggerable = makeTriggerable;
 var _commons = require("@miso.ai/commons");
 var _constants = require("../../constants.js");
-var _index = require("../../actor/index.js");
+var _clientSdkWorkflow = require("@miso.ai/client-sdk-workflow");
 function makeTriggerable(prototype) {
   (0, _commons.mixin)(prototype, TriggerableMixin.prototype);
 }
@@ -63,7 +63,7 @@ class TriggerableMixin {
     }
   }
   _onTrigger() {
-    this._view.hub.trigger(_index.fields.more());
+    this._view.hub.trigger(_clientSdkWorkflow.fields.more());
   }
   _untrackTrigger() {
     if (!this._trigger) {

package/dist/cjs/layout/radio/feedback.js

@@ -4,13 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _index = require("../../actor/index.js");
+var _constants = require("../../constants.js");
+var _clientSdkWorkflow = require("@miso.ai/client-sdk-workflow");
 var _radio = _interopRequireDefault(require("./radio.js"));
 var _svgs = require("../svgs.js");
 const _excluded = ["className", "templates"];
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-const TYPE = 'feedback';
+const TYPE = _constants.LAYOUT_TYPE.FEEDBACK;
 const DEFAULT_CLASSNAME = 'miso-feedback';
 const OPTIONS = ['helpful', 'unhelpful'];
 function options(layout) {
@@ -78,7 +79,7 @@ class FeedbackLayout extends _radio.default {
     super(Object.assign({
       className,
       templates: Object.assign({}, DEFAULT_TEMPLATES, templates),
-      field: _index.fields.feedback()
+      field: _clientSdkWorkflow.fields.feedback()
     }, options));
     if (options.text === false && options.icon === false) {
       throw new Error('At least one of options.text or options.icon must be enabled');

package/dist/cjs/layout/templates.js

@@ -22,14 +22,22 @@ exports.image = image;
 exports.imageBlock = imageBlock;
 exports.imageInfoBlock = imageInfoBlock;
 exports.indexBlock = indexBlock;
+exports.message = message;
+exports.messageAnswerBlock = messageAnswerBlock;
+exports.messageAuthor = messageAuthor;
+exports.messageQuestionBlock = messageQuestionBlock;
 exports.priceBlock = priceBlock;
 exports.product = product;
 exports.productInfoBlock = productInfoBlock;
 exports.question = question;
 exports.requiresImplementation = requiresImplementation;
+exports.thread = thread;
+exports.threadMenuBlock = threadMenuBlock;
 exports.titleBlock = titleBlock;
 exports.unimplemented = unimplemented;
 var _commons = require("@miso.ai/commons");
+var _clientSdkWorkflow = require("@miso.ai/client-sdk-workflow");
+var _svgs = require("../asset/svgs.js");
 var _constants = require("../constants.js");
 const _excluded = ["classSuffix", "role"];
 function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
@@ -55,6 +63,68 @@ function question(layout, state, data) {
   const [openTag, closeTag] = tagPair(layout, data);
   return `${openTag}${data.value || data.text || data}${closeTag}`;
 }
+
+// the <li> itself is the item: it carries the item role, the thread identity
+// and the item state — a thread item is not a link, so no anchor body (and
+// the wrapper div around it) is needed
+function thread(layout, state, data) {
+  const {
+    className,
+    templates
+  } = layout;
+  const threadId = (0, _clientSdkWorkflow.getThreadId)(data);
+  const threadIdAttr = threadId ? ` data-thread-id="${threadId}"` : '';
+  const unreadAttr = (0, _clientSdkWorkflow.isThreadUnread)(data) ? ' data-unread' : '';
+  const selectedAttr = data.selected ? ' data-selected' : '';
+  const title = (0, _commons.escapeHtml)(data.title || 'Untitled');
+  return `<li class="${className}__item" data-role="item"${threadIdAttr}${unreadAttr}${selectedAttr}><div class="${className}__title">${title}</div>${(templates.threadMenuBlock || threadMenuBlock)(layout, data)}</li>`;
+}
+function threadMenuBlock({
+  className
+}) {
+  return `<button type="button" class="${className}__menu-button" data-role="thread-menu-button" aria-label="Thread actions" aria-haspopup="menu">${(0, _svgs.getIcon)('dots-vertical')}</button>` + `<div class="${className}__menu" data-role="thread-menu" role="menu" hidden>` + `<button type="button" class="${className}__menu-item" data-role="thread-rename" role="menuitem">Rename</button>` + `<button type="button" class="${className}__menu-item ${className}__menu-item--danger" data-role="thread-delete" role="menuitem">Delete</button>` + `</div>`;
+}
+function message(layout, state, data) {
+  const {
+    className,
+    templates
+  } = layout;
+  return [`<div class="${className}__item-body" data-role="item">`, (templates.messageQuestionBlock || messageQuestionBlock)(layout, data), (templates.messageAnswerBlock || messageAnswerBlock)(layout, data), `</div>`].join('');
+}
+function messageQuestionBlock({
+  className
+}, message) {
+  const {
+    question
+  } = message;
+  const generatedBy = (0, _clientSdkWorkflow.getGeneratedBy)(message);
+  const author = messageAuthor(message);
+  // always rendered so it can be filled in place when the question text
+  // arrives later (the list renders incrementally); the authorship attrs
+  // drive the author label and the bubble color
+  const attrs = `${author ? ` data-author="${(0, _commons.escapeHtml)(author)}"` : ''}${generatedBy ? ` data-generated-by="${(0, _commons.escapeHtml)(generatedBy)}"` : ''}`;
+  return `<div class="${className}__question" data-role="question"${attrs}${question ? '' : ' hidden'}>${question ? (0, _commons.escapeHtml)(question) : ''}</div>`;
+}
+
+/**
+ * The author label of a message's question bubble: labeled only when the
+ * question was written by the answer-updates monitor — the user's own
+ * questions carry no label.
+ */
+function messageAuthor(message) {
+  return (0, _clientSdkWorkflow.getGeneratedBy)(message) === 'answer_update_monitor' ? 'Written by Miso' : undefined;
+}
+function messageAnswerBlock({
+  className
+}, {
+  answer
+}) {
+  // the content is left blank here: the layout fills it in a second pass
+  // (markdown -> HTML); a spinner shows while the answer body is still
+  // being fetched from the answers API
+  const content = answer === undefined ? `<div class="miso-loading" aria-label="Loading" data-role="loading"></div>` : '';
+  return `<div class="${className}__answer miso-markdown miso-circled-citation-index" data-role="answer">${content}</div>`;
+}
 function article(layout, state, data, meta) {
   const {
     templates

package/dist/cjs/layout/text/text.js

@@ -4,12 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _constants = require("../../constants.js");
 var _commons = require("@miso.ai/commons");
 var _template = _interopRequireDefault(require("../template.js"));
 const _excluded = ["className", "templates", "tag"];
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-const TYPE = 'text';
+const TYPE = _constants.LAYOUT_TYPE.TEXT;
 const DEFAULT_CLASSNAME = 'miso-text';
 function root(layout, state) {
   const {

package/dist/cjs/layout/text/typewriter/index.js

@@ -12,7 +12,7 @@ var _utils = require("./utils.js");
 const _excluded = ["className", "tag", "format", "tooltip", "speed", "acceleration", "nextCursorFn"];
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-const TYPE = 'typewriter';
+const TYPE = _constants.LAYOUT_TYPE.TYPEWRITER;
 const DEFAULT_CLASSNAME = 'miso-typewriter';
 class TypewriterLayout extends _progressive.default {
   static get type() {
@@ -72,10 +72,12 @@ class TypewriterLayout extends _progressive.default {
     }
   }
   async _setupForMarkdown() {
-    const context = await this._view._views._extensions.require('markdown');
+    const client = this._view.workflow._client;
+    const plugin = await TypewriterLayout.MisoClient.plugins.install('std:ui-markdown');
     if (!this._view) {
       return; // destroyed
     }
+    const context = plugin.getContext(client);
     const cursorClass = (0, _utils.cursorClassName)(this.className);
     const {
       onDebug,

package/dist/cjs/plugin.js

@@ -5,15 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _commons = require("@miso.ai/commons");
-var _index = require("./workflow/index.js");
-var _index2 = require("./combo/index.js");
+var _clientSdkWorkflow = require("@miso.ai/client-sdk-workflow");
+var _defaults = require("./defaults.js");
+var _index = require("./combo/index.js");
 var _layouts = _interopRequireDefault(require("./layouts.js"));
 var elements = _interopRequireWildcard(require("./element/index.js"));
 var layouts = _interopRequireWildcard(require("./layout/index.js"));
-var sources = _interopRequireWildcard(require("./source.js"));
 var defaults = _interopRequireWildcard(require("./defaults/index.js"));
+var _templates = require("./defaults/ask/templates.js");
 var traits = _interopRequireWildcard(require("./trait/index.js"));
 var _styles = require("./styles.js");
+var _confirm = _interopRequireDefault(require("./util/confirm.js"));
+var _prompt = _interopRequireDefault(require("./util/prompt.js"));
 var _misoContainer = _interopRequireDefault(require("./element/container/miso-container.js"));
 var _misoContext = _interopRequireDefault(require("./element/context/miso-context.js"));
 var _misoCombo = _interopRequireDefault(require("./element/combo/miso-combo.js"));
@@ -29,23 +32,29 @@ class UiPlugin extends _commons.Component {
   constructor() {
     super('ui');
     this.layouts = new _layouts.default(this);
-    this._recommendations = new WeakMap();
-    this._explores = new WeakMap();
-    this._asks = new WeakMap();
-    this._extensions = new WeakMap();
     this._ready = new _commons.Resolution();
   }
-  async install(MisoClient, {
-    addSubtree,
-    addExtensionPoints
-  }) {
+  async install(MisoClient, context) {
+    const {
+      addSubtree,
+      addExtensionPoints
+    } = context;
+    this._pluginContext = context;
     addSubtree(this);
+
+    // make sure the workflow plugin is installed, then provide the layout
+    // registry and seed the default layout options
+    MisoClient.plugins.use(_clientSdkWorkflow.WorkflowPlugin);
+    context.workflows.plugin.setLayouts(this.layouts);
+    this._seedWorkflowDefaults(context.workflows.defaults);
     MisoClient.on('create', this._injectClient.bind(this));
 
     // the UI interface for MisoClient
     const ui = {
       defaults,
-      traits
+      traits,
+      confirm: _confirm.default,
+      prompt: _prompt.default
     };
     (0, _commons.delegateGetters)(ui, this, ['layouts', 'ready']);
     (0, _commons.defineValues)(this, {
@@ -96,70 +105,33 @@ class UiPlugin extends _commons.Component {
     await (0, _styles.loadStylesIfNecessary)();
     this._ready.resolve();
   }
-  async requireExtension(name) {
-    switch (name) {
-      case 'markdown':
-        return await this.MisoClient.plugins.install('std:ui-markdown');
-      default:
-        throw new Error(`Unknown extension: ${name}`);
-    }
-  }
   get ready() {
     return this._ready.promise;
   }
+
+  /**
+   * Seed the workflow plugin's defaults store with the presentational default
+   * options: layouts of each workflow, plus UI templates.
+   */
+  _seedWorkflowDefaults(workflowDefaults) {
+    for (const [name, layouts] of Object.entries(_defaults.defaultLayouts)) {
+      workflowDefaults.set(name, {
+        layouts
+      });
+    }
+    workflowDefaults.set('ask', {
+      templates: {
+        followUp: _templates.followUp
+      }
+    });
+  }
   _injectClient(client) {
     (0, _commons.defineValues)(client, {
       ui: new Ui(this, client)
     });
   }
-  _getExtensions(client) {
-    if (this._extensions.has(client)) {
-      return this._extensions.get(client);
-    }
-    const extensions = new Extensions(this, client);
-    this._extensions.set(client, extensions);
-    return extensions;
-  }
-  _getRecommendations(client) {
-    let recommendations = this._recommendations.get(client);
-    if (!recommendations) {
-      this._recommendations.set(client, recommendations = new _index.Recommendations(this, client));
-    }
-    return recommendations;
-  }
-  _getExplores(client) {
-    let explores = this._explores.get(client);
-    if (!explores) {
-      this._explores.set(client, explores = new _index.Explores(this, client));
-    }
-    return explores;
-  }
-  _getAsks(client) {
-    let asks = this._asks.get(client);
-    if (!asks) {
-      this._asks.set(client, asks = new _index.Asks(this, client));
-    }
-    return asks;
-  }
 }
-
-// TODO: are we able to eliminate the concept of extension, just use plugins?
 exports.default = UiPlugin;
-class Extensions {
-  constructor(plugin, client) {
-    this._plugin = plugin;
-    this._client = client;
-    this._contexts = {};
-  }
-  async require(name) {
-    if (this._contexts[name]) {
-      return this._contexts[name];
-    }
-    const plugin = await this._plugin.requireExtension(name);
-    const context = this._contexts[name] = plugin.getContext(this._client);
-    return context;
-  }
-}
 function createUiPluginContext(plugin, ui, MisoClient) {
   async function addElementClasses(...ElementClasses) {
     for (const ElementClass of ElementClasses) {
@@ -187,6 +159,9 @@ function createUiPluginContext(plugin, ui, MisoClient) {
   };
 }
 
+// workflow accessors delegated to client.workflows for backward compatibility
+const WORKFLOW_ACCESSORS = ['search', 'hybridSearch', 'asks', 'ask', 'explores', 'explore', 'recommendations', 'recommendation', 'sources'];
+
 /**
  * The UI interface for the client.
  */
@@ -194,43 +169,7 @@ class Ui {
   constructor(plugin, client) {
     this._plugin = plugin;
     this._client = client;
-    (0, _commons.defineValues)(this, {
-      sources: {
-        api: sources.api(client)
-      }
-    });
-  }
-  get recommendations() {
-    return this._recommendations || (this._recommendations = this._plugin._getRecommendations(this._client));
-  }
-  get recommendation() {
-    return this.recommendations.get(); // get default recommendation unit
-  }
-  get search() {
-    if (!this._search) {
-      this._search = new _index.Search(this._plugin, this._client);
-      this._client._events.emit('postworkflow', this._search);
-    }
-    return this._search;
-  }
-  get asks() {
-    return this._asks || (this._asks = this._plugin._getAsks(this._client));
-  }
-  get ask() {
-    return this.asks.root;
-  }
-  get hybridSearch() {
-    if (!this._hybridSearch) {
-      this._hybridSearch = new _index.HybridSearch(this._plugin, this._client);
-      this._client._events.emit('postworkflow', this._hybridSearch);
-    }
-    return this._hybridSearch;
-  }
-  get explores() {
-    return this._explores || (this._explores = this._plugin._getExplores(this._client));
-  }
-  get explore() {
-    return this.explores.get(); // get default explore unit
+    (0, _commons.delegateGetters)(this, client.workflows, WORKFLOW_ACCESSORS);
   }
   get ready() {
     return this._plugin.ready;
@@ -242,6 +181,6 @@ class Combo {
     this._MisoClient = MisoClient;
   }
   get ask() {
-    return this._ask || (this._ask = new _index2.AskCombo(this._plugin, this._MisoClient));
+    return this._ask || (this._ask = new _index.AskCombo(this._plugin, this._MisoClient));
   }
 }