@shoutem/redux-io/status.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.shouldLoad = exports.hasPrev = exports.hasNext = exports.getMeta = exports.getId = exports.shouldRefresh = exports.isError = exports.getModificationTime = exports.isBusy = exports.isInitialized = exports.isValid = exports.getTransformation = exports.hasStatus = exports.getStatus = exports.cloneStatus = exports.setStatus = exports.updateStatus = exports.createStatus = exports.busyStatus = exports.validationStatus = exports.STATUS = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

exports.isExpired = isExpired;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

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

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 STATUS = exports.STATUS = '@@redux-api-state/status';

var validationStatus = exports.validationStatus = Object.freeze({
  NONE: 'none',
  INVALID: 'invalid',
  VALID: 'valid'
});

var busyStatus = exports.busyStatus = Object.freeze({
  IDLE: 'idle',
  BUSY: 'busy'
});

var createStatus = exports.createStatus = function createStatus() {
  var description = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return _extends({}, description, {
    validationStatus: validationStatus.NONE,
    busyStatus: busyStatus.IDLE,
    error: false,
    modifiedTimestamp: Date.now(),
    transformation: {}
  });
};

var updateStatus = exports.updateStatus = function updateStatus(status, update) {
  var markChange = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

  var timestamp = markChange ? { modifiedTimestamp: Date.now() } : {};
  return _lodash2.default.merge({}, status, update, timestamp);
};

var setStatus = exports.setStatus = function setStatus(obj, status) {
  if (_lodash2.default.has(obj, STATUS)) {
    // eslint-disable-next-line no-param-reassign
    obj[STATUS] = status;
  } else {
    Object.defineProperty(obj, STATUS, {
      value: status,
      enumerable: false,
      writable: true
    });
  }
};

var cloneStatus = exports.cloneStatus = function cloneStatus(sourceObject, destinationObject) {
  var markChange = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  if (!sourceObject[STATUS]) {
    return;
  }
  setStatus(destinationObject, updateStatus(sourceObject[STATUS], {}, markChange));
};

function statusProp(obj, prop) {
  var propPath = _lodash2.default.isArray(prop) ? prop : [prop];
  return _lodash2.default.get(obj, [STATUS].concat(_toConsumableArray(propPath)));
}

var getStatus = exports.getStatus = function getStatus(obj) {
  return _lodash2.default.get(obj, [STATUS]);
};

var hasStatus = exports.hasStatus = function hasStatus(obj) {
  return _lodash2.default.has(obj, [STATUS]);
};

var getTransformation = exports.getTransformation = function getTransformation(obj) {
  return statusProp(obj, 'transformation');
};

var isValid = exports.isValid = function isValid(obj) {
  return !!getStatus(obj) && statusProp(obj, 'validationStatus') === validationStatus.VALID;
};

var isInitialized = exports.isInitialized = function isInitialized(obj) {
  return !!getStatus(obj) && statusProp(obj, 'validationStatus') !== validationStatus.NONE;
};

var isBusy = exports.isBusy = function isBusy(obj) {
  return !!(statusProp(obj, 'busyStatus') === busyStatus.BUSY);
};

var getModificationTime = exports.getModificationTime = function getModificationTime(obj) {
  return statusProp(obj, 'modifiedTimestamp');
};

var isError = exports.isError = function isError(obj) {
  return !!statusProp(obj, 'error');
};

function isExpired(reference) {
  var status = getStatus(reference);
  if (!status) {
    return false;
  }

  var expirationTime = status.expirationTime,
      modifiedTimestamp = status.modifiedTimestamp;

  if (!expirationTime) {
    return false;
  }

  var referenceLifetime = Date.now() - modifiedTimestamp;
  // TODO: When `expiration` becomes rio plugin, save milliseconds in
  // the status to avoid conversation
  return expirationTime * 1000 < referenceLifetime;
}

var shouldRefresh = exports.shouldRefresh = function shouldRefresh(obj) {
  var ignoreError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  return (!isValid(obj) || isExpired(obj)) && !isBusy(obj) && (!isError(obj) || ignoreError);
};

var getId = exports.getId = function getId(obj) {
  return statusProp(obj, 'id');
};

var getMeta = exports.getMeta = function getMeta(obj) {
  return statusProp(obj, 'meta');
};

var hasNext = exports.hasNext = function hasNext(obj) {
  return !!statusProp(obj, ['links', 'next']);
};

var hasPrev = exports.hasPrev = function hasPrev(obj) {
  return !!statusProp(obj, ['links', 'prev']);
};

/**
 * Checks whether a load is needed for selected propName on given set of new and current props.
 * @param nextProps New props
 * @param props Current props
 * @param propName Prop to check
 * @param ignoreError flag indicating whether shouldRefresh function returns 'true' for
 * objects in error
 */
var shouldLoad = exports.shouldLoad = function shouldLoad(nextProps, props, propName) {
  var ignoreError = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

  if (!nextProps || !propName) {
    throw Error('Invalid shouldLoad call. Check provided arguments.');
  }

  var prop = _lodash2.default.get(props, propName);
  var nextProp = _lodash2.default.get(nextProps, propName);

  // if both props point to same object, nothing has changed
  if (nextProp && nextProp === prop) {
    return false;
  }

  // finally check whether refresh is needed
  return shouldRefresh(nextProp, ignoreError);
};