BVB Source Codes

reactide Show gradient.js Source code

Return Download reactide: download gradient.js Source code - Download reactide Source code - Type:.js
  1. (function() {
  2.   var Gradient, OldValue, Value, isDirection, list, parser, range, utils,
  3.     extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  4.     hasProp = {}.hasOwnProperty,
  5.     slice = [].slice;
  6.  
  7.   OldValue = require('../old-value');
  8.  
  9.   Value = require('../value');
  10.  
  11.   utils = require('../utils');
  12.  
  13.   parser = require('postcss-value-parser');
  14.  
  15.   range = require('normalize-range');
  16.  
  17.   list = require('postcss/lib/list');
  18.  
  19.   isDirection = /top|left|right|bottom/gi;
  20.  
  21.   Gradient = (function(superClass) {
  22.     extend(Gradient, superClass);
  23.  
  24.     function Gradient() {
  25.       return Gradient.__super__.constructor.apply(this, arguments);
  26.     }
  27.  
  28.     Gradient.names = ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'];
  29.  
  30.     Gradient.prototype.replace = function(string, prefix) {
  31.       var ast, changes, j, len, node, ref;
  32.       ast = parser(string);
  33.       ref = ast.nodes;
  34.       for (j = 0, len = ref.length; j < len; j++) {
  35.         node = ref[j];
  36.         if (node.type === 'function' && node.value === this.name) {
  37.           node.nodes = this.newDirection(node.nodes);
  38.           node.nodes = this.normalize(node.nodes);
  39.           if (prefix === '-webkit- old') {
  40.             changes = this.oldWebkit(node);
  41.             if (!changes) {
  42.               return;
  43.             }
  44.           } else {
  45.             node.nodes = this.convertDirection(node.nodes);
  46.             node.value = prefix + node.value;
  47.           }
  48.         }
  49.       }
  50.       return ast.toString();
  51.     };
  52.  
  53.     Gradient.prototype.directions = {
  54.       top: 'bottom',
  55.       left: 'right',
  56.       bottom: 'top',
  57.       right: 'left'
  58.     };
  59.  
  60.     Gradient.prototype.oldDirections = {
  61.       'top': 'left bottom, left top',
  62.       'left': 'right top, left top',
  63.       'bottom': 'left top, left bottom',
  64.       'right': 'left top, right top',
  65.       'top right': 'left bottom, right top',
  66.       'top left': 'right bottom, left top',
  67.       'right top': 'left bottom, right top',
  68.       'right bottom': 'left top, right bottom',
  69.       'bottom right': 'left top, right bottom',
  70.       'bottom left': 'right top, left bottom',
  71.       'left top': 'right bottom, left top',
  72.       'left bottom': 'right top, left bottom'
  73.     };
  74.  
  75.     Gradient.prototype.replaceFirst = function() {
  76.       var params, prefix, words;
  77.       params = arguments[0], words = 2 <= arguments.length ? slice.call(arguments, 1) : [];
  78.       prefix = words.map(function(i) {
  79.         if (i === ' ') {
  80.           return {
  81.             type: 'space',
  82.             value: i
  83.           };
  84.         } else {
  85.           return {
  86.             type: 'word',
  87.             value: i
  88.           };
  89.         }
  90.       });
  91.       return prefix.concat(params.slice(1));
  92.     };
  93.  
  94.     Gradient.prototype.normalizeUnit = function(str, full) {
  95.       var deg, num;
  96.       num = parseFloat(str);
  97.       deg = (num / full) * 360;
  98.       return deg + "deg";
  99.     };
  100.  
  101.     Gradient.prototype.normalize = function(nodes) {
  102.       var num;
  103.       if (!nodes[0]) {
  104.         return nodes;
  105.       }
  106.       if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) {
  107.         nodes[0].value = this.normalizeUnit(nodes[0].value, 400);
  108.       } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) {
  109.         nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI);
  110.       } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) {
  111.         nodes[0].value = this.normalizeUnit(nodes[0].value, 1);
  112.       } else if (nodes[0].value.indexOf('deg') !== -1) {
  113.         num = parseFloat(nodes[0].value);
  114.         num = range.wrap(0, 360, num);
  115.         nodes[0].value = num + "deg";
  116.       }
  117.       if (nodes[0].value === '0deg') {
  118.         nodes = this.replaceFirst(nodes, 'to', ' ', 'top');
  119.       } else if (nodes[0].value === '90deg') {
  120.         nodes = this.replaceFirst(nodes, 'to', ' ', 'right');
  121.       } else if (nodes[0].value === '180deg') {
  122.         nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom');
  123.       } else if (nodes[0].value === '270deg') {
  124.         nodes = this.replaceFirst(nodes, 'to', ' ', 'left');
  125.       }
  126.       return nodes;
  127.     };
  128.  
  129.     Gradient.prototype.newDirection = function(params) {
  130.       var i, j, ref;
  131.       if (params[0].value === 'to') {
  132.         return params;
  133.       }
  134.       if (!isDirection.test(params[0].value)) {
  135.         return params;
  136.       }
  137.       params.unshift({
  138.         type: 'word',
  139.         value: 'to'
  140.       }, {
  141.         type: 'space',
  142.         value: ' '
  143.       });
  144.       for (i = j = 2, ref = params.length; 2 <= ref ? j < ref : j > ref; i = 2 <= ref ? ++j : --j) {
  145.         if (params[i].type === 'div') {
  146.           break;
  147.         }
  148.         if (params[i].type === 'word') {
  149.           params[i].value = this.revertDirection(params[i].value);
  150.         }
  151.       }
  152.       return params;
  153.     };
  154.  
  155.     Gradient.prototype.convertDirection = function(params) {
  156.       if (params.length > 0) {
  157.         if (params[0].value === 'to') {
  158.           this.fixDirection(params);
  159.         } else if (params[0].value.indexOf('deg') !== -1) {
  160.           this.fixAngle(params);
  161.         } else if (params[2].value === 'at') {
  162.           this.fixRadial(params);
  163.         }
  164.       }
  165.       return params;
  166.     };
  167.  
  168.     Gradient.prototype.fixDirection = function(params) {
  169.       var i, j, ref, results;
  170.       params.splice(0, 2);
  171.       results = [];
  172.       for (i = j = 0, ref = params.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
  173.         if (params[i].type === 'div') {
  174.           break;
  175.         }
  176.         if (params[i].type === 'word') {
  177.           results.push(params[i].value = this.revertDirection(params[i].value));
  178.         } else {
  179.           results.push(void 0);
  180.         }
  181.       }
  182.       return results;
  183.     };
  184.  
  185.     Gradient.prototype.fixAngle = function(params) {
  186.       var first;
  187.       first = params[0].value;
  188.       first = parseFloat(first);
  189.       first = Math.abs(450 - first) % 360;
  190.       first = this.roundFloat(first, 3);
  191.       return params[0].value = first + "deg";
  192.     };
  193.  
  194.     Gradient.prototype.fixRadial = function(params) {
  195.       var first, i, j, ref, second;
  196.       first = params[0];
  197.       second = [];
  198.       for (i = j = 4, ref = params.length; 4 <= ref ? j < ref : j > ref; i = 4 <= ref ? ++j : --j) {
  199.         if (params[i].type === 'div') {
  200.           break;
  201.         } else {
  202.           second.push(params[i]);
  203.         }
  204.       }
  205.       return params.splice.apply(params, [0, i].concat(slice.call(second), [params[i + 2]], [first]));
  206.     };
  207.  
  208.     Gradient.prototype.revertDirection = function(word) {
  209.       return this.directions[word.toLowerCase()] || word;
  210.     };
  211.  
  212.     Gradient.prototype.roundFloat = function(float, digits) {
  213.       return parseFloat(float.toFixed(digits));
  214.     };
  215.  
  216.     Gradient.prototype.oldWebkit = function(node) {
  217.       var i, j, k, len, len1, nodes, param, params, string;
  218.       nodes = node.nodes;
  219.       string = parser.stringify(node.nodes);
  220.       if (this.name !== 'linear-gradient') {
  221.         return false;
  222.       }
  223.       if (nodes[0] && nodes[0].value.indexOf('deg') !== -1) {
  224.         return false;
  225.       }
  226.       if (string.indexOf('px') !== -1) {
  227.         return false;
  228.       }
  229.       if (string.indexOf('-corner') !== -1) {
  230.         return false;
  231.       }
  232.       if (string.indexOf('-side') !== -1) {
  233.         return false;
  234.       }
  235.       params = [[]];
  236.       for (j = 0, len = nodes.length; j < len; j++) {
  237.         i = nodes[j];
  238.         params[params.length - 1].push(i);
  239.         if (i.type === 'div' && i.value === ',') {
  240.           params.push([]);
  241.         }
  242.       }
  243.       this.oldDirection(params);
  244.       this.colorStops(params);
  245.       node.nodes = [];
  246.       for (k = 0, len1 = params.length; k < len1; k++) {
  247.         param = params[k];
  248.         node.nodes = node.nodes.concat(param);
  249.       }
  250.       node.nodes.unshift({
  251.         type: 'word',
  252.         value: 'linear'
  253.       }, this.cloneDiv(node.nodes));
  254.       node.value = '-webkit-gradient';
  255.       return true;
  256.     };
  257.  
  258.     Gradient.prototype.oldDirection = function(params) {
  259.       var div, j, len, node, old, ref, words;
  260.       div = this.cloneDiv(params[0]);
  261.       if (params[0][0].value !== 'to') {
  262.         return params.unshift([
  263.           {
  264.             type: 'word',
  265.             value: this.oldDirections.bottom
  266.           }, div
  267.         ]);
  268.       } else {
  269.         words = [];
  270.         ref = params[0].slice(2);
  271.         for (j = 0, len = ref.length; j < len; j++) {
  272.           node = ref[j];
  273.           if (node.type === 'word') {
  274.             words.push(node.value.toLowerCase());
  275.           }
  276.         }
  277.         words = words.join(' ');
  278.         old = this.oldDirections[words] || words;
  279.         return params[0] = [
  280.           {
  281.             type: 'word',
  282.             value: old
  283.           }, div
  284.         ];
  285.       }
  286.     };
  287.  
  288.     Gradient.prototype.cloneDiv = function(params) {
  289.       var i, j, len;
  290.       for (j = 0, len = params.length; j < len; j++) {
  291.         i = params[j];
  292.         if (i.type === 'div' && i.value === ',') {
  293.           return i;
  294.         }
  295.       }
  296.       return {
  297.         type: 'div',
  298.         value: ',',
  299.         after: ' '
  300.       };
  301.     };
  302.  
  303.     Gradient.prototype.colorStops = function(params) {
  304.       var color, div, i, j, len, param, pos, results, stop;
  305.       results = [];
  306.       for (i = j = 0, len = params.length; j < len; i = ++j) {
  307.         param = params[i];
  308.         if (i === 0) {
  309.           continue;
  310.         }
  311.         color = parser.stringify(param[0]);
  312.         if (param[1] && param[1].type === 'word') {
  313.           pos = param[1].value;
  314.         } else if (param[2] && param[2].type === 'word') {
  315.           pos = param[2].value;
  316.         }
  317.         stop = i === 1 && (!pos || pos === '0%') ? "from(" + color + ")" : i === params.length - 1 && (!pos || pos === '100%') ? "to(" + color + ")" : pos ? "color-stop(" + pos + ", " + color + ")" : "color-stop(" + color + ")";
  318.         div = param[param.length - 1];
  319.         params[i] = [
  320.           {
  321.             type: 'word',
  322.             value: stop
  323.           }
  324.         ];
  325.         if (div.type === 'div' && div.value === ',') {
  326.           results.push(params[i].push(div));
  327.         } else {
  328.           results.push(void 0);
  329.         }
  330.       }
  331.       return results;
  332.     };
  333.  
  334.     Gradient.prototype.old = function(prefix) {
  335.       var regexp, string, type;
  336.       if (prefix === '-webkit-') {
  337.         type = this.name === 'linear-gradient' ? 'linear' : 'radial';
  338.         string = '-gradient';
  339.         regexp = utils.regexp("-webkit-(" + type + "-gradient|gradient\\(\\s*" + type + ")", false);
  340.         return new OldValue(this.name, prefix + this.name, string, regexp);
  341.       } else {
  342.         return Gradient.__super__.old.apply(this, arguments);
  343.       }
  344.     };
  345.  
  346.     Gradient.prototype.add = function(decl, prefix) {
  347.       var p;
  348.       p = decl.prop;
  349.       if (p.indexOf('mask') !== -1) {
  350.         if (prefix === '-webkit-' || prefix === '-webkit- old') {
  351.           return Gradient.__super__.add.apply(this, arguments);
  352.         }
  353.       } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') {
  354.         if (prefix === '-webkit-' || prefix === '-webkit- old') {
  355.           return Gradient.__super__.add.apply(this, arguments);
  356.         }
  357.       } else {
  358.         return Gradient.__super__.add.apply(this, arguments);
  359.       }
  360.     };
  361.  
  362.     return Gradient;
  363.  
  364.   })(Value);
  365.  
  366.   module.exports = Gradient;
  367.  
  368. }).call(this);
  369.  
downloadgradient.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