@miso.ai/client-sdk-ui 1.10.3-beta.0 → 1.10.4-beta.0

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

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _constants = require("../constants.js");
+var _index2 = require("../layout/index.js");
+var _processors = require("./processors.js");
+const _excluded = ["q", "qs", "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 DEFAULT_API_OPTIONS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_API_OPTIONS, {
+  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'
+  }],
+  [_constants.ROLE.KEYWORDS]: [_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));
+const DEFAULT_OPTIONS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_OPTIONS, {
+  api: DEFAULT_API_OPTIONS,
+  layouts: DEFAULT_LAYOUTS,
+  trackers: DEFAULT_TRACKERS
+}));
+const ROLES_CONFIG = Object.freeze({
+  [_constants.ROLE.QUESTION]: {
+    mapping: _constants.ROLE.KEYWORDS
+  },
+  [_constants.ROLE.FACETS]: {
+    mapping: 'facet_counts'
+  }
+});
+class HybridSearch extends _answerBased.default {
+  constructor(plugin, client) {
+    super({
+      name: 'hybrid-search',
+      plugin,
+      client,
+      roles: Object.keys(DEFAULT_LAYOUTS),
+      rolesConfig: ROLES_CONFIG,
+      defaults: DEFAULT_OPTIONS
+    });
+  }
+  _initSubscriptions(args) {
+    super._initSubscriptions(args);
+    this._unsubscribes = [...this._unsubscribes, this._hub.on(_index.fields.filters(), filters => this._refine(filters))];
+  }
+
+  // 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
+      })
+    }));
+  }
+  _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 ');
+  }
+  _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
+  }
+
+  // data //
+  _defaultProcessData(data) {
+    data = super._defaultProcessData(data);
+    data = (0, _processors.writeKeywordsToData)(data);
+    data = instructPartialUpdates(data);
+    return data;
+  }
+}
+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
+  });
+}

package/dist/cjs/workflow/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "Explore", {
     return _explore.default;
   }
 });
+Object.defineProperty(exports, "HybridSearch", {
+  enumerable: true,
+  get: function () {
+    return _hybridSearch.default;
+  }
+});
 Object.defineProperty(exports, "Recommendations", {
   enumerable: true,
   get: function () {
@@ -28,6 +34,7 @@ Object.defineProperty(exports, "Search", {
   }
 });
 var _asks = _interopRequireDefault(require("./asks.js"));
+var _hybridSearch = _interopRequireDefault(require("./hybrid-search.js"));
 var _explore = _interopRequireDefault(require("./explore.js"));
 var _search = _interopRequireDefault(require("./search.js"));
 var _recommendations = _interopRequireDefault(require("./recommendations.js"));

package/dist/cjs/workflow/processors.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addDataInstructions = addDataInstructions;
+exports.removeDataInstructions = removeDataInstructions;
+exports.writeAnswerStageToMeta = writeAnswerStageToMeta;
+exports.writeDataStatus = writeDataStatus;
+exports.writeKeywordsToData = writeKeywordsToData;
+exports.writeMisoIdToMeta = writeMisoIdToMeta;
+var _commons = require("@miso.ai/commons");
+var _constants = require("../constants.js");
+const _excluded = ["_inst"];
+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; }
+function writeDataStatus(data) {
+  const status = getStatus(data);
+  const ongoing = status === _constants.STATUS.READY ? !!data.ongoing : undefined;
+  return (0, _commons.trimObj)(Object.assign({}, data, {
+    status,
+    ongoing
+  }));
+}
+function getStatus(data) {
+  if (!data) {
+    return _constants.STATUS.INITIAL;
+  }
+  const {
+    request,
+    error,
+    value
+  } = data;
+  return error ? _constants.STATUS.ERRONEOUS : value ? _constants.STATUS.READY : request ? _constants.STATUS.LOADING : _constants.STATUS.INITIAL;
+}
+function writeMisoIdToMeta(data) {
+  const {
+    value
+  } = data;
+  if (!value) {
+    return data;
+  }
+  const {
+    miso_id
+  } = value;
+  if (!miso_id) {
+    return data;
+  }
+  return Object.assign({}, data, {
+    meta: Object.assign({}, data.meta, {
+      miso_id
+    })
+  });
+}
+function writeKeywordsToData(data) {
+  const {
+    request,
+    value
+  } = data;
+  if (!request || !value) {
+    return data;
+  }
+  const {
+    payload
+  } = request || {};
+  const {
+    q: keywords
+  } = payload || {};
+  if (!keywords) {
+    return data;
+  }
+  return Object.assign({}, data, {
+    value: Object.assign({}, value, {
+      keywords
+    })
+  });
+}
+function writeAnswerStageToMeta(data) {
+  const {
+    value
+  } = data;
+  if (!value) {
+    return data;
+  }
+  const {
+    answer_stage
+  } = value;
+  if (!answer_stage) {
+    return data;
+  }
+  // 1. put answer_stage to meta
+  // 2. mark ongoing flag
+  return Object.assign({}, data, {
+    ongoing: !value.finished,
+    meta: Object.assign({}, data.meta, {
+      answer_stage
+    })
+  });
+}
+function addDataInstructions(data, instructions) {
+  if (!instructions) {
+    return data;
+  }
+  return Object.assign({
+    _inst: Object.assign({}, data._inst, instructions)
+  }, data);
+}
+function removeDataInstructions(data) {
+  if (typeof data !== 'object') {
+    return data;
+  }
+  const rest = _objectWithoutPropertiesLoose(data, _excluded);
+  return rest;
+}

package/dist/cjs/workflow/recommendation.js

@@ -35,13 +35,22 @@ class Recommendation extends _base.default {
       name: 'recommendation',
       context,
       roles: Object.keys(DEFAULT_LAYOUTS),
-      defaults: DEFAULT_OPTIONS
+      defaults: DEFAULT_OPTIONS,
+      id
     });
+  }
+  _initProperties(args) {
+    super._initProperties(args);
+    const {
+      id
+    } = args;
     (0, _commons.defineValues)(this, {
       id
     });
-    this._context = context;
-    context._members.set(id, this);
+  }
+  _initReset(args) {
+    this._context._members.set(args.id, this);
+    super._initReset(args);
   }
 
   // lifecycle //

package/dist/cjs/workflow/search.js

@@ -7,10 +7,10 @@ exports.default = void 0;
 var _commons = require("@miso.ai/commons");
 var _base = _interopRequireDefault(require("./base.js"));
 var _options = require("./options.js");
-var sources = _interopRequireWildcard(require("../source/index.js"));
-var _index2 = require("../actor/index.js");
+var sources = _interopRequireWildcard(require("../source.js"));
+var _index = require("../actor/index.js");
 var _constants = require("../constants.js");
-var _index3 = require("../layout/index.js");
+var _index2 = require("../layout/index.js");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
@@ -34,8 +34,8 @@ const DEFAULT_AUTOCOMPLETE_OPTIONS = Object.freeze({
   throttle: 300
 });
 const DEFAULT_LAYOUTS = Object.freeze({
-  [_constants.ROLE.QUERY]: _index3.SearchBoxLayout.type,
-  [_constants.ROLE.PRODUCTS]: _index3.ListLayout.type
+  [_constants.ROLE.QUERY]: _index2.SearchBoxLayout.type,
+  [_constants.ROLE.PRODUCTS]: _index2.ListLayout.type
 });
 const DEFAULT_TRACKERS = Object.freeze({
   [_constants.ROLE.PRODUCTS]: {}
@@ -55,11 +55,17 @@ class Search extends _base.default {
       roles: Object.keys(DEFAULT_LAYOUTS),
       defaults: DEFAULT_OPTIONS
     });
-    this._autocomplete = new _index2.AutocompleteActor(this._hub, {
+  }
+  _initActors(args) {
+    super._initActors(args);
+    this._autocomplete = new _index.AutocompleteActor(this._hub, {
       source: sources.api(this._client),
       options: this._options
     });
-    this._unsubscribes.push(this._hub.on(_index2.fields.query(), payload => this.query(payload)));
+  }
+  _initSubscriptions(args) {
+    super._initSubscriptions(args);
+    this._unsubscribes = [...this._unsubscribes, this._hub.on(_index.fields.query(), args => this._query(args))];
   }
 
   // lifecycle //
@@ -86,20 +92,36 @@ class Search extends _base.default {
       });
     }
   }
-  query(payload) {
+  query(args) {
+    if (!args.q) {
+      throw new Error(`q is required in query() call`);
+    }
+    this._hub.update(_index.fields.query(), args);
+  }
+  _query(args) {
+    // start a new session
     this.restart();
     const {
       session
     } = this;
-    this._hub.update(_index2.fields.request(), (0, _options.mergeApiOptions)(this._options.resolved.api, {
+
+    // build payload and trigger request
+    const payload = this._buildPayload(args);
+    const event = (0, _options.mergeApiOptions)(this._options.resolved.api, {
       payload,
       session
-    }));
-    return this;
+    });
+    this._request(event);
+  }
+  _buildPayload(args) {
+    return args;
+  }
+  _request(event) {
+    this._hub.update(_index.fields.request(), event);
   }
   updateCompletions(event) {
     // TODO: verify
-    this._hub.update(_index2.fields.completions(), Object.assign({}, event, {
+    this._hub.update(_index.fields.data(_constants.DATA_ASPECT.AUTOCOMPLETE), Object.assign({}, event, {
       source: 'manual'
     }));
     return this;

package/package.json

@@ -26,7 +26,7 @@
     "url": "https://github.com/MisoAI/miso-client-js-sdk/issues"
   },
   "dependencies": {
-    "@miso.ai/commons": "1.10.3-beta.0"
+    "@miso.ai/commons": "1.10.4-beta.0"
   },
-  "version": "1.10.3-beta.0"
+  "version": "1.10.4-beta.0"
 }

package/src/actor/autocomplete.js

@@ -1,4 +1,4 @@
-import { STATUS } from '../constants.js';
+import { STATUS, DATA_ASPECT } from '../constants.js';
 import * as fields from './fields.js';
 
 export default class AutocompleteActor {
@@ -9,6 +9,7 @@ export default class AutocompleteActor {
     this._options = options;
     this._index = -1;
 
+    // TODO: listen to request:input instead
     this._unsubscribes = [
       hub.on(fields.input(), () => this._sync()),
       options.on('autocomplete', () => this._syncOptions()),
@@ -104,7 +105,8 @@ export default class AutocompleteActor {
 
   _emitCompletions(event) {
     event.source = 'actor';
-    this._hub.update(fields.completions(), event);
+    // TDOO: update response:autocomplete instead
+    this._hub.update(fields.data(DATA_ASPECT.AUTOCOMPLETE), event);
   }
 
   _error(error) {

package/src/actor/data.js

@@ -50,8 +50,10 @@ export default class DataActor {
     const { session } = this._hub.states;
     const { session: _, ...request } = event;
 
-    // emit response to update request
-    this._emitResponse({ session, request });
+    if (!event._skipLoading) {
+      // emit response to update request
+      this._emitResponse({ session, request });
+    }
 
     try {
       const { signal } = this._ac || {};
@@ -59,6 +61,10 @@ export default class DataActor {
       const response = await this._source({ session, ...event, options });
       // takes an iterable, either sync or async
       if (response && response[Symbol.asyncIterator]) {
+        // also emit reponse of the head request, if available
+        if (response._response) {
+          this._emitResponseWithSessionCheck({ session, request, value: response._response });
+        }
         let value;
         for await (value of response) {
           // A new session invalidates ongoing data fetch for the old session, terminating the loop

package/src/actor/fields.js

@@ -6,20 +6,24 @@ export function suggestions() {
   return 'suggestions';
 }
 
+export function filters() {
+  return 'filters';
+}
+
 export function query() {
   return 'query';
 }
 
-export function request() {
-  return 'request';
+export function request(aspect) {
+  return aspect ? `request:${aspect}` : 'request';
 }
 
-export function response() {
-  return 'response';
+export function response(aspect) {
+  return aspect ? `response:${aspect}` : 'response';
 }
 
-export function data() {
-  return 'data';
+export function data(aspect) {
+  return aspect ? `data:${aspect}` : 'data';
 }
 
 export function view(role) {
@@ -45,7 +49,3 @@ export function feedback() {
 export function input() {
   return 'input';
 }
-
-export function completions() {
-  return 'completions';
-}

package/src/actor/filters.js

@@ -0,0 +1,103 @@
+import { EventEmitter, trimObj, defineValues } from '@miso.ai/commons';
+import * as fields from './fields.js';
+
+function mergeState(state = {}, update = {}) {
+  return Object.freeze(trimObj({
+    ...state,
+    ...update,
+    facets: Object.freeze(trimObj({
+      ...state.facets,
+      ...update.facets,
+    })),
+  }));
+}
+
+export default class Filters {
+
+  constructor(views, { facets: facetsOptions } = {}) {
+    this._views = views;
+    this._hub = views._hub;
+    this._states = this._initialStates = mergeState({}); // TODO: support custom initial states
+    const error = this._error = this._error.bind(this);
+    this._events = new EventEmitter({ target: this, error });
+    defineValues(this, { facets: new Facets(this, facetsOptions) });
+  }
+
+  get states() {
+    return this._states;
+  }
+
+  update(updates) {
+    const oldStates = this._states;
+    const states = this._states = mergeState({ ...this._states, ...updates });
+    this._events.emit('update', { updates, states, oldStates });
+  }
+
+  reset() {
+    const oldStates = this._states;
+    const states = this._states = this._initialStates;
+    this._events.emit('reset', { states, oldStates });
+  }
+
+  apply() {
+    this._hub.update(fields.filters(), this._states);
+    this._events.emit('apply');
+  }
+
+  _error(error) {
+    this._views._error(error);
+  }
+
+  _destroy() {}
+
+}
+
+class Facets {
+
+  constructor(filters, options = {}) {
+    this._filters = filters;
+    this._options = options;
+  }
+
+  isSelected(field, value) {
+    const state = this._filters._states.facets[field];
+    return state && state.includes(value);
+  }
+
+  select(field, value) {
+    if (this.isSelected(field, value)) {
+      return;
+    }
+    this._select(field, value);
+  }
+
+  unselect(field, value) {
+    if (!this.isSelected(field, value)) {
+      return;
+    }
+    this._unselect(field, value);
+  }
+
+  toggle(field, value) {
+    if (this.isSelected(field, value)) {
+      this._unselect(field, value);
+    } else {
+      this._select(field, value);
+    }
+  }
+
+  _select(field, value) {
+    const values = this._options.multiple ? [...(this._filters._states.facets[field] || []), value] : [value];
+    values.sort();
+    this._filters.update({ facets: { [field]: values } });
+  }
+
+  _unselect(field, value) {
+    let values = this._filters._states.facets[field].filter(v => v !== value);
+    if (values.length === 0) {
+      values = undefined;
+    }
+    this._filters.update({ facets: { [field]: values } });
+  }
+
+}

package/src/actor/hub.js

@@ -1,4 +1,5 @@
 import { defineValues, EventEmitter } from '@miso.ai/commons';
+import { removeDataInstructions } from '../workflow/processors.js';
 
 export default class Hub {
 
@@ -13,7 +14,7 @@ export default class Hub {
   }
 
   update(name, state, { silent = false } = {}) {
-    this._states[name] = Object.freeze(state);
+    this._states[name] = Object.freeze(removeDataInstructions(state));
     if (!silent) {
       this._events.emit(name, state);
     }

package/src/actor/sessions.js

@@ -32,13 +32,12 @@ export default class SessionMaker {
   }
 
   restart() {
-    this.new({ force: true });
-    this.start();
+    this._hub.update(fields.session(), this._create(true));
   }
 
-  _create() {
+  _create(active = false) {
     return Object.freeze({
-      active: false,
+      active,
       uuid: uuidv4(),
       index: this._sessionIndex++,
       meta: {},

package/src/actor/view.js

@@ -22,6 +22,7 @@ export default class ViewActor {
   constructor(views, role) {
     this._events = new EventEmitter({ target: this });
     this._views = views;
+    this._config = views._rolesConfig[role] || {};
 
     defineValues(this, {
       role,
@@ -101,6 +102,10 @@ export default class ViewActor {
     return this._tracker;
   }
 
+  get filters() {
+    return this._views.filters;
+  }
+
   async refresh({ force = false, data } = {}) {
     // protocol: no reaction when layout is absent
     if (!this._layout) {
@@ -155,9 +160,10 @@ export default class ViewActor {
     return this._views._getTrackerOptions(this.role);
   }
 
-  _sliceData({ value, error, status, meta, ...rest }) {
+  _sliceData(data) {
+    const { value, error, status, meta, ...rest } = data;
     const sliced = {
-      value: this.role === ROLE.ERROR ? error : (value && value[this.role]),
+      value: asMappingFunction(this._config.mapping || this.role)(data),
       status,
       data: value,
       meta,
@@ -230,3 +236,14 @@ class View {
   }
 
 }
+
+function asMappingFunction(fn) {
+  switch (typeof fn) {
+    case 'function':
+      return fn;
+    case 'string':
+      return data => data.value && data.value[fn];
+    default:
+      throw new Error(`Invalid mapping function: ${fn}`);
+  }
+}