planning

node_modules/ol/color.js

@@ -0,0 +1,222 @@
+/**
+ * @module ol/color
+ */
+import { assert } from './asserts.js';
+import { clamp } from './math.js';
+/**
+ * A color represented as a short array [red, green, blue, alpha].
+ * red, green, and blue should be integers in the range 0..255 inclusive.
+ * alpha should be a float in the range 0..1 inclusive. If no alpha value is
+ * given then `1` will be used.
+ * @typedef {Array<number>} Color
+ * @api
+ */
+/**
+ * This RegExp matches # followed by 3, 4, 6, or 8 hex digits.
+ * @const
+ * @type {RegExp}
+ * @private
+ */
+var HEX_COLOR_RE_ = /^#([a-f0-9]{3}|[a-f0-9]{4}(?:[a-f0-9]{2}){0,2})$/i;
+/**
+ * Regular expression for matching potential named color style strings.
+ * @const
+ * @type {RegExp}
+ * @private
+ */
+var NAMED_COLOR_RE_ = /^([a-z]*)$|^hsla?\(.*\)$/i;
+/**
+ * Return the color as an rgba string.
+ * @param {Color|string} color Color.
+ * @return {string} Rgba string.
+ * @api
+ */
+export function asString(color) {
+    if (typeof color === 'string') {
+        return color;
+    }
+    else {
+        return toString(color);
+    }
+}
+/**
+ * Return named color as an rgba string.
+ * @param {string} color Named color.
+ * @return {string} Rgb string.
+ */
+function fromNamed(color) {
+    var el = document.createElement('div');
+    el.style.color = color;
+    if (el.style.color !== '') {
+        document.body.appendChild(el);
+        var rgb = getComputedStyle(el).color;
+        document.body.removeChild(el);
+        return rgb;
+    }
+    else {
+        return '';
+    }
+}
+/**
+ * @param {string} s String.
+ * @return {Color} Color.
+ */
+export var fromString = (function () {
+    // We maintain a small cache of parsed strings.  To provide cheap LRU-like
+    // semantics, whenever the cache grows too large we simply delete an
+    // arbitrary 25% of the entries.
+    /**
+     * @const
+     * @type {number}
+     */
+    var MAX_CACHE_SIZE = 1024;
+    /**
+     * @type {Object<string, Color>}
+     */
+    var cache = {};
+    /**
+     * @type {number}
+     */
+    var cacheSize = 0;
+    return (
+    /**
+     * @param {string} s String.
+     * @return {Color} Color.
+     */
+    function (s) {
+        var color;
+        if (cache.hasOwnProperty(s)) {
+            color = cache[s];
+        }
+        else {
+            if (cacheSize >= MAX_CACHE_SIZE) {
+                var i = 0;
+                for (var key in cache) {
+                    if ((i++ & 3) === 0) {
+                        delete cache[key];
+                        --cacheSize;
+                    }
+                }
+            }
+            color = fromStringInternal_(s);
+            cache[s] = color;
+            ++cacheSize;
+        }
+        return color;
+    });
+})();
+/**
+ * Return the color as an array. This function maintains a cache of calculated
+ * arrays which means the result should not be modified.
+ * @param {Color|string} color Color.
+ * @return {Color} Color.
+ * @api
+ */
+export function asArray(color) {
+    if (Array.isArray(color)) {
+        return color;
+    }
+    else {
+        return fromString(color);
+    }
+}
+/**
+ * @param {string} s String.
+ * @private
+ * @return {Color} Color.
+ */
+function fromStringInternal_(s) {
+    var r, g, b, a, color;
+    if (NAMED_COLOR_RE_.exec(s)) {
+        s = fromNamed(s);
+    }
+    if (HEX_COLOR_RE_.exec(s)) {
+        // hex
+        var n = s.length - 1; // number of hex digits
+        var d = // number of digits per channel
+         void 0; // number of digits per channel
+        if (n <= 4) {
+            d = 1;
+        }
+        else {
+            d = 2;
+        }
+        var hasAlpha = n === 4 || n === 8;
+        r = parseInt(s.substr(1 + 0 * d, d), 16);
+        g = parseInt(s.substr(1 + 1 * d, d), 16);
+        b = parseInt(s.substr(1 + 2 * d, d), 16);
+        if (hasAlpha) {
+            a = parseInt(s.substr(1 + 3 * d, d), 16);
+        }
+        else {
+            a = 255;
+        }
+        if (d == 1) {
+            r = (r << 4) + r;
+            g = (g << 4) + g;
+            b = (b << 4) + b;
+            if (hasAlpha) {
+                a = (a << 4) + a;
+            }
+        }
+        color = [r, g, b, a / 255];
+    }
+    else if (s.indexOf('rgba(') == 0) {
+        // rgba()
+        color = s.slice(5, -1).split(',').map(Number);
+        normalize(color);
+    }
+    else if (s.indexOf('rgb(') == 0) {
+        // rgb()
+        color = s.slice(4, -1).split(',').map(Number);
+        color.push(1);
+        normalize(color);
+    }
+    else {
+        assert(false, 14); // Invalid color
+    }
+    return color;
+}
+/**
+ * TODO this function is only used in the test, we probably shouldn't export it
+ * @param {Color} color Color.
+ * @return {Color} Clamped color.
+ */
+export function normalize(color) {
+    color[0] = clamp((color[0] + 0.5) | 0, 0, 255);
+    color[1] = clamp((color[1] + 0.5) | 0, 0, 255);
+    color[2] = clamp((color[2] + 0.5) | 0, 0, 255);
+    color[3] = clamp(color[3], 0, 1);
+    return color;
+}
+/**
+ * @param {Color} color Color.
+ * @return {string} String.
+ */
+export function toString(color) {
+    var r = color[0];
+    if (r != (r | 0)) {
+        r = (r + 0.5) | 0;
+    }
+    var g = color[1];
+    if (g != (g | 0)) {
+        g = (g + 0.5) | 0;
+    }
+    var b = color[2];
+    if (b != (b | 0)) {
+        b = (b + 0.5) | 0;
+    }
+    var a = color[3] === undefined ? 1 : Math.round(color[3] * 100) / 100;
+    return 'rgba(' + r + ',' + g + ',' + b + ',' + a + ')';
+}
+/**
+ * @param {string} s String.
+ * @return {boolean} Whether the string is actually a valid color
+ */
+export function isStringColor(s) {
+    if (NAMED_COLOR_RE_.test(s)) {
+        s = fromNamed(s);
+    }
+    return (HEX_COLOR_RE_.test(s) || s.indexOf('rgba(') === 0 || s.indexOf('rgb(') === 0);
+}
+//# sourceMappingURL=color.js.map