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

package/src/workflow/ask.js

@@ -4,8 +4,9 @@ import { mergeApiOptions } from './options.js';
 import * as sources from '../source/index.js';
 import { fields, FeedbackActor, AutocompleteActor } from '../actor/index.js';
 import { ROLE, STATUS, ORGANIC_QUESTION_SOURCE } from '../constants.js';
-import { SearchBoxLayout, OptionListLayout, ListLayout, TextLayout, TypewriterLayout, FeedbackLayout } from '../layout/index.js';
+import { SearchBoxLayout, OptionListLayout, ListLayout, TextLayout, TypewriterLayout, FeedbackLayout, AffiliationLayout } from '../layout/index.js';
 import { makeConfigurable } from './options.js';
+import { processData as processAffiliationData } from '../affiliation/index.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({
   group: API.GROUP.ASK,
@@ -35,13 +36,14 @@ const DEFAULT_LAYOUTS = Object.freeze({
   [ROLE.SOURCES]: [ListLayout.type, { incremental: true, itemType: 'article', templates: { ordered: true } }],
   [ROLE.RELATED_RESOURCES]: [ListLayout.type, { incremental: true, itemType: 'article' }],
   [ROLE.QUERY_SUGGESTIONS]: OptionListLayout.type,
+  [ROLE.AFFILIATION]: [AffiliationLayout.type, { incremental: true, itemType: 'affiliation', link: { rel: 'noopener nofollow' } }],
 });
 
 const DEFAULT_TRACKERS = Object.freeze({
   [ROLE.SOURCES]: {},
   [ROLE.RELATED_RESOURCES]: {},
+  [ROLE.AFFILIATION]: {},
   [ROLE.QUERY_SUGGESTIONS]: {
-    active: true, // we are tracking events at initial stage, when session is not active yet
     click: {
       validate: event => event.button === 0, // left click only
     },
@@ -207,6 +209,9 @@ export default class Ask extends Workflow {
       }
     }
 
+    // affiliation
+    data = processAffiliationData(data);
+
     // 1. put answer_stage to meta
     // 2. mark ongoing flag
     return {
@@ -288,7 +293,6 @@ export default class Ask extends Workflow {
       this._context._byQid.delete(questionId);
     }
     this._feedback._destroy();
-    this._autocomplete._destroy();
     super._destroy(options);
   }
 

package/src/workflow/base.js

@@ -47,8 +47,8 @@ export default class Workflow extends Component {
     this._sessions = new SessionMaker(hub);
     this._data = new DataActor(hub, { source: sources.api(client), options });
     const views = this._views = new ViewsActor(hub, { extensions, layouts, roles, options, workflow: name });
-    this._interactions = new InteractionsActor(hub, { client, options });
     this._trackers = new Trackers(hub, { views, options });
+    this._interactions = new InteractionsActor(hub, { client, options });
 
     this._unsubscribes = [
       this._hub.on(fields.response(), data => this.updateData(data)),

package/src/workflow/options.js

@@ -11,10 +11,14 @@ export function normalizeApiOptions([name, payload] = []) {
     payload = name;
     name = undefined;
   }
+  let group = undefined;
+  if (name && name.indexOf('/') !== -1) {
+    [group, name] = name.split('/');
+  }
   if ((name && typeof name !== 'string') || (payload !== undefined && typeof payload !== 'object')) {
     throw new Error(`Invalid arguments for useApi(): ${name}, ${payload}`);
   }
-  return trimObj({ name, payload });
+  return trimObj({ group, name, payload });
 }
 
 export function normalizeLayoutsOptions(options = {}) {

package/src/workflow/recommendation.js

@@ -53,6 +53,7 @@ export default class Recommendation extends Workflow {
     return this;
   }
 
+  // TODO: deprecate this
   startTracker() {
     this.useApi(false);
     this.useLayouts(false);

package/dist/cjs/util/tracker.js

@@ -1,348 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _commons = require("@miso.ai/commons");
-var _constants = require("../constants.js");
-var _bindings = require("./bindings.js");
-var _states = _interopRequireDefault(require("./states.js"));
-var _proxy = _interopRequireDefault(require("./proxy.js"));
-const _excluded = ["impression", "viewable", "click"],
-  _excluded2 = ["proxyElement", "element", "sessionId", "active", "bindings"];
-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.indexOf(n) >= 0) continue; t[n] = r[n]; } return t; }
-const {
-  IMPRESSION,
-  VIEWABLE,
-  CLICK
-} = _constants.EVENT_TYPE;
-const {
-  UNTRACKED,
-  TRACKING,
-  TRIGGERED
-} = _constants.TRACKING_STATUS;
-const DEFAULT_TRACKING_OPTIONS = Object.freeze({
-  impression: Object.freeze({}),
-  viewable: Object.freeze({
-    area: 0.5,
-    duration: 1000
-  }),
-  click: Object.freeze({
-    lenient: false
-  }),
-  watch: false
-});
-function mergeOptions(def, opt) {
-  // if opt is falsy then return false, merge otherwise
-  return !!opt && Object.assign({}, def, opt);
-}
-function normalizeOptions(options) {
-  if (options === false) {
-    return false; // turn off all tracking
-  }
-  if (options === true) {
-    options = {};
-  }
-  if (typeof options !== 'object') {
-    throw new Error(`Invalid options: ${options}`);
-  }
-  const {
-      impression = {},
-      viewable = {},
-      click = {}
-    } = options,
-    rest = _objectWithoutPropertiesLoose(options, _excluded);
-  return (0, _commons.trimObj)(Object.assign({}, DEFAULT_TRACKING_OPTIONS, rest, {
-    impression: mergeOptions(DEFAULT_TRACKING_OPTIONS.impression, impression),
-    viewable: mergeOptions(DEFAULT_TRACKING_OPTIONS.viewable, viewable),
-    click: mergeOptions(DEFAULT_TRACKING_OPTIONS.click, click)
-  }));
-}
-class Tracker {
-  constructor() {
-    let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let {
-        proxyElement,
-        element,
-        sessionId = 'default',
-        active = true,
-        bindings
-      } = _ref,
-      options = _objectWithoutPropertiesLoose(_ref, _excluded2);
-    this._events = new _commons.EventEmitter({
-      target: this
-    });
-    this._proxyElement = proxyElement || new _proxy.default(element);
-    this._getSessionId = typeof sessionId === 'function' ? sessionId : () => sessionId;
-    this._isActive = typeof active === 'function' ? active : () => active;
-    this._bindings = new _bindings.Bindings(bindings);
-    this._viewables = new WeakMap();
-    this._options = normalizeOptions(options);
-    this._unsubscribes = [this._proxyElement.on('click', event => this._handleClick(event)), this._proxyElement.on('element', () => this.refresh())];
-    this.refresh();
-  }
-  get active() {
-    return this._isActive();
-  }
-  config(options) {
-    this._options = normalizeOptions(options);
-  }
-  refresh() {
-    // refresh against root element
-    this._syncElement();
-    // refresh against view state
-    this._syncStates();
-    // refresh bindings
-    this._refreshBindings();
-  }
-  _syncStates() {
-    const sessionId = this._getSessionId();
-    if (!sessionId) {
-      return;
-    }
-    if (this._states && sessionId !== this._states.sessionId) {
-      this._retireStates();
-    }
-    if (!this._states && sessionId) {
-      this._states = new _states.default(sessionId);
-    }
-  }
-  impression(values, options) {
-    this._assertActive();
-    if (this._options && this._options.impression) {
-      this._trigger(IMPRESSION, values, Object.assign({
-        manual: true
-      }, options));
-    }
-  }
-  viewable(values, options) {
-    this._assertActive();
-    if (this._options && this._options.viewable) {
-      this._trigger(VIEWABLE, values, Object.assign({
-        manual: true
-      }, options));
-    }
-  }
-  click(values, options) {
-    this._assertActive();
-    if (this._options && this._options.click) {
-      this._trigger(CLICK, values, Object.assign({
-        manual: true
-      }, options));
-    }
-  }
-  _assertActive() {
-    if (!this._isActive()) {
-      throw new Error(`Tracker is not active.`);
-    }
-  }
-  getState(value) {
-    // TODO: do we have to be so precise?
-    return Object.freeze(Object.assign({
-      [CLICK]: this._proxyElement.current ? TRACKING : UNTRACKED
-    }, this._states.getFullState(value)));
-  }
-  _syncElement() {
-    this._proxyElement.sync({
-      silent: true
-    });
-    const element = this._proxyElement.current;
-    if (this._element === element) {
-      return;
-    }
-    // remove observer from old element
-    this._retireElement();
-
-    // add observer on new element
-    if (element) {
-      if (this._options && this._options.watch) {
-        // TODO: move to proxy element
-        this._mutationObserver = new MutationObserver(() => this.refresh());
-        this._mutationObserver.observe(element, {
-          childList: true,
-          subtree: true
-        });
-      }
-    }
-    this._element = element;
-  }
-  _retireElement() {
-    if (!this._element) {
-      return;
-    }
-    if (this._mutationObserver) {
-      this._mutationObserver.disconnect();
-      this._mutationObserver = undefined;
-    }
-    this._element = undefined;
-  }
-  _retireStates() {
-    const {
-      unbounds
-    } = this._bindings.unbindAll();
-    this._untrackViewables(unbounds);
-    this._states = undefined;
-  }
-  _refreshBindings() {
-    if (!this._states) {
-      return;
-    }
-    const element = this._proxyElement.current;
-    const {
-      bounds,
-      unbounds
-    } = this._bindings.refresh(element);
-    this._untrackViewables(unbounds);
-    this._trackImpressions(bounds);
-    this._trackViewables(bounds);
-  }
-
-  // impression //
-  _trackImpressions(bindings) {
-    const options = this._options && this._options.impression;
-    if (!options) {
-      return;
-    }
-    this._trigger(IMPRESSION, bindings.map(b => b.value), {
-      bindings
-    });
-  }
-
-  // viewable //
-  _trackViewables(bindings) {
-    const options = this._options && this._options.viewable;
-    if (!options) {
-      return;
-    }
-    for (const binding of bindings) {
-      this._trackViewableOnElement(binding);
-    }
-  }
-  async _trackViewableOnElement(binding) {
-    const {
-      value,
-      element
-    } = binding;
-    if (!value || !(0, _commons.isElement)(element) || this._viewables.has(element)) {
-      return;
-    }
-    // TODO: when element is replaced without proper unload...
-    const state = this._states.get(value, VIEWABLE);
-    if (state !== UNTRACKED) {
-      return;
-    }
-    this._states.set(value, VIEWABLE, TRACKING);
-    const {
-      area,
-      duration
-    } = this._options && this._options.viewable;
-    // abort signal
-    const ac = new AbortController();
-    const {
-      signal
-    } = ac;
-    this._viewables.set(element, {
-      ac
-    });
-    await (0, _commons.viewable)(element, {
-      area,
-      duration,
-      signal
-    });
-    this._viewables.delete(element);
-    this._trigger(VIEWABLE, [value], {
-      bindings: [binding]
-    });
-  }
-  _untrackViewableOnElement(_ref2) {
-    let {
-      value,
-      element
-    } = _ref2;
-    const viewable = this._viewables.get(element);
-    if (!viewable) {
-      return;
-    }
-    viewable.ac.abort();
-    this._viewables.delete(element);
-    const type = VIEWABLE;
-    if (this._states.get(value, type) === TRACKING) {
-      this._states.set(value, type, UNTRACKED);
-    }
-  }
-  _untrackViewables(bindings) {
-    for (const binding of bindings) {
-      this._untrackViewableOnElement(binding);
-    }
-  }
-
-  // click //
-  _handleClick(event) {
-    const options = this._options && this._options.click;
-    if (!options || !this._isActive()) {
-      return;
-    }
-    const binding = this._bindings.get(event.target);
-    if (!binding) {
-      return;
-    }
-
-    // TODO: refactor
-    if (typeof options.validate === 'function') {
-      if (!options.validate(event, binding)) {
-        return;
-      }
-    } else if (!options.lenient) {
-      // it must be a left click
-      if (event.button !== 0) {
-        return;
-      }
-      // event default must not be prevented
-      if (event.defaultPrevented) {
-        return;
-      }
-      // must go through a real link
-      if (!(0, _commons.findInAncestors)(event.target, element => element.tagName === 'A' && element.href || undefined)) {
-        return;
-      }
-    }
-    this._trigger(CLICK, [binding.value], {
-      bindings: [binding]
-    });
-  }
-  _trigger(event, values) {
-    let {
-      manual = false,
-      bindings
-    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    (0, _constants.validateEventType)(event);
-    if (!this._isActive()) {
-      return;
-    }
-
-    // ignore already triggered
-    values = this._states.untriggered((0, _commons.asArray)(values), event);
-    if (values.length === 0) {
-      return;
-    }
-    this._states.set(values, event, TRIGGERED);
-    this._events.emit(event, {
-      event,
-      values,
-      manual,
-      bindings
-    });
-  }
-  destroy() {
-    this._retireElement();
-    this._retireStates();
-    this._bindings._destroy();
-    for (const unsubscribe of this._unsubscribes) {
-      unsubscribe();
-    }
-    this._unsubscribes = [];
-  }
-}
-exports.default = Tracker;