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

package/dist/cjs/layout/text/typewriter/progress.js

@@ -1,45 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-class ProgressController {
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this._cps = normalizeSpeedFunction(options);
-  }
-  get(prevState, newState) {
-    const cps = this._cps(newState);
-    const increment = Math.floor((newState.timestamp - prevState.timestamp) * cps / 1000);
-    return prevState.cursor + increment;
-  }
-}
-exports.default = ProgressController;
-function normalizeSpeedFunction() {
-  let {
-    speed = 100,
-    acceleration = 4
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  if (typeof speed === 'function') {
-    return speed;
-  }
-  if (typeof speed !== 'number') {
-    throw new Error(`Invalid speed: ${speed}`);
-  }
-  if (typeof acceleration !== 'number') {
-    throw new Error(`Invalid acceleration: ${acceleration}`);
-  }
-  return _ref => {
-    let {
-      doneAt,
-      timestamp
-    } = _ref;
-    let value = speed * (Math.random() + 0.5);
-    if (acceleration > 0 && doneAt !== undefined) {
-      // speed up gradually when input is done
-      value *= 1 + (timestamp - doneAt) * acceleration / 1000;
-    }
-    return value;
-  };
-}

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.includes(n)) 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;

package/src/actor/trackers.js

@@ -1,45 +0,0 @@
-import Tracker from './tracker.js';
-
-export default class Trackers {
-
-  constructor(hub, { views, options }) {
-    this._hub = hub;
-    this._views = views;
-    this._options = options;
-    this._trackers = {};
-    options.on('trackers', () => this._syncConfig());
-    this._syncConfig();
-  }
-
-  _syncConfig() {
-    for (const [role, options] of Object.entries(this._options.resolved.trackers)) {
-      this._createOrConfigTracker(role, options);
-    }
-  }
-
-  _createOrConfigTracker(role, options) {
-    if (options === undefined) {
-      return;
-    }
-    let tracker = this._trackers[role];
-    if (!tracker) {
-      tracker = this._trackers[role] = new Tracker(this._hub, this._views.get(role), options);
-      Object.defineProperty(this, role, {
-        get: () => this._trackers[role],
-      });
-    } else {
-      tracker.config(options);
-    }
-  }
-
-  _destroy() {
-    for (const tracker of Object.values(this._trackers)) {
-      try {
-        tracker._destroy();
-      } catch (e) {
-        console.error(e);
-      }
-    }
-  }
-
-}

package/src/layout/text/typewriter/progress.js

@@ -1,33 +0,0 @@
-export default class ProgressController {
-
-  constructor(options = {}) {
-    this._cps = normalizeSpeedFunction(options);
-  }
-
-  get(prevState, newState) {
-    const cps = this._cps(newState);
-    const increment = Math.floor((newState.timestamp - prevState.timestamp) * cps / 1000);
-    return prevState.cursor + increment;
-  }
-
-}
-
-function normalizeSpeedFunction({ speed = 100, acceleration = 4 } = {}) {
-  if (typeof speed === 'function') {
-    return speed;
-  }
-  if (typeof speed !== 'number') {
-    throw new Error(`Invalid speed: ${speed}`);
-  }
-  if (typeof acceleration !== 'number') {
-    throw new Error(`Invalid acceleration: ${acceleration}`);
-  }
-  return ({ doneAt, timestamp }) => {
-    let value = speed * (Math.random() + 0.5);
-    if (acceleration > 0 && doneAt !== undefined) {
-      // speed up gradually when input is done
-      value *= 1 + ((timestamp - doneAt) * acceleration / 1000);
-    }
-    return value;
-  };
-}