@canonical/yui 3.18.2-pre

package/build/color-base/color-base-debug.js

@@ -0,0 +1,492 @@
+YUI.add('color-base', function (Y, NAME) {
+
+/**
+Color provides static methods for color conversion.
+
+    Y.Color.toRGB('f00'); // rgb(255, 0, 0)
+
+    Y.Color.toHex('rgb(255, 255, 0)'); // #ffff00
+
+@module color
+@submodule color-base
+@class Color
+@since 3.8.0
+**/
+
+var REGEX_HEX = /^#?([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})(\ufffe)?/,
+    REGEX_HEX3 = /^#?([\da-fA-F]{1})([\da-fA-F]{1})([\da-fA-F]{1})(\ufffe)?/,
+    REGEX_RGB = /rgba?\(([\d]{1,3}), ?([\d]{1,3}), ?([\d]{1,3}),? ?([.\d]*)?\)/,
+    TYPES = { 'HEX': 'hex', 'RGB': 'rgb', 'RGBA': 'rgba' },
+    CONVERTS = { 'hex': 'toHex', 'rgb': 'toRGB', 'rgba': 'toRGBA' };
+
+
+Y.Color = {
+    /**
+    @static
+    @property KEYWORDS
+    @type Object
+    @since 3.8.0
+    **/
+    KEYWORDS: {
+        'black': '000', 'silver': 'c0c0c0', 'gray': '808080', 'white': 'fff',
+        'maroon': '800000', 'red': 'f00', 'purple': '800080', 'fuchsia': 'f0f',
+        'green': '008000', 'lime': '0f0', 'olive': '808000', 'yellow': 'ff0',
+        'navy': '000080', 'blue': '00f', 'teal': '008080', 'aqua': '0ff'
+    },
+
+    /**
+        NOTE: `(\ufffe)?` is added to the Regular Expression to carve out a
+        place for the alpha channel that is returned from toArray
+        without compromising any usage of the Regular Expression
+
+    @static
+    @property REGEX_HEX
+    @type RegExp
+    @default /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})(\ufffe)?/
+    @since 3.8.0
+    **/
+    REGEX_HEX: REGEX_HEX,
+
+    /**
+        NOTE: `(\ufffe)?` is added to the Regular Expression to carve out a
+        place for the alpha channel that is returned from toArray
+        without compromising any usage of the Regular Expression
+
+    @static
+    @property REGEX_HEX3
+    @type RegExp
+    @default /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})(\ufffe)?/
+    @since 3.8.0
+    **/
+    REGEX_HEX3: REGEX_HEX3,
+
+    /**
+    @static
+    @property REGEX_RGB
+    @type RegExp
+    @default /rgba?\(([0-9]{1,3}), ?([0-9]{1,3}), ?([0-9]{1,3}),? ?([.0-9]{1,3})?\)/
+    @since 3.8.0
+    **/
+    REGEX_RGB: REGEX_RGB,
+
+    re_RGB: REGEX_RGB,
+
+    re_hex: REGEX_HEX,
+
+    re_hex3: REGEX_HEX3,
+
+    /**
+    @static
+    @property STR_HEX
+    @type String
+    @default #{*}{*}{*}
+    @since 3.8.0
+    **/
+    STR_HEX: '#{*}{*}{*}',
+
+    /**
+    @static
+    @property STR_RGB
+    @type String
+    @default rgb({*}, {*}, {*})
+    @since 3.8.0
+    **/
+    STR_RGB: 'rgb({*}, {*}, {*})',
+
+    /**
+    @static
+    @property STR_RGBA
+    @type String
+    @default rgba({*}, {*}, {*}, {*})
+    @since 3.8.0
+    **/
+    STR_RGBA: 'rgba({*}, {*}, {*}, {*})',
+
+    /**
+    @static
+    @property TYPES
+    @type Object
+    @default {'rgb':'rgb', 'rgba':'rgba'}
+    @since 3.8.0
+    **/
+    TYPES: TYPES,
+
+    /**
+    @static
+    @property CONVERTS
+    @type Object
+    @default {}
+    @since 3.8.0
+    **/
+    CONVERTS: CONVERTS,
+
+    /**
+     Converts the provided string to the provided type.
+     You can use the `Y.Color.TYPES` to get a valid `to` type.
+     If the color cannot be converted, the original color will be returned.
+
+     @public
+     @method convert
+     @param {String} str
+     @param {String} to
+     @return {String}
+     @since 3.8.0
+     **/
+    convert: function (str, to) {
+        var convert = Y.Color.CONVERTS[to.toLowerCase()],
+            clr = str;
+
+        if (convert && Y.Color[convert]) {
+            clr = Y.Color[convert](str);
+        }
+
+        return clr;
+    },
+
+    /**
+    Converts provided color value to a hex value string
+
+    @public
+    @method toHex
+    @param {String} str Hex or RGB value string
+    @return {String} returns array of values or CSS string if options.css is true
+    @since 3.8.0
+    **/
+    toHex: function (str) {
+        var clr = Y.Color._convertTo(str, 'hex'),
+            isTransparent = clr.toLowerCase() === 'transparent';
+
+        if (clr.charAt(0) !== '#' && !isTransparent) {
+            clr = '#' + clr;
+        }
+
+        return isTransparent ? clr.toLowerCase() : clr.toUpperCase();
+    },
+
+    /**
+    Converts provided color value to an RGB value string
+    @public
+    @method toRGB
+    @param {String} str Hex or RGB value string
+    @return {String}
+    @since 3.8.0
+    **/
+    toRGB: function (str) {
+        var clr = Y.Color._convertTo(str, 'rgb');
+        return clr.toLowerCase();
+    },
+
+    /**
+    Converts provided color value to an RGB value string
+    @public
+    @method toRGBA
+    @param {String} str Hex or RGB value string
+    @return {String}
+    @since 3.8.0
+    **/
+    toRGBA: function (str) {
+        var clr = Y.Color._convertTo(str, 'rgba' );
+        return clr.toLowerCase();
+    },
+
+    /**
+    Converts the provided color string to an array of values where the
+        last value is the alpha value. Will return an empty array if
+        the provided string is not able to be parsed.
+
+        NOTE: `(\ufffe)?` is added to `HEX` and `HEX3` Regular Expressions to
+        carve out a place for the alpha channel that is returned from
+        toArray without compromising any usage of the Regular Expression
+
+        Y.Color.toArray('fff');              // ['ff', 'ff', 'ff', 1]
+        Y.Color.toArray('rgb(0, 0, 0)');     // ['0', '0', '0', 1]
+        Y.Color.toArray('rgba(0, 0, 0, 0)'); // ['0', '0', '0', 1]
+
+
+
+    @public
+    @method toArray
+    @param {String} str
+    @return {Array}
+    @since 3.8.0
+    **/
+    toArray: function(str) {
+        // parse with regex and return "matches" array
+        var type = Y.Color.findType(str).toUpperCase(),
+            regex,
+            arr,
+            length,
+            lastItem;
+
+        if (type === 'HEX' && str.length < 5) {
+            type = 'HEX3';
+        }
+
+        if (type.charAt(type.length - 1) === 'A') {
+            type = type.slice(0, -1);
+        }
+
+        regex = Y.Color['REGEX_' + type];
+
+        if (regex) {
+            arr = regex.exec(str) || [];
+            length = arr.length;
+
+            if (length) {
+
+                arr.shift();
+                length--;
+
+                if (type === 'HEX3') {
+                    arr[0] += arr[0];
+                    arr[1] += arr[1];
+                    arr[2] += arr[2];
+                }
+
+                lastItem = arr[length - 1];
+                if (!lastItem) {
+                    arr[length - 1] = 1;
+                }
+            }
+        }
+
+        return arr;
+
+    },
+
+    /**
+    Converts the array of values to a string based on the provided template.
+    @public
+    @method fromArray
+    @param {Array} arr
+    @param {String} template
+    @return {String}
+    @since 3.8.0
+    **/
+    fromArray: function(arr, template) {
+        arr = arr.concat();
+
+        if (typeof template === 'undefined') {
+            return arr.join(', ');
+        }
+
+        var replace = '{*}';
+
+        template = Y.Color['STR_' + template.toUpperCase()];
+
+        if (arr.length === 3 && template.match(/\{\*\}/g).length === 4) {
+            arr.push(1);
+        }
+
+        while ( template.indexOf(replace) >= 0 && arr.length > 0) {
+            template = template.replace(replace, arr.shift());
+        }
+
+        return template;
+    },
+
+    /**
+    Finds the value type based on the str value provided.
+    @public
+    @method findType
+    @param {String} str
+    @return {String}
+    @since 3.8.0
+    **/
+    findType: function (str) {
+        if (Y.Color.KEYWORDS[str]) {
+            return 'keyword';
+        }
+
+        var index = str.indexOf('('),
+            key;
+
+        if (index > 0) {
+            key = str.substr(0, index);
+        }
+
+        if (key && Y.Color.TYPES[key.toUpperCase()]) {
+            return Y.Color.TYPES[key.toUpperCase()];
+        }
+
+        return 'hex';
+
+    }, // return 'keyword', 'hex', 'rgb'
+
+    /**
+    Retrives the alpha channel from the provided string. If no alpha
+        channel is present, `1` will be returned.
+    @protected
+    @method _getAlpha
+    @param {String} clr
+    @return {Number}
+    @since 3.8.0
+    **/
+    _getAlpha: function (clr) {
+        var alpha,
+            arr = Y.Color.toArray(clr);
+
+        if (arr.length > 3) {
+            alpha = arr.pop();
+        }
+
+        return +alpha || 1;
+    },
+
+    /**
+    Returns the hex value string if found in the KEYWORDS object
+    @protected
+    @method _keywordToHex
+    @param {String} clr
+    @return {String}
+    @since 3.8.0
+    **/
+    _keywordToHex: function (clr) {
+        var keyword = Y.Color.KEYWORDS[clr];
+
+        if (keyword) {
+            return keyword;
+        }
+    },
+
+    /**
+    Converts the provided color string to the value type provided as `to`
+    @protected
+    @method _convertTo
+    @param {String} clr
+    @param {String} to
+    @return {String}
+    @since 3.8.0
+    **/
+    _convertTo: function(clr, to) {
+
+        if (clr === 'transparent') {
+            return clr;
+        }
+
+        var from = Y.Color.findType(clr),
+            originalTo = to,
+            needsAlpha,
+            alpha,
+            method,
+            ucTo;
+
+        if (from === 'keyword') {
+            clr = Y.Color._keywordToHex(clr);
+            from = 'hex';
+        }
+
+        if (from === 'hex' && clr.length < 5) {
+            if (clr.charAt(0) === '#') {
+                clr = clr.substr(1);
+            }
+
+            clr = '#' + clr.charAt(0) + clr.charAt(0) +
+                        clr.charAt(1) + clr.charAt(1) +
+                        clr.charAt(2) + clr.charAt(2);
+        }
+
+        if (from === to) {
+            return clr;
+        }
+
+        if (from.charAt(from.length - 1) === 'a') {
+            from = from.slice(0, -1);
+        }
+
+        needsAlpha = (to.charAt(to.length - 1) === 'a');
+        if (needsAlpha) {
+            to = to.slice(0, -1);
+            alpha = Y.Color._getAlpha(clr);
+        }
+
+        ucTo = to.charAt(0).toUpperCase() + to.substr(1).toLowerCase();
+        method = Y.Color['_' + from + 'To' + ucTo ];
+
+        // check to see if need conversion to rgb first
+        // check to see if there is a direct conversion method
+        // convertions are: hex <-> rgb <-> hsl
+        if (!method) {
+            if (from !== 'rgb' && to !== 'rgb') {
+                clr = Y.Color['_' + from + 'ToRgb'](clr);
+                from = 'rgb';
+                method = Y.Color['_' + from + 'To' + ucTo ];
+            }
+        }
+
+        if (method) {
+            clr = ((method)(clr, needsAlpha));
+        }
+
+        // process clr from arrays to strings after conversions if alpha is needed
+        if (needsAlpha) {
+            if (!Y.Lang.isArray(clr)) {
+                clr = Y.Color.toArray(clr);
+            }
+            clr.push(alpha);
+            clr = Y.Color.fromArray(clr, originalTo.toUpperCase());
+        }
+
+        return clr;
+    },
+
+    /**
+    Processes the hex string into r, g, b values. Will return values as
+        an array, or as an rgb string.
+    @protected
+    @method _hexToRgb
+    @param {String} str
+    @param {Boolean} [toArray]
+    @return {String|Array}
+    @since 3.8.0
+    **/
+    _hexToRgb: function (str, toArray) {
+        var r, g, b;
+
+        /*jshint bitwise:false*/
+        if (str.charAt(0) === '#') {
+            str = str.substr(1);
+        }
+
+        str = parseInt(str, 16);
+
+        r = str >> 16;
+        g = str >> 8 & 0xFF;
+        b = str & 0xFF;
+
+        if (toArray) {
+            return [r, g, b];
+        }
+
+        return 'rgb(' + r + ', ' + g + ', ' + b + ')';
+    },
+
+    /**
+    Processes the rgb string into r, g, b values. Will return values as
+        an array, or as a hex string.
+    @protected
+    @method _rgbToHex
+    @param {String} str
+    @param {Boolean} [toArray]
+    @return {String|Array}
+    @since 3.8.0
+    **/
+    _rgbToHex: function (str) {
+        /*jshint bitwise:false*/
+        var rgb = Y.Color.toArray(str),
+            hex = rgb[2] | (rgb[1] << 8) | (rgb[0] << 16);
+
+        hex = (+hex).toString(16);
+
+        while (hex.length < 6) {
+            hex = '0' + hex;
+        }
+
+        return '#' + hex;
+    }
+
+};
+
+
+
+}, '@VERSION@', {"requires": ["yui-base"]});

package/build/color-base/color-base-min.js

@@ -0,0 +1 @@
+YUI.add("color-base",function(e,t){var n=/^#?([\da-fA-F]{2})([\da-fA-F]{2})([\da-fA-F]{2})(\ufffe)?/,r=/^#?([\da-fA-F]{1})([\da-fA-F]{1})([\da-fA-F]{1})(\ufffe)?/,i=/rgba?\(([\d]{1,3}), ?([\d]{1,3}), ?([\d]{1,3}),? ?([.\d]*)?\)/,s={HEX:"hex",RGB:"rgb",RGBA:"rgba"},o={hex:"toHex",rgb:"toRGB",rgba:"toRGBA"};e.Color={KEYWORDS:{black:"000",silver:"c0c0c0",gray:"808080",white:"fff",maroon:"800000",red:"f00",purple:"800080",fuchsia:"f0f",green:"008000",lime:"0f0",olive:"808000",yellow:"ff0",navy:"000080",blue:"00f",teal:"008080",aqua:"0ff"},REGEX_HEX:n,REGEX_HEX3:r,REGEX_RGB:i,re_RGB:i,re_hex:n,re_hex3:r,STR_HEX:"#{*}{*}{*}",STR_RGB:"rgb({*}, {*}, {*})",STR_RGBA:"rgba({*}, {*}, {*}, {*})",TYPES:s,CONVERTS:o,convert:function(t,n){var r=e.Color.CONVERTS[n.toLowerCase()],i=t;return r&&e.Color[r]&&(i=e.Color[r](t)),i},toHex:function(t){var n=e.Color._convertTo(t,"hex"),r=n.toLowerCase()==="transparent";return n.charAt(0)!=="#"&&!r&&(n="#"+n),r?n.toLowerCase():n.toUpperCase()},toRGB:function(t){var n=e.Color._convertTo(t,"rgb");return n.toLowerCase()},toRGBA:function(t){var n=e.Color._convertTo(t,"rgba");return n.toLowerCase()},toArray:function(t){var n=e.Color.findType(t).toUpperCase(),r,i,s,o;return n==="HEX"&&t.length<5&&(n="HEX3"),n.charAt(n.length-1)==="A"&&(n=n.slice(0,-1)),r=e.Color["REGEX_"+n],r&&(i=r.exec(t)||[],s=i.length,s&&(i.shift(),s--,n==="HEX3"&&(i[0]+=i[0],i[1]+=i[1],i[2]+=i[2]),o=i[s-1],o||(i[s-1]=1))),i},fromArray:function(t,n){t=t.concat();if(typeof n=="undefined")return t.join(", ");var r="{*}";n=e.Color["STR_"+n.toUpperCase()],t.length===3&&n.match(/\{\*\}/g).length===4&&t.push(1);while(n.indexOf(r)>=0&&t.length>0)n=n.replace(r,t.shift());return n},findType:function(t){if(e.Color.KEYWORDS[t])return"keyword";var n=t.indexOf("("),r;return n>0&&(r=t.substr(0,n)),r&&e.Color.TYPES[r.toUpperCase()]?e.Color.TYPES[r.toUpperCase()]:"hex"},_getAlpha:function(t){var n,r=e.Color.toArray(t);return r.length>3&&(n=r.pop()),+n||1},_keywordToHex:function(t){var n=e.Color.KEYWORDS[t];if(n)return n},_convertTo:function(t,n){if(t==="transparent")return t;var r=e.Color.findType(t),i=n,s,o,u,a;return r==="keyword"&&(t=e.Color._keywordToHex(t),r="hex"),r==="hex"&&t.length<5&&(t.charAt(0)==="#"&&(t=t.substr(1)),t="#"+t.charAt(0)+t.charAt(0)+t.charAt(1)+t.charAt(1)+t.charAt(2)+t.charAt(2)),r===n?t:(r.charAt(r.length-1)==="a"&&(r=r.slice(0,-1)),s=n.charAt(n.length-1)==="a",s&&(n=n.slice(0,-1),o=e.Color._getAlpha(t)),a=n.charAt(0).toUpperCase()+n.substr(1).toLowerCase(),u=e.Color["_"+r+"To"+a],u||r!=="rgb"&&n!=="rgb"&&(t=e.Color["_"+r+"ToRgb"](t),r="rgb",u=e.Color["_"+r+"To"+a]),u&&(t=u(t,s)),s&&(e.Lang.isArray(t)||(t=e.Color.toArray(t)),t.push(o),t=e.Color.fromArray(t,i.toUpperCase())),t)},_hexToRgb:function(e,t){var n,r,i;return e.charAt(0)==="#"&&(e=e.substr(1)),e=parseInt(e,16),n=e>>16,r=e>>8&255,i=e&255,t?[n,r,i]:"rgb("+n+", "+r+", "+i+")"},_rgbToHex:function(t){var n=e.Color.toArray(t),r=n[2]|n[1]<<8|n[0]<<16;r=(+r).toString(16);while(r.length<6)r="0"+r;return"#"+r}}},"@VERSION@",{requires:["yui-base"]});