BVB Source Codes

reactide Show transition.js Source code

Return Download reactide: download transition.js Source code - Download reactide Source code - Type:.js
  1. (function() {
  2.   var Transition, list, parser, vendor;
  3.  
  4.   parser = require('postcss-value-parser');
  5.  
  6.   vendor = require('postcss/lib/vendor');
  7.  
  8.   list = require('postcss/lib/list');
  9.  
  10.   Transition = (function() {
  11.     function Transition(prefixes) {
  12.       this.prefixes = prefixes;
  13.     }
  14.  
  15.     Transition.prototype.props = ['transition', 'transition-property'];
  16.  
  17.     Transition.prototype.add = function(decl, result) {
  18.       var added, declPrefixes, j, k, l, len, len1, len2, names, operaClean, param, params, prefix, prefixValue, prefixed, prefixer, prop, ref, ref1, value, webkitClean;
  19.       declPrefixes = ((ref = this.prefixes.add[decl.prop]) != null ? ref.prefixes : void 0) || [];
  20.       params = this.parse(decl.value);
  21.       names = params.map((function(_this) {
  22.         return function(i) {
  23.           return _this.findProp(i);
  24.         };
  25.       })(this));
  26.       added = [];
  27.       if (names.some(function(i) {
  28.         return i[0] === '-';
  29.       })) {
  30.         return;
  31.       }
  32.       for (j = 0, len = params.length; j < len; j++) {
  33.         param = params[j];
  34.         prop = this.findProp(param);
  35.         if (prop[0] === '-') {
  36.           continue;
  37.         }
  38.         prefixer = this.prefixes.add[prop];
  39.         if (!(prefixer != null ? prefixer.prefixes : void 0)) {
  40.           continue;
  41.         }
  42.         ref1 = prefixer.prefixes;
  43.         for (k = 0, len1 = ref1.length; k < len1; k++) {
  44.           prefix = ref1[k];
  45.           prefixed = this.prefixes.prefixed(prop, prefix);
  46.           if (prefixed !== '-ms-transform' && names.indexOf(prefixed) === -1) {
  47.             if (!this.disabled(prop, prefix)) {
  48.               added.push(this.clone(prop, prefixed, param));
  49.             }
  50.           }
  51.         }
  52.       }
  53.       params = params.concat(added);
  54.       value = this.stringify(params);
  55.       webkitClean = this.stringify(this.cleanFromUnprefixed(params, '-webkit-'));
  56.       if (declPrefixes.indexOf('-webkit-') !== -1) {
  57.         this.cloneBefore(decl, '-webkit-' + decl.prop, webkitClean);
  58.       }
  59.       this.cloneBefore(decl, decl.prop, webkitClean);
  60.       if (declPrefixes.indexOf('-o-') !== -1) {
  61.         operaClean = this.stringify(this.cleanFromUnprefixed(params, '-o-'));
  62.         this.cloneBefore(decl, '-o-' + decl.prop, operaClean);
  63.       }
  64.       for (l = 0, len2 = declPrefixes.length; l < len2; l++) {
  65.         prefix = declPrefixes[l];
  66.         if (prefix !== '-webkit-' && prefix !== '-o-') {
  67.           prefixValue = this.stringify(this.cleanOtherPrefixes(params, prefix));
  68.           this.cloneBefore(decl, prefix + decl.prop, prefixValue);
  69.         }
  70.       }
  71.       if (value !== decl.value && !this.already(decl, decl.prop, value)) {
  72.         this.checkForWarning(result, decl);
  73.         decl.cloneBefore();
  74.         return decl.value = value;
  75.       }
  76.     };
  77.  
  78.     Transition.prototype.findProp = function(param) {
  79.       var i, j, len, prop, token;
  80.       prop = param[0].value;
  81.       if (/^\d/.test(prop)) {
  82.         for (i = j = 0, len = param.length; j < len; i = ++j) {
  83.           token = param[i];
  84.           if (i !== 0 && token.type === 'word') {
  85.             return token.value;
  86.           }
  87.         }
  88.       }
  89.       return prop;
  90.     };
  91.  
  92.     Transition.prototype.already = function(decl, prop, value) {
  93.       return decl.parent.some(function(i) {
  94.         return i.prop === prop && i.value === value;
  95.       });
  96.     };
  97.  
  98.     Transition.prototype.cloneBefore = function(decl, prop, value) {
  99.       if (!this.already(decl, prop, value)) {
  100.         return decl.cloneBefore({
  101.           prop: prop,
  102.           value: value
  103.         });
  104.       }
  105.     };
  106.  
  107.     Transition.prototype.checkForWarning = function(result, decl) {
  108.       if (decl.prop === 'transition-property') {
  109.         return decl.parent.each(function(i) {
  110.           if (i.type !== 'decl') {
  111.             return;
  112.           }
  113.           if (i.prop.indexOf('transition-') !== 0) {
  114.             return;
  115.           }
  116.           if (i.prop === 'transition-property') {
  117.             return;
  118.           }
  119.           if (list.comma(i.value).length > 1) {
  120.             decl.warn(result, 'Replace transition-property to transition, ' + 'because Autoprefixer could not support ' + 'any cases of transition-property ' + 'and other transition-*');
  121.           }
  122.           return false;
  123.         });
  124.       }
  125.     };
  126.  
  127.     Transition.prototype.remove = function(decl) {
  128.       var double, params, smaller, value;
  129.       params = this.parse(decl.value);
  130.       params = params.filter((function(_this) {
  131.         return function(i) {
  132.           var ref;
  133.           return !((ref = _this.prefixes.remove[_this.findProp(i)]) != null ? ref.remove : void 0);
  134.         };
  135.       })(this));
  136.       value = this.stringify(params);
  137.       if (decl.value === value) {
  138.         return;
  139.       }
  140.       if (params.length === 0) {
  141.         decl.remove();
  142.         return;
  143.       }
  144.       double = decl.parent.some(function(i) {
  145.         return i.prop === decl.prop && i.value === value;
  146.       });
  147.       smaller = decl.parent.some(function(i) {
  148.         return i !== decl && i.prop === decl.prop && i.value.length > value.length;
  149.       });
  150.       if (double || smaller) {
  151.         return decl.remove();
  152.       } else {
  153.         return decl.value = value;
  154.       }
  155.     };
  156.  
  157.     Transition.prototype.parse = function(value) {
  158.       var ast, j, len, node, param, ref, result;
  159.       ast = parser(value);
  160.       result = [];
  161.       param = [];
  162.       ref = ast.nodes;
  163.       for (j = 0, len = ref.length; j < len; j++) {
  164.         node = ref[j];
  165.         param.push(node);
  166.         if (node.type === 'div' && node.value === ',') {
  167.           result.push(param);
  168.           param = [];
  169.         }
  170.       }
  171.       result.push(param);
  172.       return result.filter(function(i) {
  173.         return i.length > 0;
  174.       });
  175.     };
  176.  
  177.     Transition.prototype.stringify = function(params) {
  178.       var j, len, nodes, param;
  179.       if (params.length === 0) {
  180.         return '';
  181.       }
  182.       nodes = [];
  183.       for (j = 0, len = params.length; j < len; j++) {
  184.         param = params[j];
  185.         if (param[param.length - 1].type !== 'div') {
  186.           param.push(this.div(params));
  187.         }
  188.         nodes = nodes.concat(param);
  189.       }
  190.       if (nodes[0].type === 'div') {
  191.         nodes = nodes.slice(1);
  192.       }
  193.       if (nodes[nodes.length - 1].type === 'div') {
  194.         nodes = nodes.slice(0, -1);
  195.       }
  196.       return parser.stringify({
  197.         nodes: nodes
  198.       });
  199.     };
  200.  
  201.     Transition.prototype.clone = function(origin, name, param) {
  202.       var changed, i, j, len, result;
  203.       result = [];
  204.       changed = false;
  205.       for (j = 0, len = param.length; j < len; j++) {
  206.         i = param[j];
  207.         if (!changed && i.type === 'word' && i.value === origin) {
  208.           result.push({
  209.             type: 'word',
  210.             value: name
  211.           });
  212.           changed = true;
  213.         } else {
  214.           result.push(i);
  215.         }
  216.       }
  217.       return result;
  218.     };
  219.  
  220.     Transition.prototype.div = function(params) {
  221.       var j, k, len, len1, node, param;
  222.       for (j = 0, len = params.length; j < len; j++) {
  223.         param = params[j];
  224.         for (k = 0, len1 = param.length; k < len1; k++) {
  225.           node = param[k];
  226.           if (node.type === 'div' && node.value === ',') {
  227.             return node;
  228.           }
  229.         }
  230.       }
  231.       return {
  232.         type: 'div',
  233.         value: ',',
  234.         after: ' '
  235.       };
  236.     };
  237.  
  238.     Transition.prototype.cleanOtherPrefixes = function(params, prefix) {
  239.       return params.filter((function(_this) {
  240.         return function(param) {
  241.           var current;
  242.           current = vendor.prefix(_this.findProp(param));
  243.           return current === '' || current === prefix;
  244.         };
  245.       })(this));
  246.     };
  247.  
  248.     Transition.prototype.cleanFromUnprefixed = function(params, prefix) {
  249.       var j, len, p, param, prop, remove, result;
  250.       result = [];
  251.       remove = params.map((function(_this) {
  252.         return function(i) {
  253.           return _this.findProp(i);
  254.         };
  255.       })(this)).filter(function(i) {
  256.         return i.slice(0, prefix.length) === prefix;
  257.       }).map((function(_this) {
  258.         return function(i) {
  259.           return _this.prefixes.unprefixed(i);
  260.         };
  261.       })(this));
  262.       for (j = 0, len = params.length; j < len; j++) {
  263.         param = params[j];
  264.         prop = this.findProp(param);
  265.         p = vendor.prefix(prop);
  266.         if (remove.indexOf(prop) === -1 && (p === prefix || p === '')) {
  267.           result.push(param);
  268.         }
  269.       }
  270.       return result;
  271.     };
  272.  
  273.     Transition.prototype.disabled = function(prop, prefix) {
  274.       var other;
  275.       other = ['order', 'justify-content', 'align-self', 'align-content'];
  276.       if (prop.indexOf('flex') !== -1 || other.indexOf(prop) !== -1) {
  277.         if (this.prefixes.options.flexbox === false) {
  278.           return true;
  279.         } else if (this.prefixes.options.flexbox === 'no-2009') {
  280.           return prefix.indexOf('2009') !== -1;
  281.         }
  282.       }
  283.     };
  284.  
  285.     return Transition;
  286.  
  287.   })();
  288.  
  289.   module.exports = Transition;
  290.  
  291. }).call(this);
  292.  
downloadtransition.js Source code - Download reactide Source code
Related Source Codes/Software:
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
postal - 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top