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

package/dist/cjs/layout/trackable.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TrackableMixin = void 0;
+exports.makeTrackable = makeTrackable;
+var _constants = require("../constants.js");
+var _bindings = _interopRequireDefault(require("../util/bindings.js"));
+var _viewables = _interopRequireDefault(require("../util/viewables.js"));
+var _trackers = require("../util/trackers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function makeTrackable(prototype) {
+  _mixin(prototype, TrackableMixin.prototype);
+}
+function _mixin(target, source) {
+  const descriptors = Object.getOwnPropertyDescriptors(source);
+  for (const key in descriptors) {
+    if (key === 'constructor') {
+      continue;
+    }
+    const {
+      value
+    } = descriptors[key];
+    if (target[key] === undefined && typeof value === 'function') {
+      target[key] = value;
+    }
+    // TODO: getter, setter
+  }
+}
+class TrackableMixin {
+  _initTrackable() {
+    this._bindings = new _bindings.default();
+    this._viewables = new _viewables.default();
+  }
+  _syncBindings(element, state) {
+    const values = this._getItems(state) || [];
+    const keys = values.map(value => this._getItemKey(value));
+    const elements = this._getItemElements(element);
+    const {
+      bounds,
+      unbounds
+    } = this._bindings.update(keys, values, elements);
+    this._onBindingsUpdate(bounds, unbounds);
+  }
+  _clearBindings() {
+    const {
+      bounds,
+      unbounds
+    } = this._bindings.clear();
+    this._onBindingsUpdate(bounds, unbounds);
+  }
+  _getItemKey(value) {
+    // TODO: ad-hoc!
+    return value.product_id || value.text || value.id || value;
+  }
+  _getItems(state) {
+    throw new Error(`Not implemented.`);
+  }
+  _getItemElements(element) {
+    throw new Error(`Not implemented.`);
+  }
+  _onBindingsUpdate(bounds, unbounds) {
+    this._trackImpressions(bounds);
+    this._untrackViewables(unbounds);
+    this._trackViewables(bounds);
+  }
+  _trackImpressions(entries) {
+    if (entries.length === 0) {
+      return;
+    }
+    const {
+      impression: options
+    } = this._view.trackerOptions || {};
+    if (!options) {
+      return;
+    }
+    setTimeout(() => this._view._track(_constants.EVENT_TYPE.IMPRESSION, entries.map(_ref => {
+      let {
+        value
+      } = _ref;
+      return value;
+    })), 0);
+  }
+  _untrackViewables(entries) {
+    for (const {
+      element
+    } of entries) {
+      this._viewables.untrack(element);
+    }
+  }
+  _trackViewables(entries) {
+    if (entries.length === 0) {
+      return;
+    }
+    const {
+      viewable: options
+    } = this._view.trackerOptions || {};
+    if (!options) {
+      return;
+    }
+    for (const {
+      value,
+      element
+    } of entries) {
+      (async () => (await this._viewables.track(element, options)) && this._view._track(_constants.EVENT_TYPE.VIEWABLE, [value]))();
+    }
+  }
+  _trackClick(event, binding) {
+    const {
+      click: options
+    } = this._view.trackerOptions || {};
+    if ((0, _trackers.validateClick)(options, event, binding)) {
+      this._view._track(_constants.EVENT_TYPE.CLICK, [binding.value]);
+    }
+  }
+  _destroyTrackable() {
+    const {
+      unbounds
+    } = this._bindings.clear();
+    this._untrackViewables(unbounds);
+  }
+}
+exports.TrackableMixin = TrackableMixin;

package/dist/cjs/plugin.js

@@ -19,7 +19,7 @@ const _excluded = ["containers", "roles", "combos"];
 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 }; }
-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; }
+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 PLUGIN_ID = 'std:ui';
 class UiPlugin extends _commons.Component {
   static get id() {

package/dist/cjs/source/index.js

@@ -3,11 +3,23 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "api", {
-  enumerable: true,
-  get: function () {
-    return _api.default;
-  }
-});
-var _api = _interopRequireDefault(require("./api.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+exports.api = api;
+var _commons = require("@miso.ai/commons");
+//export { default as api } from './api.js';
+
+function api(client) {
+  // TODO: send uuid & unit id
+  return async _ref => {
+    let {
+      group,
+      name,
+      payload,
+      options
+    } = _ref;
+    if (group === _commons.API.GROUP.ASK && name === _commons.API.NAME.QUESTIONS) {
+      return client.api.ask.questions(payload, options);
+    }
+    // because name is in snake case
+    return client.api[group]._run(name, payload, options);
+  };
+}

package/dist/cjs/util/bindings.js

@@ -3,131 +3,79 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Bindings = void 0;
-exports.fallbackListFunction = fallbackListFunction;
-var _commons = require("@miso.ai/commons");
-function fallbackListFunction(keyAttrName) {
-  return element => Array.from(element.querySelectorAll(`[${keyAttrName}]`)).map(element => ({
-    element,
-    value: {
-      product_id: element.getAttribute(keyAttrName) // TODO: product_id is ad-hoc
+exports.default = void 0;
+function tuple(keys, values, elements) {
+  const k2b = new Map();
+  const e2b = new Map();
+  const entries = [];
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index];
+    const element = elements[index];
+    const value = values[index];
+    const entry = Object.freeze({
+      index,
+      key,
+      value,
+      element
+    });
+    k2b.set(key, entry);
+    e2b.set(element, entry);
+    entries.push(entry);
+  }
+  return {
+    k2b,
+    e2b,
+    entries
+  };
+}
+function diff(from, to) {
+  const entries = [];
+  for (const entry of to.entries) {
+    const f = from.e2b.get(entry.element);
+    if (!f || f.key !== entry.key) {
+      entries.push(entry);
     }
-  }));
+  }
+  return entries;
 }
 class Bindings {
   constructor() {
-    let {
-      keyAttrName = 'data-key',
-      list
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this._list = list || fallbackListFunction(keyAttrName);
-    this._bindings = new Map();
-    this._e2b = new WeakMap();
+    this._k2b = new Map();
+    this._e2b = new Map();
+    this._entries = [];
   }
-  list() {
-    return [...this._bindings.values()];
+  get entries() {
+    return [...this._entries];
   }
-  get(ref) {
-    if (!ref) {
-      throw new Error(`Value or element is required.`);
-    }
-    if (!this._root) {
-      return undefined;
-    }
-    if (!(0, _commons.isElement)(ref)) {
-      return this._bindings.get(ref);
-    }
-    return (0, _commons.findInAncestors)(ref, element => this._e2b.get(element) || undefined, {
-      root: this._root
-    });
+  get(element) {
+    return this._e2b.get(element) || undefined;
   }
-  refresh(rootElement) {
-    if (!rootElement) {
-      return this.unbindAll();
-    }
-    this._root = rootElement;
-    const unbounds = this._purge();
-    const bounds = [];
-    // warn for conflict productIds
-    // TODO
-    for (const pair of this._list(rootElement)) {
-      const [binding, ...ubs] = this._bind(pair);
-      if (binding) {
-        bounds.push(binding);
-      }
-      for (const u of ubs) {
-        unbounds.push(u);
-      }
-    }
+  update(keys, values, elements) {
+    const newTuple = tuple(keys, values, elements);
+    const oldTuple = {
+      k2b: this._k2b,
+      e2b: this._e2b,
+      entries: this._entries
+    };
+    const bounds = diff(oldTuple, newTuple);
+    const unbounds = diff(newTuple, oldTuple);
+    this._k2b = newTuple.k2b;
+    this._e2b = newTuple.e2b;
+    this._entries = newTuple.entries;
     return {
       bounds,
       unbounds
     };
   }
-  unbindAll() {
-    const unbounds = this.list();
-    this._bindings.clear();
-    this._root = undefined;
+  clear() {
+    const unbounds = this._entries;
+    this._k2b = new Map();
+    this._e2b = new Map();
+    this._entries = [];
     return {
       bounds: [],
       unbounds
     };
   }
-  _bind(_ref) {
-    let {
-      element,
-      key,
-      value
-    } = _ref;
-    key = key || value;
-    if (!key) {
-      throw new Error(`Key or value is required.`);
-    }
-    if (!element) {
-      throw new Error(`Element is required.`);
-    }
-
-    // check if binding already exist
-    const oldBinding = this._bindings.get(key);
-    if (oldBinding && oldBinding.element === element) {
-      return [];
-    }
-    const unbound0 = this._unbind(this.get(key));
-    const unbound1 = this._unbind(this.get(element));
-    const binding = Object.freeze({
-      key,
-      value,
-      element
-    });
-    this._bindings.set(key, binding);
-    this._e2b.set(element, binding);
-    const results = [binding];
-    unbound0 && results.push(unbound0);
-    unbound1 && results.push(unbound1);
-    return results;
-  }
-  _purge() {
-    const purged = [];
-    for (const binding of this._bindings.values()) {
-      const {
-        element
-      } = binding;
-      if ((0, _commons.isInDocument)(element)) {
-        continue;
-      }
-      purged.push(this._unbind(binding));
-    }
-    return purged;
-  }
-  _unbind(binding) {
-    if (binding) {
-      this._bindings.delete(binding.key);
-      this._e2b.delete(binding.element);
-    }
-    return binding;
-  }
-  _destroy() {
-    this.unbindAll();
-  }
 }
-exports.Bindings = Bindings;
+exports.default = Bindings;

package/dist/cjs/util/states.js

@@ -15,55 +15,62 @@ const {
   UNTRACKED,
   TRIGGERED
 } = _constants.TRACKING_STATUS;
+
+/*
 const STATES = {
   NEW: Object.freeze({
     [IMPRESSION]: UNTRACKED,
-    [VIEWABLE]: UNTRACKED
+    [VIEWABLE]: UNTRACKED,
   }),
   UNTRACKED: Object.freeze({
     [IMPRESSION]: UNTRACKED,
     [VIEWABLE]: UNTRACKED,
-    [CLICK]: UNTRACKED
-  })
+    [CLICK]: UNTRACKED,
+  }),
 };
+*/
+
+const UNTRACKED_STATES = Object.freeze({
+  [IMPRESSION]: UNTRACKED,
+  [VIEWABLE]: UNTRACKED,
+  [CLICK]: UNTRACKED
+});
 
 /**
  * Tracking states for a session to keep track of the tracking status of each product.
- * For each entry there are status of impression, viewable, and click events. 
- * The actual click tracking status depends on the presence of root element, which is not respected in this object.
+ * For each entry there are status of impression, viewable, and click events.
  */
 class States {
   constructor(sessionId) {
     this.sessionId = sessionId;
-    this._states = new Map(); // productId -> {impression, viewable, click}
+    this._states = new Map(); // item key -> {impression, viewable, click}
   }
-  getFullState(productId) {
+  getFullState(item) {
     // when we receive a bind event, impression is trigger, making an entry here
     // so if the state is not found, the product is not present yet => all untracked
-    const state = this._states.get(getKey(productId));
-    return state ? Object.assign({}, state) : STATES.UNTRACKED;
+    const state = this._states.get(this._getKey(item));
+    return state ? Object.assign({}, state) : UNTRACKED_STATES;
   }
-  get(productId, type) {
-    const state = this._states.get(getKey(productId));
+  get(item, type) {
+    const state = this._states.get(this._getKey(item));
     return state && state[type] || UNTRACKED;
   }
-  set(productIds, type, status) {
+  set(items, type, status) {
     (0, _constants.validateEventType)(type);
     (0, _constants.validateTrackingStatus)(status);
-    for (const productId of (0, _commons.asArray)(productIds)) {
-      this._setOne(getKey(productId), type, status);
+    for (const item of (0, _commons.asArray)(items)) {
+      this._setOne(item, type, status);
     }
   }
-  _setOne(productId, type, status) {
-    // leave click untracked/tracking judged by its global state
-    (0, _commons.computeIfAbsent)(this._states, productId, () => Object.assign({}, STATES.NEW))[type] = status;
+  untriggered(items, type) {
+    return items.filter(item => this.get(item, type) !== TRIGGERED);
+  }
+  _getKey(item) {
+    // TODO: ad-hoc! should move away to higher level
+    return item.product_id || item.text || item.id || item;
   }
-  untriggered(productIds, type) {
-    return productIds.filter(productId => this.get(productId, type) !== TRIGGERED);
+  _setOne(item, type, status) {
+    (0, _commons.computeIfAbsent)(this._states, this._getKey(item), () => Object.assign({}, UNTRACKED_STATES))[type] = status;
   }
 }
-exports.default = States;
-function getKey(value) {
-  // TODO: ad-hoc!
-  return value.product_id || value.text || value;
-}
+exports.default = States;

package/dist/cjs/util/trackers.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeTrackerOptions = normalizeTrackerOptions;
+exports.validateClick = validateClick;
+var _commons = require("@miso.ai/commons");
+const _excluded = ["impression", "viewable", "click"];
+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_TRACKER_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 normalizeTrackerOptions(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_TRACKER_OPTIONS, rest, {
+    impression: mergeOptions(DEFAULT_TRACKER_OPTIONS.impression, impression),
+    viewable: mergeOptions(DEFAULT_TRACKER_OPTIONS.viewable, viewable),
+    click: mergeOptions(DEFAULT_TRACKER_OPTIONS.click, click)
+  }));
+}
+function validateClick() {
+  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let event = arguments.length > 1 ? arguments[1] : undefined;
+  if (!options) {
+    return false;
+  }
+  if (typeof options.validate === 'function') {
+    return options.validate(event);
+  }
+  if (options.lenient) {
+    return true;
+  }
+
+  // standard criteria
+  // 1. it must be a left click
+  if (event.button !== 0) {
+    return false;
+  }
+  // 2. event default must not be prevented
+  if (event.defaultPrevented) {
+    return false;
+  }
+  // 3. must go through a real link
+  if (!(0, _commons.findInAncestors)(event.target, element => element.tagName === 'A' && element.href || undefined)) {
+    return false;
+  }
+  return true;
+}

package/dist/cjs/util/viewables.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _commons = require("@miso.ai/commons");
+class Viewables {
+  constructor() {
+    this._entries = new WeakMap();
+  }
+  isTracked(element) {
+    return this._entries.has(element);
+  }
+  async track(element) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (!options) {
+      return false;
+    }
+    const entry = this._entries.get(element);
+    if (entry) {
+      return false;
+    }
+    const ac = new AbortController();
+    const {
+      signal
+    } = ac;
+    this._entries.set(element, {
+      ac
+    });
+    let result = false;
+    try {
+      await (0, _commons.viewable)(element, Object.assign({}, options, {
+        signal
+      }));
+      result = true;
+    } catch (e) {
+      if (e.name !== 'AbortError') {
+        throw e;
+      }
+    } finally {
+      this._entries.delete(element);
+    }
+    return result;
+  }
+  untrack(element) {
+    const entry = this._entries.get(element);
+    if (!entry) {
+      return;
+    }
+    entry.ac.abort();
+    this._entries.delete(element);
+  }
+}
+exports.default = Viewables;

package/dist/cjs/version.js

@@ -4,4 +4,4 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _default = exports.default = '1.10.0-beta.0';
+var _default = exports.default = '1.10.0-beta.10';