reactors/dist/API/StyleSheet/transforms/transform.js

View components and APIs that work web, mobile and desktop!

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _Core = require('../../Core');

var _Core2 = _interopRequireDefault(_Core);

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

var translateTransform = function translateTransform(values) {
  var bits2 = values.split(/,\s+/);
  var translateX = bits2[0];
  if (typeof translateX === 'string' && /px/.test(translateX)) {
    translateX = parseInt(translateX, 10);
  }
  var translateY = bits2[1];
  if (typeof translateY === 'string' && /px/.test(translateY)) {
    translateY = parseInt(translateY, 10);
  }
  return [{ translateX: translateX }, { translateY: translateY }];
};

var translateXTransform = function translateXTransform(values) {
  var translateX = values;
  if (typeof translateX === 'string' && /px/.test(translateX)) {
    translateX = parseInt(translateX, 10);
  }
  return { translateX: translateX };
};

var perspectiveTransform = function perspectiveTransform(values) {
  return { perspective: Number(values) };
};

var translateYTransform = function translateYTransform(values) {
  var translateY = values;
  if (typeof translateY === 'string' && /px/.test(translateY)) {
    translateY = parseInt(translateY, 10);
  }
  return { translateY: translateY };
};

var scaleTransform = function scaleTransform(values) {
  var bits2 = values.split(/,\s+/);
  var scaleX = Number(bits2[0]);
  var scaleY = Number(bits2[1]);
  return [{ scaleX: scaleX }, { scaleY: scaleY }];
};

var skewTransform = function skewTransform(values) {
  var bits2 = values.split(/,\s+/);
  var skewX = bits2[0];
  var skewY = bits2[1];
  return [{ skewX: skewX }, { skewY: skewY }];
};

var transform = function transform(style) {
  if (typeof style.transform === 'string' && _Core2.default.isMobile()) {
    var _ret = function () {
      var transformed = {};
      var transformations = style.transform.split(/\)\s+/);
      transformed.transform = [];
      transformations.forEach(function (transformation) {
        var _transformed$transfor, _transformed$transfor2, _transformed$transfor3;

        if (!/\)$/.test(transformation)) {
          transformation += ')';
        }
        var bits = transformation.split(/\(/);
        var key = bits.shift();
        var values = bits.join('').replace(/\)$/, '');
        switch (key) {
          case 'translate':
            (_transformed$transfor = transformed.transform).push.apply(_transformed$transfor, (0, _toConsumableArray3.default)(translateTransform(values)));
            break;
          case 'translateX':
            transformed.transform.push(translateXTransform(values));
            break;
          case 'translateY':
            transformed.transform.push(translateYTransform(values));
            break;
          case 'perspective':
            transformed.transform.push(perspectiveTransform(values));
            break;
          case 'rotate':
            transformed.transform.push({ rotate: values });
            break;
          case 'rotateX':
            transformed.transform.push({ rotateX: values });
            break;
          case 'rotateY':
            transformed.transform.push({ rotateY: values });
            break;
          case 'rotateZ':
            transformed.transform.push({ rotateZ: values });
            break;
          case 'scale':
            (_transformed$transfor2 = transformed.transform).push.apply(_transformed$transfor2, (0, _toConsumableArray3.default)(scaleTransform(values)));
            break;
          case 'scaleX':
            transformed.transform.push({ scaleX: Number(values) });
            break;
          case 'scaleY':
            transformed.transform.push({ scaleY: Number(values) });
            break;
          case 'skew':
            (_transformed$transfor3 = transformed.transform).push.apply(_transformed$transfor3, (0, _toConsumableArray3.default)(skewTransform(values)));
            break;
          case 'skewX':
            transformed.transform.push({ skewX: values });
            break;
          case 'skewY':
            transformed.transform.push({ skewY: values });
            break;
        }
      });
      return {
        v: (0, _extends3.default)({}, style, transformed)
      };
    }();

    if ((typeof _ret === 'undefined' ? 'undefined' : (0, _typeof3.default)(_ret)) === "object") return _ret.v;
  }
  if (Array.isArray(style.transform) && _Core2.default.isDOM()) {
    var _transformed = {};
    _transformed.transform = style.transform.map(function (transformation) {
      for (var key in transformation) {
        if (typeof transformation[key] === 'number') {
          return key + '(' + transformation[key] + 'px)';
        }
        return key + '(' + transformation[key] + ')';
      }
      return '';
    }).join(' ');
    return (0, _extends3.default)({}, style, _transformed);
  }
  return style;
};

exports.default = transform;