@miso.ai/client-sdk-ui 1.11.0-beta.1 → 1.11.0-beta.11

package/dist/cjs/workflow/explore.js

@@ -6,18 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _commons = require("@miso.ai/commons");
 var _base = _interopRequireDefault(require("./base.js"));
-var _options = require("./options.js");
 var _index = require("../actor/index.js");
 var _constants = require("../constants.js");
 var _index2 = require("../layout/index.js");
+var _options = require("./options.js");
 const _excluded = ["value"];
 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 (e.includes(n)) continue; t[n] = r[n]; } return t; }
-const DEFAULT_API_OPTIONS = Object.freeze({
+const DEFAULT_API_OPTIONS = Object.freeze(Object.assign({}, _base.default.DEFAULT_API_OPTIONS, {
   group: _commons.API.GROUP.ASK,
   name: _commons.API.NAME.RELATED_QUESTIONS
-});
-const DEFAULT_LAYOUTS = Object.freeze({
+}));
+const DEFAULT_LAYOUTS = Object.freeze(Object.assign({}, _base.default.DEFAULT_LAYOUTS, {
   [_constants.ROLE.RELATED_QUESTIONS]: [_index2.ListLayout.type, {
     itemType: 'question',
     link: {
@@ -27,18 +27,22 @@ const DEFAULT_LAYOUTS = Object.freeze({
   [_constants.ROLE.QUERY]: [_index2.SearchBoxLayout.type, {
     placeholder: 'Ask a question'
   }]
-});
-const DEFAULT_TRACKERS = Object.freeze({
+}));
+const DEFAULT_TRACKERS = Object.freeze(Object.assign({}, _base.default.DEFAULT_TRACKERS, {
   [_constants.ROLE.RELATED_QUESTIONS]: {},
   [_constants.ROLE.CONTAINER]: {},
   [_constants.ROLE.QUERY]: {
     [_constants.EVENT_TYPE.SUBMIT]: {}
   }
-});
-const DEFAULT_OPTIONS = Object.freeze({
+}));
+const DEFAULT_OPTIONS = Object.freeze(Object.assign({}, _base.default.DEFAULT_OPTIONS, {
   api: DEFAULT_API_OPTIONS,
   layouts: DEFAULT_LAYOUTS,
   trackers: DEFAULT_TRACKERS
+}));
+const ROLES_OPTIONS = (0, _options.mergeRolesOptions)(_base.default.ROLES_OPTIONS, {
+  main: _constants.ROLE.RELATED_QUESTIONS,
+  members: Object.keys(DEFAULT_LAYOUTS)
 });
 class Explore extends _base.default {
   constructor(plugin, client) {
@@ -46,7 +50,7 @@ class Explore extends _base.default {
       name: 'explore',
       plugin,
       client,
-      roles: Object.keys(DEFAULT_LAYOUTS),
+      roles: ROLES_OPTIONS,
       defaults: DEFAULT_OPTIONS
     });
   }
@@ -57,7 +61,7 @@ class Explore extends _base.default {
   }
   _initSubscriptions(args) {
     super._initSubscriptions(args);
-    this._unsubscribes = [...this._unsubscribes, this._views.get(_constants.ROLE.RELATED_QUESTIONS).on('click', event => this._handleRelatedQuestionClick(event)), this._hub.on(_index.fields.query(), payload => this.query(payload))];
+    this._unsubscribes = [...this._unsubscribes, this._views.get(_constants.ROLE.RELATED_QUESTIONS).on('click', event => this._handleRelatedQuestionClick(event)), this._hub.on(_index.fields.query(), args => this._submit(args))];
   }
 
   // configuration //
@@ -89,21 +93,18 @@ class Explore extends _base.default {
     let {
       relatedQuestions = true
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    if (relatedQuestions && this._linkFn === undefined) {
+    if (this._linkFn === undefined) {
       throw new Error('Define link mapping function before calling start()');
     }
-    this._sessions.start();
     // in explore workflow, start() triggers query
     // TODO: we should still make the query lifecycle
-    const {
-      session
-    } = this;
     if (relatedQuestions) {
-      this._hub.update(_index.fields.request(), (0, _options.mergeApiOptions)(this._options.resolved.api, {
-        session
-      }));
+      this._request();
     } else {
       // TODO: ad-hoc
+      const {
+        session
+      } = this;
       this.updateData({
         session,
         request: {},
@@ -152,7 +153,13 @@ class Explore extends _base.default {
       question
     })));
   }
-  query() {
+  query(args) {
+    if (!args.q) {
+      throw new Error(`q is required in query() call`);
+    }
+    this._hub.update(_index.fields.query(), args);
+  }
+  _submit() {
     let {
       q
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

package/dist/cjs/workflow/hybrid-search-answer.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _answerBased = _interopRequireDefault(require("./answer-based.js"));
+var _constants = require("../constants.js");
+var _options = require("./options.js");
+var _processors = require("./processors.js");
+var _autocompletable = require("./autocompletable.js");
+const _excluded = ["q", "qs"];
+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 (e.includes(n)) continue; t[n] = r[n]; } return t; }
+const ROLES_OPTIONS = (0, _options.mergeRolesOptions)(_answerBased.default.ROLES_OPTIONS, {
+  mappings: {
+    [_constants.ROLE.QUESTION]: _constants.ROLE.KEYWORDS
+  }
+});
+class HybridSearchAnswer extends _answerBased.default {
+  constructor(superworkflow) {
+    super({
+      name: 'hybrid-search/answer',
+      plugin: superworkflow._plugin,
+      client: superworkflow._client,
+      options: superworkflow._options,
+      defaults: superworkflow._defaults,
+      roles: ROLES_OPTIONS,
+      superworkflow
+    });
+  }
+  _initProperties(args) {
+    super._initProperties(args);
+    this._initAutocomplete(args);
+    this._superworkflow = args.superworkflow;
+  }
+  _initSession() {} // no reset here, will manually reset later
+
+  restart() {
+    super.restart();
+    // cascade restart to the sibling
+    const results = this._superworkflow._results;
+    results._views.filters.reset();
+    results.restart();
+    this._resultsSession = results.session; // keep track of the session
+  }
+
+  // query //
+  _buildPayload() {
+    let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let {
+        q,
+        qs
+      } = _ref,
+      payload = _objectWithoutPropertiesLoose(_ref, _excluded);
+    return Object.assign({}, payload, {
+      q,
+      // q, not question
+      _meta: Object.assign({}, payload._meta, {
+        question_source: qs || _constants.ORGANIC_QUESTION_SOURCE // might be null, not undefined
+      })
+    });
+  }
+
+  // data //
+  _defaultProcessData(data) {
+    data = super._defaultProcessData(data);
+    data = (0, _processors.writeKeywordsToData)(data);
+    return data;
+  }
+  _updateDataInHub(data) {
+    switch (data.status) {
+      case _constants.STATUS.INITIAL:
+      case _constants.STATUS.LOADING:
+        // share the initial/loading status with its sibling
+        this._dispatchDataToSibling(data);
+        break;
+    }
+    super._updateDataInHub(data);
+  }
+  _handleHeadResponse(data) {
+    super._handleHeadResponse(data);
+    // share the search results with its sibling
+    this._dispatchDataToSibling(data);
+  }
+  _dispatchDataToSibling(data) {
+    this._resultsSession && this._superworkflow._results.updateData(Object.assign({}, data, {
+      session: this._resultsSession
+    }));
+  }
+
+  // destroy //
+  _destroy(options) {
+    this._destroyAutocomplete();
+    super._destroy(options);
+  }
+}
+exports.default = HybridSearchAnswer;
+(0, _autocompletable.makeAutocompletable)(HybridSearchAnswer.prototype);

package/dist/cjs/workflow/hybrid-search-results.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _commons = require("@miso.ai/commons");
+var _searchBased = _interopRequireDefault(require("./search-based.js"));
+var _index = require("../actor/index.js");
+var _constants = require("../constants.js");
+var _options = require("./options.js");
+const _excluded = ["filters"];
+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 (e.includes(n)) continue; t[n] = r[n]; } return t; }
+const ROLES_OPTIONS = (0, _options.mergeRolesOptions)(_searchBased.default.ROLES_OPTIONS, {
+  members: [_constants.ROLE.PRODUCTS, _constants.ROLE.KEYWORDS, _constants.ROLE.TOTAL, _constants.ROLE.FACETS, _constants.ROLE.MORE]
+});
+class HybridSearchResults extends _searchBased.default {
+  constructor(superworkflow) {
+    super({
+      name: 'hybrid-search/results',
+      plugin: superworkflow._plugin,
+      client: superworkflow._client,
+      options: superworkflow._options,
+      defaults: superworkflow._defaults,
+      roles: ROLES_OPTIONS,
+      superworkflow
+    });
+  }
+  _initProperties(args) {
+    super._initProperties(args);
+    this._superworkflow = args.superworkflow;
+  }
+  _initSession() {} // no reset here, will manually reset later
+
+  // lifecycle //
+  _emitLifecycleEvent(name, event) {
+    super._emitLifecycleEvent(name, event);
+    this._superworkflow._emitLifecycleEvent(name, event);
+  }
+
+  // query //
+  _getQuery() {
+    // get stored query from sibling
+    return this._superworkflow._answer._hub.states[_index.fields.query()];
+  }
+  _buildPayload() {
+    let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let payload = _objectWithoutPropertiesLoose(_ref, _excluded);
+    // borrow the work from the sibling
+    payload = this._superworkflow._answer._buildPayload(payload);
+    payload = _searchBased.default.prototype._buildPayload.call(this, payload);
+    payload = this._writeQuestionIdToPayload(payload);
+    return Object.assign({}, payload, {
+      answer: false
+    });
+  }
+  _writeQuestionIdToPayload(payload) {
+    return Object.assign({}, payload, {
+      _meta: (0, _commons.trimObj)(Object.assign({}, payload._meta, {
+        question_id: this._superworkflow._answer.questionId
+      }))
+    });
+  }
+}
+exports.default = HybridSearchResults;

package/dist/cjs/workflow/hybrid-search-views.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../constants.js");
+function getSubworkflowByRole(role) {
+  // TODO: ROLE.ERROR
+  switch (role) {
+    case _constants.ROLE.PRODUCTS:
+    case _constants.ROLE.TOTAL:
+    case _constants.ROLE.FACETS:
+    case _constants.ROLE.KEYWORDS:
+    case _constants.ROLE.MORE:
+      return 'results';
+    default:
+      return 'answer';
+  }
+}
+class HybridSearchViewsActor {
+  constructor(workflow) {
+    this._workflow = workflow;
+    this._containers = new Set();
+  }
+  get(role) {
+    return this._getSubviews(role).get(role);
+  }
+  addContainer(element) {
+    if (this._containers.has(element)) {
+      return;
+    }
+    this._containers.add(element);
+    const {
+      components
+    } = element;
+    for (const component of components) {
+      this.addComponent(component);
+    }
+  }
+  removeContainer(element) {
+    for (const subworkflow of this._workflow._subworkflows) {
+      subworkflow._views.removeContainer(element);
+    }
+    this._containers.delete(element);
+  }
+  addComponent(element) {
+    this._getViewByElement(element).element = element;
+    this._addContainerToSubviews(element._container, element);
+  }
+  removeComponent(element) {
+    this._getViewByElement(element).element = undefined;
+    this._removeContainerFromSubviewsIfNecessary(element._container);
+  }
+  updateComponentRole(element, oldRole, newRole) {
+    // TODO
+  }
+  refreshElement(element) {
+    const view = element.isContainer ? this._containers.get(element) : this._getViewByElement(element);
+    view && view.refresh({
+      force: true
+    });
+  }
+
+  // helpers //
+  _getSubworkflow(role) {
+    return this._workflow._getSubworkflow(getSubworkflowByRole(role));
+  }
+  _getAllSubviews() {
+    return this._workflow._subworkflows.flatMap(subworkflow => subworkflow._views);
+  }
+  _getSubviews(role) {
+    return this._getSubworkflow(role)._views;
+  }
+  _getViewByElement(element) {
+    let {
+      role
+    } = element;
+    if (!role) {
+      throw new Error('Component must have a role');
+    }
+    return this.get(role);
+  }
+  _addContainerToSubviews(container, child) {
+    if (!container) {
+      return;
+    }
+    const {
+      role
+    } = child;
+    const subviews = this._getSubviews(role);
+    if (subviews._containers.has(container)) {
+      return;
+    }
+    // check if the container is in other subviews
+    for (const otherSubviews of this._getAllSubviews()) {
+      if (otherSubviews === subviews) {
+        continue;
+      }
+      if (otherSubviews._containers.has(container)) {
+        // find the conflicting element
+        for (const component of container.components) {
+          if (otherSubviews.containsElement(component)) {
+            throw new Error(`<${container.tagName}> cannot contain both <${component.tagName}> and <${child.tagName}>, for they don't share the same data lifecycle.`);
+          }
+        }
+        throw new Error(`Failed to add container <${container.tagName}> with child component <${child.tagName}>.`);
+      }
+    }
+    // add the container to the subviews
+    subviews.addContainer(container);
+  }
+  _removeContainerFromSubviewsIfNecessary(container) {
+    if (!container || container.components.length > 0) {
+      return;
+    }
+    for (const subviews of this._getAllSubviews()) {
+      subviews.removeContainer(container);
+    }
+  }
+}
+exports.default = HybridSearchViewsActor;

package/dist/cjs/workflow/hybrid-search.js

@@ -5,136 +5,131 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _commons = require("@miso.ai/commons");
-var _answerBased = _interopRequireDefault(require("./answer-based.js"));
-var _options = require("./options.js");
 var _index = require("../actor/index.js");
+var _base = _interopRequireDefault(require("./base.js"));
+var _searchBased = _interopRequireDefault(require("./search-based.js"));
+var _answerBased = _interopRequireDefault(require("./answer-based.js"));
 var _constants = require("../constants.js");
 var _index2 = require("../layout/index.js");
-var _processors = require("./processors.js");
-const _excluded = ["q", "qs", "filters"];
+var _hybridSearchAnswer = _interopRequireDefault(require("./hybrid-search-answer.js"));
+var _hybridSearchResults = _interopRequireDefault(require("./hybrid-search-results.js"));
+var _hybridSearchViews = _interopRequireDefault(require("./hybrid-search-views.js"));
 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 (e.includes(n)) continue; t[n] = r[n]; } return t; }
-const DEFAULT_API_OPTIONS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_API_OPTIONS, {
+const DEFAULT_API_OPTIONS = Object.freeze({
+  group: _commons.API.GROUP.ASK,
   name: _commons.API.NAME.SEARCH,
-  payload: Object.assign({}, _answerBased.default.DEFAULT_API_OPTIONS.payload)
-}));
-const DEFAULT_LAYOUTS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_LAYOUTS, {
-  [_constants.ROLE.PRODUCTS]: [_index2.ListLayout.type, {
-    itemType: 'article'
+  payload: Object.assign({}, _answerBased.default.DEFAULT_API_OPTIONS.payload, _searchBased.default.DEFAULT_API_OPTIONS.payload, {
+    source_fl: ['cover_image', 'url', 'created_at', 'updated_at', 'published_at', 'title']
+  })
+});
+const DEFAULT_LAYOUTS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_LAYOUTS, _searchBased.default.DEFAULT_LAYOUTS, {
+  [_constants.ROLE.QUERY]: [_index2.SearchBoxLayout.type, {
+    placeholder: ''
   }],
-  [_constants.ROLE.KEYWORDS]: [_index2.TextLayout.type, {
+  [_constants.ROLE.QUESTION]: [_index2.TextLayout.type, {
     raw: true
-  }],
-  [_constants.ROLE.HITS]: [_index2.TextLayout.type, {
-    raw: true,
-    format: 'number'
-  }],
-  [_constants.ROLE.FACETS]: [_index2.FacetsLayout.type]
+  }]
+}));
+const DEFAULT_TRACKERS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_TRACKERS, _searchBased.default.DEFAULT_TRACKERS));
+const DEFAULT_PAGINATION = Object.freeze(Object.assign({}, _searchBased.default.DEFAULT_PAGINATION, {
+  active: true
 }));
-const DEFAULT_TRACKERS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_TRACKERS));
-const DEFAULT_OPTIONS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_OPTIONS, {
+const DEFAULT_AUTOCOMPLETE_OPTIONS = Object.freeze({
+  api: {
+    group: _commons.API.GROUP.ASK,
+    name: _commons.API.NAME.SEARCH_AUTOCOMPLETE,
+    payload: {
+      completion_fields: ['suggested_queries']
+    }
+  }
+});
+const DEFAULT_OPTIONS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_OPTIONS, _searchBased.default.DEFAULT_OPTIONS, {
   api: DEFAULT_API_OPTIONS,
   layouts: DEFAULT_LAYOUTS,
-  trackers: DEFAULT_TRACKERS
+  trackers: DEFAULT_TRACKERS,
+  autocomplete: DEFAULT_AUTOCOMPLETE_OPTIONS,
+  pagination: DEFAULT_PAGINATION
 }));
-const ROLES_CONFIG = Object.freeze({
-  [_constants.ROLE.QUESTION]: {
-    mapping: _constants.ROLE.KEYWORDS
-  },
-  [_constants.ROLE.FACETS]: {
-    mapping: 'facet_counts'
-  }
+const ROLES_OPTIONS = Object.freeze({
+  main: _constants.ROLE.PRODUCTS,
+  members: Object.keys(DEFAULT_LAYOUTS),
+  mappings: Object.freeze(Object.assign({}, _answerBased.default.ROLES_OPTIONS.mappings, _searchBased.default.ROLES_OPTIONS.mappings))
 });
-class HybridSearch extends _answerBased.default {
+class HybridSearch extends _base.default {
   constructor(plugin, client) {
     super({
       name: 'hybrid-search',
       plugin,
       client,
-      roles: Object.keys(DEFAULT_LAYOUTS),
-      rolesConfig: ROLES_CONFIG,
+      roles: ROLES_OPTIONS,
       defaults: DEFAULT_OPTIONS
     });
   }
-  _initSubscriptions(args) {
-    super._initSubscriptions(args);
-    this._unsubscribes = [...this._unsubscribes, this._hub.on(_index.fields.filters(), filters => this._refine(filters))];
+  _initProperties(args) {
+    super._initProperties(args);
+    this._subworkflows = [this._answer = new _hybridSearchAnswer.default(this), this._results = new _hybridSearchResults.default(this)];
+  }
+  _getSubworkflow(name) {
+    switch (name) {
+      case 'answer':
+        return this._answer;
+      case 'results':
+        return this._results;
+      default:
+        throw new Error(`Invalid subworkflow: ${name}`);
+    }
+  }
+  _initActors() {
+    const hub = this._hub;
+    const client = this._client;
+    const options = this._options;
+    this._views = new _hybridSearchViews.default(this);
+    this._interactions = new _index.InteractionsActor(hub, {
+      client,
+      options
+    });
+  }
+  _initSession() {
+    this._results._sessions.restart();
+    this._answer._sessions.restart();
+  }
+
+  // configuration //
+  useLink(fn) {
+    this._answer.useLink(fn);
+    return this;
+  }
+
+  // properties //
+  get questionId() {
+    return this._answer.questionId;
+  }
+  get filters() {
+    return this._results._views.filters;
+  }
+  get autocomplete() {
+    return this._answer.autocomplete;
   }
 
   // query //
-  _buildPayload() {
-    let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let {
-        q,
-        qs,
-        filters
-      } = _ref,
-      payload = _objectWithoutPropertiesLoose(_ref, _excluded);
-    const fq = this._buildFq(filters); // TODO: combine with fq in payload?
-    return (0, _commons.trimObj)(Object.assign({}, payload, {
-      q,
-      // q, not question
-      fq,
-      _meta: Object.assign({}, payload._meta, {
-        question_source: qs || _constants.ORGANIC_QUESTION_SOURCE // might be null, not undefined
-      })
-    }));
+  autoQuery(options) {
+    this._answer.autoQuery(options);
   }
-  _buildFq(filters) {
-    if (!filters) {
-      return undefined;
-    }
-    const clauses = [];
-    const {
-      facets
-    } = filters;
-    for (const field in facets) {
-      const values = facets[field];
-      if (!values || !values.length) {
-        continue; // just in case
-      }
-      clauses.push(`${field}:(${values.map(v => `"${v}"`).join(' OR ')})`);
-    }
-    return clauses.map(c => `(${c})`).join(' AND ');
+  query(args) {
+    this._answer.query(args);
   }
-  _refine(filters) {
-    const query = this._hub.states[_index.fields.query()];
-    const payload = this._buildPayload(Object.assign({}, query, {
-      filters,
-      answer: false
-    }));
-    const {
-      session
-    } = this;
-    const event = (0, _options.mergeApiOptions)(this._options.resolved.api, {
-      payload,
-      session,
-      _skipLoading: true
-    });
-    this._request(event);
 
-    // emulate loading status exclusively for products
-    // TODO
+  // interactions //
+  _defaultProcessInteraction(payload, args) {
+    return this._answer._defaultProcessInteraction(payload, args);
   }
 
-  // data //
-  _defaultProcessData(data) {
-    data = super._defaultProcessData(data);
-    data = (0, _processors.writeKeywordsToData)(data);
-    data = instructPartialUpdates(data);
-    return data;
+  // destroy //
+  _destroy() {
+    for (const subworkflow of this._subworkflows) {
+      subworkflow.destroy();
+    }
+    super._destroy();
   }
 }
-exports.default = HybridSearch;
-function instructPartialUpdates(data) {
-  if (!data.value) {
-    return data;
-  }
-  return (0, _processors.addDataInstructions)(data, data.value.products ? {
-    includes: [_constants.ROLE.PRODUCTS, _constants.ROLE.HITS, _constants.ROLE.FACETS, _constants.ROLE.KEYWORDS, _constants.ROLE.QUESTION],
-    merge: true
-  } : {
-    excludes: [_constants.ROLE.PRODUCTS, _constants.ROLE.HITS, _constants.ROLE.FACETS],
-    merge: true
-  });
-}
+exports.default = HybridSearch;