micro-analytics-adapter-memory/dist.js

An in memory adapter for micro-analytics

'use strict';

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var getAll = function () {
  var _ref = _asyncToGenerator(_regenerator2.default.mark(function _callee(options) {
    var value, _keys, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key;

    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            value = {};
            _context.t0 = filterPaths;
            _context.next = 4;
            return keys();

          case 4:
            _context.t1 = _context.sent;
            _context.t2 = options;
            _keys = (0, _context.t0)(_context.t1, _context.t2);
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _iteratorError = undefined;
            _context.prev = 10;
            _iterator = _keys[Symbol.iterator]();

          case 12:
            if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
              _context.next = 20;
              break;
            }

            key = _step.value;
            _context.next = 16;
            return get(key, {
              before: options.before,
              after: options.after
            });

          case 16:
            value[key] = _context.sent;

          case 17:
            _iteratorNormalCompletion = true;
            _context.next = 12;
            break;

          case 20:
            _context.next = 26;
            break;

          case 22:
            _context.prev = 22;
            _context.t3 = _context['catch'](10);
            _didIteratorError = true;
            _iteratorError = _context.t3;

          case 26:
            _context.prev = 26;
            _context.prev = 27;

            if (!_iteratorNormalCompletion && _iterator.return) {
              _iterator.return();
            }

          case 29:
            _context.prev = 29;

            if (!_didIteratorError) {
              _context.next = 32;
              break;
            }

            throw _iteratorError;

          case 32:
            return _context.finish(29);

          case 33:
            return _context.finish(26);

          case 34:
            return _context.abrupt('return', Promise.resolve(value));

          case 35:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this, [[10, 22, 26, 34], [27,, 29, 33]]);
  }));

  return function getAll(_x) {
    return _ref.apply(this, arguments);
  };
}();

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var _require = require('micro-analytics-adapter-utils'),
    filterViews = _require.filterViews,
    filterPaths = _require.filterPaths;

var Observable = require('zen-observable');

var data = {};
var handlers = [];

var observable = new Observable(function (observer) {
  handlers.push(function (data) {
    return observer.next(data);
  });
  var index = handlers.length;
  return function () {
    handlers = [].concat(_toConsumableArray(handlers.slice(0, index)), _toConsumableArray(handlers.slice(index)));
  };
});

function get(key, options) {
  var value = data[key] || { views: [] };
  return Promise.resolve({ views: filterViews(value.views, options) });
}

function keys() {
  return Promise.resolve(Object.keys(data));
}

function put(key, value) {
  data[key] = value;
  handlers.forEach(function (handler) {
    handler({ key: key, value: value });
  });

  return Promise.resolve();
}

function has(key) {
  return Promise.resolve({}.hasOwnProperty.call(data, key));
}

function clear() {
  data = {};
}

function subscribe(listener) {
  return observable.subscribe(listener);
}

module.exports = { get: get, put: put, getAll: getAll, has: has, keys: keys, clear: clear, subscribe: subscribe };