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

package/dist/cjs/workflow/ask.js

@@ -9,9 +9,9 @@ var _answerBased = _interopRequireDefault(require("./answer-based.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"];
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _objectDestructuringEmpty(t) { if (null == t) throw new TypeError("Cannot destructure " + t); }
 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.QUESTIONS,
@@ -20,6 +20,11 @@ const DEFAULT_API_OPTIONS = Object.freeze(Object.assign({}, _answerBased.default
   })
 }));
 const DEFAULT_LAYOUTS = Object.freeze(Object.assign({}, _answerBased.default.DEFAULT_LAYOUTS, {
+  [_constants.ROLE.QUERY]: [_index2.SearchBoxLayout.type, {
+    templates: {
+      buttonIcon: 'send'
+    }
+  }],
   [_constants.ROLE.RELATED_RESOURCES]: [_index2.ListLayout.type, {
     incremental: true,
     itemType: 'article'
@@ -39,12 +44,13 @@ const DEFAULT_OPTIONS = Object.freeze(Object.assign({}, _answerBased.default.DEF
   layouts: DEFAULT_LAYOUTS,
   trackers: DEFAULT_TRACKERS
 }));
+const ROLES_OPTIONS = _answerBased.default.ROLES_OPTIONS;
 class Ask extends _answerBased.default {
   constructor(context, parentQuestionId) {
     super({
       name: 'ask',
       context,
-      roles: Object.keys(DEFAULT_LAYOUTS),
+      roles: ROLES_OPTIONS,
       defaults: DEFAULT_OPTIONS,
       parentQuestionId
     });
@@ -69,6 +75,7 @@ class Ask extends _answerBased.default {
     if (!previous) {
       return;
     }
+    // TODO: write question_source from payload._meta, so we don't need to write it to session.meta
     const values = previous.states[_index.fields.data()].value;
     const value = values.suggested_followup_questions || values.followup_questions || [];
     this._hub.update(_index.fields.suggestions(), {
@@ -77,11 +84,11 @@ class Ask extends _answerBased.default {
       }))
     });
   }
-  _initReset(args) {
+  _initSession(args) {
     // register at context
     args.parentQuestionId && this._context._byPqid.set(args.parentQuestionId, this);
     this._context._events.emit('create', this);
-    super._initReset(args);
+    super._initSession(args);
   }
 
   // lifecycle //
@@ -139,31 +146,32 @@ class Ask extends _answerBased.default {
   }
 
   // interactions //
-  _preprocessInteraction(payload) {
-    payload = super._preprocessInteraction(payload) || {};
-    const {
-      context = {}
-    } = payload;
-    const _ref2 = context.custom_context || {},
-      custom_context = Object.assign({}, (_objectDestructuringEmpty(_ref2), _ref2));
+  _writeAskPropertiesToInteraction(payload, args) {
+    const root_question_id = this.rootQuestionId;
     let {
-      rootQuestionId,
-      parentQuestionId,
-      questionId
-    } = this;
-    if (custom_context.property === _constants.ROLE.QUERY_SUGGESTIONS) {
-      questionId = parentQuestionId;
-      parentQuestionId = this.previous && this.previous.parentQuestionId;
-      custom_context.property = 'suggested_followup_questions';
-      custom_context.question_source = this.previous && this.previous.session.meta.question_source;
+      property
+    } = payload.context && payload.context.custom_context || {};
+    let question_id, parent_question_id, question_source;
+    if (args.role === _constants.ROLE.QUERY_SUGGESTIONS) {
+      property = 'suggested_followup_questions';
+      parent_question_id = this.previous && this.previous.parentQuestionId;
+      question_id = this.parentQuestionId;
+      question_source = this.previous && this.previous.session.meta.question_source;
+    } else {
+      parent_question_id = this.parentQuestionId;
+      question_id = this.questionId;
+      question_source = this._getQuestionSourceFromViewState(args);
     }
-    custom_context.question_id = questionId;
-    custom_context.root_question_id = rootQuestionId;
-    custom_context.parent_question_id = parentQuestionId;
-    return Object.assign({}, payload, {
-      context: Object.assign({}, context, {
-        custom_context: (0, _commons.trimObj)(custom_context)
-      })
+    return (0, _processors.mergeInteraction)(payload, {
+      context: {
+        custom_context: {
+          property,
+          root_question_id,
+          parent_question_id,
+          question_id,
+          question_source
+        }
+      }
     });
   }
 

package/dist/cjs/workflow/asks.js

@@ -66,7 +66,7 @@ class Asks extends _context.default {
 
     // reset root workflow
     if (root) {
-      this._root.reset();
+      this._root.restart();
     }
   }
 }

package/dist/cjs/workflow/autocompletable.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AutocompletableMixin = void 0;
+exports.makeAutocompletable = makeAutocompletable;
+var _commons = require("@miso.ai/commons");
+var _index = require("../actor/index.js");
+var _autocomplete = _interopRequireDefault(require("./autocomplete.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function makeAutocompletable(prototype) {
+  (0, _commons.mixin)(prototype, AutocompletableMixin.prototype);
+}
+class AutocompletableMixin {
+  _initAutocomplete(args) {
+    this._autocomplete = new _autocomplete.default(this, {
+      defaults: args.defaults.autocomplete
+    });
+  }
+  get autocomplete() {
+    return this._autocomplete;
+  }
+  updateCompletions(data) {
+    this._hub.update(_index.fields.completions(), data);
+    return this;
+  }
+  _destroyAutocomplete() {
+    this._autocomplete && this._autocomplete._destroy();
+    this._autocomplete = undefined;
+  }
+}
+exports.AutocompletableMixin = AutocompletableMixin;

package/dist/cjs/workflow/autocomplete.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../constants.js");
+var _index = require("../actor/index.js");
+var _base = _interopRequireDefault(require("./base.js"));
+const _excluded = ["layouts", "trackers"],
+  _excluded2 = ["defaults"];
+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 = Object.freeze({
+  members: []
+});
+function shimDefaults() {
+  let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let options = _objectWithoutPropertiesLoose(_ref, _excluded);
+  return Object.assign({
+    active: false
+  }, options, {
+    layouts: {},
+    trackers: {}
+  });
+}
+function sameInputValue(a, b) {
+  return getInputValue(a) === getInputValue(b);
+}
+function getInputValue(args) {
+  return args && args.value && args.value.trim() || undefined;
+}
+class Autocomplete extends _base.default {
+  constructor(superworkflow) {
+    let _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let {
+        defaults
+      } = _ref2,
+      args = _objectWithoutPropertiesLoose(_ref2, _excluded2);
+    super(Object.assign({
+      name: 'autocomplete',
+      plugin: superworkflow._plugin,
+      client: superworkflow._client,
+      defaults: shimDefaults(defaults),
+      roles: ROLES_OPTIONS,
+      superworkflow
+    }, args));
+  }
+  _initProperties(args) {
+    super._initProperties(args);
+    this._superworkflow = args.superworkflow;
+    this._active = args.defaults.active;
+  }
+  _initSubscriptions(args) {
+    // TODO: how to sync options updates
+    super._initSubscriptions(args);
+    this._unsubscribes = [...this._unsubscribes, args.superworkflow._hub.on(_index.fields.input(), args => this._query(args))];
+  }
+
+  // API //
+  get enabled() {
+    return this._active;
+  }
+  enable() {
+    this._active = true;
+  }
+  disable() {
+    this._active = false;
+  }
+
+  // query //
+  _query(args) {
+    if (!this._active || sameInputValue(args, this._args)) {
+      return;
+    }
+    this._args = args;
+
+    // start a new session
+    this.restart();
+    const {
+      session
+    } = this;
+    session.meta.input = args;
+
+    // if input value is blank, emit empty response
+    if (!getInputValue(args)) {
+      this._updateCompletions({
+        session,
+        status: _constants.STATUS.INITIAL
+      });
+      return;
+    }
+
+    // payload
+    const payload = this._buildPayload(args);
+
+    // request
+    this._request({
+      payload
+    });
+  }
+  _buildPayload(args) {
+    return {
+      q: getInputValue(args)
+    };
+  }
+
+  // data //
+  _updateDataInHub(data) {
+    if (data.value) {
+      data = Object.assign({}, data, {
+        value: data.value.completions
+      });
+    }
+    // update completion field in superworkflow hub
+    this._updateCompletions(data);
+  }
+  _updateCompletions(data) {
+    this._superworkflow.updateCompletions(data);
+  }
+}
+exports.default = Autocomplete;

package/dist/cjs/workflow/base.js

@@ -9,42 +9,47 @@ var _index = require("../actor/index.js");
 var sources = _interopRequireWildcard(require("../source.js"));
 var _constants = require("../constants.js");
 var _index2 = require("../layout/index.js");
-var _utils = require("./utils.js");
 var _options = require("./options.js");
 var _processors = require("./processors.js");
-const _excluded = ["layouts", "interactions"],
-  _excluded2 = ["custom_context"],
-  _excluded3 = ["context"];
 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 _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; }
+// TODO: just bury this into hub
+function injectLogger(hub, callback) {
+  const {
+    update,
+    trigger
+  } = hub;
+  hub.update = (name, state, options) => {
+    if (!options || !options.silent) {
+      callback('update', name, state, options);
+    }
+    return update.call(hub, name, state, options);
+  };
+  hub.trigger = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    callback('trigger', ...args);
+    return trigger.apply(hub, args);
+  };
+  return hub;
+}
+const DEFAULT_API_OPTIONS = Object.freeze({});
 const DEFAULT_LAYOUTS = Object.freeze({
   [_constants.ROLE.CONTAINER]: _index2.ContainerLayout.type,
   [_constants.ROLE.ERROR]: _index2.ErrorLayout.type
 });
-const ROLES_CONFIG = Object.freeze({
-  [_constants.ROLE.ERROR]: {
-    mapping: data => data.error
+const DEFAULT_TRACKERS = Object.freeze({});
+const DEFAULT_OPTIONS = Object.freeze({
+  api: DEFAULT_API_OPTIONS,
+  layouts: DEFAULT_LAYOUTS,
+  trackers: DEFAULT_TRACKERS
+});
+const ROLES_OPTIONS = Object.freeze({
+  mappings: {
+    [_constants.ROLE.ERROR]: data => data.error
   }
 });
-function mergeDefaults(workflow) {
-  let _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  let {
-      layouts,
-      interactions
-    } = _ref,
-    defaults = _objectWithoutPropertiesLoose(_ref, _excluded);
-  const DEFAULT_INTERACTIONS = {
-    preprocess: [payload => workflow._preprocessInteraction(payload)]
-  };
-  return Object.assign({}, defaults, {
-    layouts: (0, _options.mergeLayoutsOptions)(DEFAULT_LAYOUTS, layouts),
-    interactions: (0, _options.mergeInteractionsOptions)(DEFAULT_INTERACTIONS, interactions)
-  });
-}
-function getRevision(data) {
-  return data && data.value && data.value.revision;
-}
 class Workflow extends _commons.Component {
   constructor(args) {
     var _this;
@@ -53,7 +58,8 @@ class Workflow extends _commons.Component {
     let {
       context,
       plugin,
-      client
+      client,
+      options
     } = args;
     this._context = context;
     this._plugin = plugin = plugin || context._plugin;
@@ -64,23 +70,25 @@ class Workflow extends _commons.Component {
     }));
     this._name = args.name;
     this._roles = args.roles;
-    this._rolesConfig = Object.assign({}, ROLES_CONFIG, args.rolesConfig);
     this._extensions = plugin._getExtensions(client);
-    this._options = new _options.WorkflowOptions(context && context._options, mergeDefaults(this, args.defaults));
-    this._hub = (0, _utils.injectLogger)(new _index.Hub(), function () {
+    this._defaults = args.defaults;
+    this._options = options || new _options.WorkflowOptions(context && context._options, args.defaults);
+    this._hub = injectLogger(new _index.Hub(), function () {
       return _this._log(...arguments);
     });
     this._initProperties(args);
     this._initActors(args);
     this._initSubscriptions(args);
-    this._initReset(args);
+    this._initSession(args);
   }
   _initProperties() {}
-  _initActors() {
+  _initActors(_ref) {
+    let {
+      name,
+      roles
+    } = _ref;
     const hub = this._hub;
     const client = this._client;
-    const roles = this._roles;
-    const rolesConfig = this._rolesConfig;
     const options = this._options;
     const extensions = this._extensions;
     const layouts = this._plugin.layouts;
@@ -93,32 +101,31 @@ class Workflow extends _commons.Component {
       extensions,
       layouts,
       roles,
-      rolesConfig,
       options,
-      workflow: this._name
+      workflow: name
     });
     this._interactions = new _index.InteractionsActor(hub, {
       client,
       options
     });
   }
-  _initSubscriptions() {
-    this._unsubscribes = [this._hub.on(_index.fields.response(), data => this.updateData(data))];
+  _initSubscriptions(_ref2) {
+    let {
+      roles
+    } = _ref2;
+    this._unsubscribes = [this._hub.on(_index.fields.response(), data => this.updateData(data)), this._hub.on(_index.fields.tracker(), args => this._onTracker(args))];
+    if (roles.main) {
+      this._unsubscribes.push(this._hub.on(_index.fields.view(roles.main), state => this._onMainViewUpdate(state)));
+    }
   }
-  _initReset() {
-    this.reset();
+  _initSession() {
+    this.restart();
   }
   get uuid() {
     return this.session && this.session.uuid;
   }
   get session() {
-    return this._hub.states.session;
-  }
-  get active() {
-    const {
-      session
-    } = this;
-    return !!session && session.active;
+    return this._hub.states[_index.fields.session()];
   }
   get states() {
     return this._hub.states;
@@ -132,24 +139,58 @@ class Workflow extends _commons.Component {
   }
 
   // lifecycle //
-  reset() {
-    this._sessions.new();
-    return this;
-  }
-  start() {
-    this._sessions.start();
-    return this;
-  }
   restart() {
+    this._emitInterruptEventIfNecessary();
     this._sessions.restart();
     return this;
   }
+  _emitInterruptEventIfNecessary() {
+    const {
+      main
+    } = this._roles;
+    if (!main) {
+      return;
+    }
+    const state = this._hub.states[_index.fields.view(main)] || {};
+    if (state.session && state.status === _constants.STATUS.LOADING) {
+      // it's interrupted by a new question
+      this._emitLifecycleEvent('interrupt', state);
+      this._emitLifecycleEvent('finally', state);
+    }
+  }
+  _onMainViewUpdate(state) {
+    const {
+      status
+    } = state;
+    const done = status === _constants.STATUS.READY;
+    const erroneous = status === _constants.STATUS.ERRONEOUS;
+    const eventName = erroneous ? 'error' : status;
+    this._emitLifecycleEvent(eventName, state);
+    if (done) {
+      this._emitLifecycleEvent('done', state);
+    }
+    if (done || erroneous) {
+      this._emitLifecycleEvent('finally', state);
+    }
+  }
+  _emitLifecycleEvent(name, event) {
+    this._emit(name, event);
+  }
+
+  // request //
+  _request() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const {
+      session
+    } = this;
+    const event = (0, _options.mergeApiOptions)(this._options.resolved.api, Object.assign({}, options, {
+      session
+    }));
+    this._hub.update(_index.fields.request(), event);
+  }
 
-  // states //
+  // data //
   updateData(data) {
-    let {
-      instructions
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     if (!data) {
       throw new Error(`Data is required.`);
     }
@@ -167,42 +208,35 @@ class Workflow extends _commons.Component {
     }
 
     // compare revision to omit outdated data, if any
-    const revision = getRevision(data);
+    const revision = (0, _processors.getRevision)(data);
     if (!(0, _commons.isNullLike)(revision)) {
-      const currentRevision = getRevision(this._hub.states[_index.fields.data()]);
+      const currentRevision = (0, _processors.getRevision)(this._hub.states[_index.fields.data()]);
       if (!(0, _commons.isNullLike)(currentRevision) && revision <= currentRevision) {
         return;
       }
     }
-    this._sessions.start(); // in case session not started yet
-
-    data = (0, _processors.writeDataStatus)(data);
+    this._updateData(data);
+    return this;
+  }
+  _updateData(data) {
     data = this._defaultProcessData(data);
     for (const process of this._options.resolved.dataProcessor) {
       data = process(data);
     }
-
-    // write data instructions from function args
-    data = (0, _processors.addDataInstructions)(data, instructions);
-    data = this._mergeDataIfNecessary(data);
-    this._hub.update(_index.fields.data(), data);
-    return this;
+    this._updateDataInHub(data);
   }
   _defaultProcessData(data) {
-    return (0, _processors.writeMisoIdToMeta)(data);
+    data = (0, _processors.writeDataStatus)(data);
+    data = (0, _processors.writeMisoIdToMeta)(data);
+    return data;
   }
-  _mergeDataIfNecessary(data) {
-    if (!data._inst || !data._inst.merge) {
-      return data;
-    }
-    return Object.assign({}, this._hub.states[_index.fields.data()], data);
+  _updateDataInHub(data) {
+    this._hub.update(_index.fields.data(), data);
   }
-  _handleResponseObject() {}
 
   // TODO: notifyViewUpdateAll()
 
   notifyViewUpdate(role, state) {
-    this._assertActive();
     state = Object.assign({
       status: _constants.STATUS.READY,
       session: this.session
@@ -215,28 +249,59 @@ class Workflow extends _commons.Component {
   get trackers() {
     return this._views.trackers;
   }
-  _preprocessInteraction() {
-    let _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let {
-        context: {
-          custom_context
-        } = {}
-      } = _ref2,
-      context = _objectWithoutPropertiesLoose(_ref2.context, _excluded2),
-      payload = _objectWithoutPropertiesLoose(_ref2, _excluded3);
+  _onTracker(args) {
+    const payload = this._buildInteraction(args);
+    this._sendInteraction(payload);
+  }
+  _buildInteraction(args) {
+    let payload = (0, _processors.buildBaseInteraction)(args);
+    payload = this._defaultProcessInteraction(payload, args);
+    const {
+      preprocess = []
+    } = this._options.resolved.interactions;
+    for (const p of preprocess) {
+      payload = p(payload, args);
+    }
+    return payload;
+  }
+  _defaultProcessInteraction(payload, args) {
+    payload = this._writeApiInfoToInteraction(payload, args);
+    payload = this._writeMisoIdToInteraction(payload, args);
+    payload = (0, _processors.writeAffiliationInfoToInteraction)(payload, args);
+    return payload;
+  }
+  _writeApiInfoToInteraction(payload) {
     const {
-      group: api_group,
-      name: api_name
+      group,
+      name
     } = this._options.resolved.api;
-    return Object.assign({}, payload, {
-      context: Object.assign({}, context, {
-        custom_context: Object.assign({
-          api_group,
-          api_name
-        }, custom_context)
-      })
+    return (0, _processors.mergeInteraction)(payload, {
+      context: {
+        custom_context: {
+          api_group: group,
+          api_name: name
+        }
+      }
     });
   }
+  _writeMisoIdToInteraction(payload, args) {
+    // TODO: ad-hoc, try to pass info from tracker
+    const state = this._hub.states[_index.fields.view(args.role)] || {};
+    const miso_id = state.meta && state.meta.miso_id || undefined;
+    return miso_id ? (0, _processors.mergeInteraction)(payload, {
+      miso_id
+    }) : payload;
+  }
+  _sendInteraction(payload) {
+    const {
+      handle
+    } = this._options.resolved.interactions;
+    if (typeof handle === 'function') {
+      handle(payload);
+    } else {
+      this._hub.trigger(_index.fields.interaction(), payload);
+    }
+  }
 
   // destroy //
   destroy(options) {
@@ -271,11 +336,13 @@ class Workflow extends _commons.Component {
       }, data));
     }
   }
-  _assertActive() {
-    if (!this.active) {
-      throw new Error(`Unit is not active yet. Call unit.start() to activate it.`);
-    }
-  }
 }
 exports.default = Workflow;
-(0, _options.makeConfigurable)(Workflow.prototype);
+(0, _options.makeConfigurable)(Workflow.prototype);
+Object.assign(Workflow, {
+  DEFAULT_API_OPTIONS,
+  DEFAULT_LAYOUTS,
+  DEFAULT_TRACKERS,
+  DEFAULT_OPTIONS,
+  ROLES_OPTIONS
+});