@nativescript/core 8.9.0-alpha.3 → 8.9.0-napi-es5.0

package/color/color-common.js

@@ -1,14 +1,18 @@
 import * as types from '../utils/types';
 import * as knownColors from './known-colors';
 import { Color } from '.';
-const SHARP = '#';
-const HEX_REGEX = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)|(^#[0-9A-F]{8}$)|(^#[0-9A-F]{4}$)/i;
-export class ColorBase {
-    constructor(...args) {
+var SHARP = '#';
+var HEX_REGEX = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)|(^#[0-9A-F]{8}$)|(^#[0-9A-F]{4}$)/i;
+var ColorBase = /** @class */ (function () {
+    function ColorBase() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
         if (args.length === 1) {
-            const arg = args[0];
+            var arg = args[0];
             if (types.isString(arg)) {
-                const lowered = arg.toLowerCase();
+                var lowered = arg.toLowerCase();
                 if (isRgbOrRgba(lowered)) {
                     this._argb = argbFromRgbOrRgba(lowered);
                 }
@@ -20,7 +24,7 @@ export class ColorBase {
                 }
                 else if (knownColors.isKnownName(lowered)) {
                     // The parameter is a known color name
-                    const argb = knownColors.getKnownColor(lowered);
+                    var argb = knownColors.getKnownColor(lowered);
                     this._name = arg;
                     this._argb = argb;
                 }
@@ -50,15 +54,15 @@ export class ColorBase {
             }
         }
         else if (args.length >= 4) {
-            const a = args[0];
+            var a = args[0];
             switch (args[4]) {
                 case 'hsl': {
-                    const { r, g, b } = hslToRgb(args[1], args[2], args[3]);
+                    var _a = hslToRgb(args[1], args[2], args[3]), r = _a.r, g = _a.g, b = _a.b;
                     this._argb = (a & 0xff) * 0x01000000 + (r & 0xff) * 0x00010000 + (g & 0xff) * 0x00000100 + (b & 0xff) * 0x00000001;
                     break;
                 }
                 case 'hsv': {
-                    const { r, g, b } = hsvToRgb(args[1], args[2], args[3]);
+                    var _b = hsvToRgb(args[1], args[2], args[3]), r = _b.r, g = _b.g, b = _b.b;
                     this._argb = (a & 0xff) * 0x01000000 + (r & 0xff) * 0x00010000 + (g & 0xff) * 0x00000100 + (b & 0xff) * 0x00000001;
                     break;
                 }
@@ -71,41 +75,77 @@ export class ColorBase {
             throw new Error('Expected 1 or 4 constructor parameters.');
         }
     }
-    get a() {
-        return (this._argb / 0x01000000) & 0xff;
-    }
-    get r() {
-        return (this._argb / 0x00010000) & 0xff;
-    }
-    get g() {
-        return (this._argb / 0x00000100) & 0xff;
-    }
-    get b() {
-        return (this._argb / 0x00000001) & 0xff;
-    }
-    get argb() {
-        return this._argb;
-    }
-    get hex() {
-        let result = SHARP + ('000000' + (this._argb & 0xffffff).toString(16)).toUpperCase().slice(-6);
-        if (this.a !== 0xff) {
-            return (result += ('00' + this.a.toString(16).toUpperCase()).slice(-2));
-        }
-        return result;
-    }
-    get name() {
-        return this._name;
-    }
-    get ios() {
-        return undefined;
-    }
-    get android() {
-        return undefined;
-    }
-    _argbFromString(hex) {
+    Object.defineProperty(ColorBase.prototype, "a", {
+        get: function () {
+            return (this._argb / 0x01000000) & 0xff;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "r", {
+        get: function () {
+            return (this._argb / 0x00010000) & 0xff;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "g", {
+        get: function () {
+            return (this._argb / 0x00000100) & 0xff;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "b", {
+        get: function () {
+            return (this._argb / 0x00000001) & 0xff;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "argb", {
+        get: function () {
+            return this._argb;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "hex", {
+        get: function () {
+            var result = SHARP + ('000000' + (this._argb & 0xffffff).toString(16)).toUpperCase().slice(-6);
+            if (this.a !== 0xff) {
+                return (result += ('00' + this.a.toString(16).toUpperCase()).slice(-2));
+            }
+            return result;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "name", {
+        get: function () {
+            return this._name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "ios", {
+        get: function () {
+            return undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ColorBase.prototype, "android", {
+        get: function () {
+            return undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ColorBase.prototype._argbFromString = function (hex) {
         // always called as SHARP as first char
         hex = hex.substring(1);
-        const length = hex.length;
+        var length = hex.length;
         // first we normalize
         if (length === 3) {
             hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
@@ -113,7 +153,7 @@ export class ColorBase {
         else if (length === 4) {
             hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2] + hex[3] + hex[3];
         }
-        let intVal = parseInt(hex, 16);
+        var intVal = parseInt(hex, 16);
         if (hex.length === 6) {
             // add the alpha component since the provided string is RRGGBB
             intVal = (intVal & 0x00ffffff) + 0xff000000;
@@ -121,15 +161,15 @@ export class ColorBase {
         else {
             // the new format is #RRGGBBAA
             // we need to shift the alpha value to 0x01000000 position
-            const a = (intVal / 0x00000001) & 0xff;
+            var a = (intVal / 0x00000001) & 0xff;
             intVal = (intVal >>> 8) + (a & 0xff) * 0x01000000;
         }
         return intVal;
-    }
-    equals(value) {
+    };
+    ColorBase.prototype.equals = function (value) {
         return value && this.argb === value.argb;
-    }
-    static equals(value1, value2) {
+    };
+    ColorBase.equals = function (value1, value2) {
         // both values are falsy
         if (!value1 && !value2) {
             return true;
@@ -139,65 +179,65 @@ export class ColorBase {
             return false;
         }
         return value1.equals(value2);
-    }
-    static isValid(value) {
+    };
+    ColorBase.isValid = function (value) {
         if (value instanceof Color) {
             return true;
         }
         if (!types.isString(value)) {
             return false;
         }
-        const lowered = value.toLowerCase();
+        var lowered = value.toLowerCase();
         if (knownColors.isKnownName(lowered)) {
             return true;
         }
         return HEX_REGEX.test(value) || isRgbOrRgba(lowered) || isHslOrHsla(lowered);
-    }
-    static fromHSL(a, h, s, l) {
+    };
+    ColorBase.fromHSL = function (a, h, s, l) {
         return new Color(a, h, s, l, 'hsl');
-    }
-    static fromHSV(a, h, s, l) {
+    };
+    ColorBase.fromHSV = function (a, h, s, l) {
         return new Color(a, h, s, l, 'hsv');
-    }
-    toString() {
+    };
+    ColorBase.prototype.toString = function () {
         return this.hex;
-    }
+    };
     /**
      * @param {UIColor} value
      */
-    static fromIosColor(value) {
+    ColorBase.fromIosColor = function (value) {
         return undefined;
-    }
+    };
     /**
      * return true if brightness < 128
      *
      */
-    isDark() {
+    ColorBase.prototype.isDark = function () {
         return this.getBrightness() < 128;
-    }
+    };
     /**
      * return true if brightness >= 128
      *
      */
-    isLight() {
+    ColorBase.prototype.isLight = function () {
         return !this.isDark();
-    }
+    };
     /**
      * return the [brightness](http://www.w3.org/TR/AERT#color-contrast)
      *
      */
-    getBrightness() {
+    ColorBase.prototype.getBrightness = function () {
         return (this.r * 299 + this.g * 587 + this.b * 114) / 1000;
-    }
+    };
     /**
      * return the [luminance](http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef)
      *
      */
-    getLuminance() {
-        let R, G, B;
-        const RsRGB = this.r / 255;
-        const GsRGB = this.g / 255;
-        const BsRGB = this.b / 255;
+    ColorBase.prototype.getLuminance = function () {
+        var R, G, B;
+        var RsRGB = this.r / 255;
+        var GsRGB = this.g / 255;
+        var BsRGB = this.b / 255;
         if (RsRGB <= 0.03928) {
             R = RsRGB / 12.92;
         }
@@ -217,147 +257,150 @@ export class ColorBase {
             B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
         }
         return 0.2126 * R + 0.7152 * G + 0.0722 * B;
-    }
+    };
     /**
      * Return this color (as a new Color instance) with the provided alpha
      *
      * @param alpha (between 0 and 255)
      */
-    setAlpha(a) {
+    ColorBase.prototype.setAlpha = function (a) {
         return new Color(a, this.r, this.g, this.b);
-    }
+    };
     /**
      * return the hsl representation of the color
      *
      */
-    toHsl() {
-        return { ...rgbToHsl(this.r, this.g, this.b), a: this.a };
-    }
+    ColorBase.prototype.toHsl = function () {
+        return __assign(__assign({}, rgbToHsl(this.r, this.g, this.b)), { a: this.a });
+    };
     /**
      * return the [CSS hsv](https://www.w3schools.com/Css/css_colors_hsl.asp) representation of the color
      *
      */
-    toHslString() {
-        const hsl = rgbToHsl(this.r, this.g, this.b);
-        const h = Math.round(hsl.h), s = Math.round(hsl.s), l = Math.round(hsl.l);
-        const a = this.a;
+    ColorBase.prototype.toHslString = function () {
+        var hsl = rgbToHsl(this.r, this.g, this.b);
+        var h = Math.round(hsl.h), s = Math.round(hsl.s), l = Math.round(hsl.l);
+        var a = this.a;
         return a == 255 ? 'hsl(' + h + ', ' + s + '%, ' + l + '%)' : 'hsla(' + h + ', ' + s + '%, ' + l + '%, ' + (a / 255).toFixed(2) + ')';
-    }
+    };
     /**
      * return the hsv representation of the color
      *
      */
-    toHsv() {
-        return { ...rgbToHsv(this.r, this.g, this.b), a: this.a };
-    }
+    ColorBase.prototype.toHsv = function () {
+        return __assign(__assign({}, rgbToHsv(this.r, this.g, this.b)), { a: this.a });
+    };
     /**
      * return the [CSS hsv](https://www.w3schools.com/Css/css_colors_rgb.asp) representation of the color
      *
      */
-    toHsvString() {
-        const hsv = rgbToHsv(this.r, this.g, this.b);
-        const h = Math.round(hsv.h * 360), s = Math.round(hsv.s * 100), v = Math.round(hsv.v * 100);
-        const a = this.a;
+    ColorBase.prototype.toHsvString = function () {
+        var hsv = rgbToHsv(this.r, this.g, this.b);
+        var h = Math.round(hsv.h * 360), s = Math.round(hsv.s * 100), v = Math.round(hsv.v * 100);
+        var a = this.a;
         return a == 255 ? 'hsv(' + h + ', ' + s + '%, ' + v + '%)' : 'hsva(' + h + ', ' + s + '%, ' + v + '%, ' + (a / 255).toFixed(2) + ')';
-    }
+    };
     /**
      * return the [CSS rgb](https://www.w3schools.com/Css/css_colors_rgb.asp) representation of the color
      *
      */
-    toRgbString() {
-        const a = this.a;
+    ColorBase.prototype.toRgbString = function () {
+        var a = this.a;
         return a == 1 ? 'rgb(' + Math.round(this.r) + ', ' + Math.round(this.g) + ', ' + Math.round(this.b) + ')' : 'rgba(' + Math.round(this.r) + ', ' + Math.round(this.g) + ', ' + Math.round(this.b) + ', ' + (a / 255).toFixed(2) + ')';
-    }
+    };
     /**
      *  Desaturate the color a given amount, from 0 to 100. Providing 100 will is the same as calling greyscale.
      *
      * @param amount (between 0 and 100)
      */
-    desaturate(amount) {
+    ColorBase.prototype.desaturate = function (amount) {
         amount = amount === 0 ? 0 : amount || 10;
-        const hsl = rgbToHsl(this.r, this.g, this.b);
+        var hsl = rgbToHsl(this.r, this.g, this.b);
         return Color.fromHSL(this.a, hsl.h, Math.min(100, Math.max(0, hsl.s - amount)), hsl.l);
-    }
+    };
     /**
      * Saturate the color a given amount, from 0 to 100.
      *
      * @param amount (between 0 and 100)
      */
-    saturate(amount) {
+    ColorBase.prototype.saturate = function (amount) {
         amount = amount === 0 ? 0 : amount || 10;
-        const hsl = rgbToHsl(this.r, this.g, this.b);
+        var hsl = rgbToHsl(this.r, this.g, this.b);
         return Color.fromHSL(this.a, hsl.h, Math.min(100, Math.max(0, hsl.s + amount)), hsl.l);
-    }
+    };
     /**
      * Completely desaturates a color into greyscale. Same as calling desaturate(100).
      *
      */
-    greyscale() {
+    ColorBase.prototype.greyscale = function () {
         return this.desaturate(100);
-    }
+    };
     /**
      * Lighten the color a given amount, from 0 to 100. Providing 100 will always return white.
      *
      * @param amount (between 0 and 100)
      */
-    lighten(amount) {
+    ColorBase.prototype.lighten = function (amount) {
         amount = amount === 0 ? 0 : amount || 10;
-        const hsl = rgbToHsl(this.r, this.g, this.b);
+        var hsl = rgbToHsl(this.r, this.g, this.b);
         return Color.fromHSL(this.a, hsl.h, hsl.s, Math.min(100, Math.max(0, hsl.l + amount)));
-    }
+    };
     /**
      * Brighten the color a given amount, from 0 to 100.
      *
      * @param amount (between 0 and 100)
      */
-    brighten(amount) {
+    ColorBase.prototype.brighten = function (amount) {
         amount = amount === 0 ? 0 : amount || 10;
-        const r = Math.max(0, Math.min(255, this.r - Math.round(255 * -(amount / 100))));
-        const g = Math.max(0, Math.min(255, this.g - Math.round(255 * -(amount / 100))));
-        const b = Math.max(0, Math.min(255, this.b - Math.round(255 * -(amount / 100))));
+        var r = Math.max(0, Math.min(255, this.r - Math.round(255 * -(amount / 100))));
+        var g = Math.max(0, Math.min(255, this.g - Math.round(255 * -(amount / 100))));
+        var b = Math.max(0, Math.min(255, this.b - Math.round(255 * -(amount / 100))));
         return new Color(this.a, r, g, b);
-    }
+    };
     /**
      * Darken the color a given amount, from 0 to 100. Providing 100 will always return black.
      *
      * @param amount (between 0 and 100)
      */
-    darken(amount) {
+    ColorBase.prototype.darken = function (amount) {
         amount = amount === 0 ? 0 : amount || 10;
-        const hsl = rgbToHsl(this.r, this.g, this.b);
+        var hsl = rgbToHsl(this.r, this.g, this.b);
         return Color.fromHSL(this.a, hsl.h, hsl.s, Math.min(100, Math.max(0, hsl.l - amount)));
-    }
+    };
     /**
      * Spin the hue a given amount, from -360 to 360. Calling with 0, 360, or -360 will do nothing (since it sets the hue back to what it was before).
      *
      * @param amount (between -360 and 360)
      */
-    spin(amount) {
-        const hsl = this.toHsl();
-        const hue = (hsl.h + amount) % 360;
+    ColorBase.prototype.spin = function (amount) {
+        var hsl = this.toHsl();
+        var hue = (hsl.h + amount) % 360;
         hsl.h = hue < 0 ? 360 + hue : hue;
         return Color.fromHSL(this.a, hsl.h, hsl.s, hsl.l);
-    }
+    };
     /**
      * returns the color complement
      *
      */
-    complement() {
-        const hsl = this.toHsl();
+    ColorBase.prototype.complement = function () {
+        var hsl = this.toHsl();
         hsl.h = (hsl.h + 180) % 360;
         return Color.fromHSL(this.a, hsl.h, hsl.s, hsl.l);
-    }
-    static mix(color1, color2, amount = 50) {
-        const p = amount / 100;
-        const rgba = {
+    };
+    ColorBase.mix = function (color1, color2, amount) {
+        if (amount === void 0) { amount = 50; }
+        var p = amount / 100;
+        var rgba = {
             r: (color2.r - color1.r) * p + color1.r,
             g: (color2.g - color1.g) * p + color1.g,
             b: (color2.b - color1.b) * p + color1.b,
             a: (color2.a - color1.a) * p + color1.a,
         };
         return new Color(rgba.a, rgba.r, rgba.g, rgba.b);
-    }
-}
+    };
+    return ColorBase;
+}());
+export { ColorBase };
 function isRgbOrRgba(value) {
     return (value.startsWith('rgb(') || value.startsWith('rgba(')) && value.endsWith(')');
 }
@@ -368,18 +411,18 @@ function isHsvOrHsva(value) {
     return (value.startsWith('hsv') || value.startsWith('hsva(')) && value.endsWith(')');
 }
 function parseColorWithAlpha(value) {
-    const separator = value.indexOf(',') !== -1 ? ',' : ' ';
-    const parts = value
+    var separator = value.indexOf(',') !== -1 ? ',' : ' ';
+    var parts = value
         .replace(/(rgb|hsl|hsv)a?\(/, '')
         .replace(')', '')
         .replace(/\//, ' ')
         .replace(/%/g, '')
         .split(separator)
-        .filter((part) => Boolean(part.length));
-    let f = 255;
-    let s = 255;
-    let t = 255;
-    let a = 255;
+        .filter(function (part) { return Boolean(part.length); });
+    var f = 255;
+    var s = 255;
+    var t = 255;
+    var a = 255;
     if (parts[0]) {
         f = parseFloat(parts[0].trim());
     }
@@ -392,20 +435,20 @@ function parseColorWithAlpha(value) {
     if (parts[3]) {
         a = Math.round(parseFloat(parts[3].trim()) * 255);
     }
-    return { f, s, t, a };
+    return { f: f, s: s, t: t, a: a };
 }
 function argbFromRgbOrRgba(value) {
-    const { f: r, s: g, t: b, a } = parseColorWithAlpha(value);
+    var _a = parseColorWithAlpha(value), r = _a.f, g = _a.s, b = _a.t, a = _a.a;
     return (a & 0xff) * 0x01000000 + (r & 0xff) * 0x00010000 + (g & 0xff) * 0x00000100 + (b & 0xff);
 }
 function argbFromHslOrHsla(value) {
-    const { f: h, s: s, t: l, a } = parseColorWithAlpha(value);
-    const { r, g, b } = hslToRgb(h, s, l);
+    var _a = parseColorWithAlpha(value), h = _a.f, s = _a.s, l = _a.t, a = _a.a;
+    var _b = hslToRgb(h, s, l), r = _b.r, g = _b.g, b = _b.b;
     return (a & 0xff) * 0x01000000 + (r & 0xff) * 0x00010000 + (g & 0xff) * 0x00000100 + (b & 0xff);
 }
 function argbFromHsvOrHsva(value) {
-    const { f: h, s: s, t: v, a } = parseColorWithAlpha(value);
-    const { r, g, b } = hsvToRgb(h, s, v);
+    var _a = parseColorWithAlpha(value), h = _a.f, s = _a.s, v = _a.t, a = _a.a;
+    var _b = hsvToRgb(h, s, v), r = _b.r, g = _b.g, b = _b.b;
     return (a & 0xff) * 0x01000000 + (r & 0xff) * 0x00010000 + (g & 0xff) * 0x00000100 + (b & 0xff);
 }
 // `rgbToHsl`
@@ -416,14 +459,14 @@ function rgbToHsl(r, g, b) {
     r /= 255;
     g /= 255;
     b /= 255;
-    const max = Math.max(r, g, b), min = Math.min(r, g, b);
-    let h, s;
-    const l = (max + min) / 2;
+    var max = Math.max(r, g, b), min = Math.min(r, g, b);
+    var h, s;
+    var l = (max + min) / 2;
     if (max == min) {
         h = s = 0; // achromatic
     }
     else {
-        const d = max - min;
+        var d = max - min;
         s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
         switch (max) {
             case r:
@@ -458,16 +501,16 @@ function hue2rgb(p, q, t) {
 // *Assumes:* h is contained in  [0, 360] and s and l are contained  [0, 100]
 // *Returns:* { r, g, b } in the set [0, 255]
 function hslToRgb(h1, s1, l1) {
-    const h = (h1 % 360) / 360;
-    const s = s1 / 100;
-    const l = l1 / 100;
-    let r, g, b;
+    var h = (h1 % 360) / 360;
+    var s = s1 / 100;
+    var l = l1 / 100;
+    var r, g, b;
     if (s === 0) {
         r = g = b = l; // achromatic
     }
     else {
-        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-        const p = 2 * l - q;
+        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        var p = 2 * l - q;
         r = hue2rgb(p, q, h + 1 / 3);
         g = hue2rgb(p, q, h);
         b = hue2rgb(p, q, h - 1 / 3);
@@ -482,11 +525,11 @@ function rgbToHsv(r, g, b) {
     r /= 255;
     g /= 255;
     b /= 255;
-    const max = Math.max(r, g, b), min = Math.min(r, g, b);
-    let h;
-    const v = max;
-    const d = max - min;
-    const s = max === 0 ? 0 : d / max;
+    var max = Math.max(r, g, b), min = Math.min(r, g, b);
+    var h;
+    var v = max;
+    var d = max - min;
+    var s = max === 0 ? 0 : d / max;
     if (max == min) {
         h = 0; // achromatic
     }
@@ -511,10 +554,10 @@ function rgbToHsv(r, g, b) {
 // *Assumes:* h is contained in [0, 360] and s and v are contained [0, 100]
 // *Returns:* { r, g, b } in the set [0, 255]
 function hsvToRgb(h1, s1, v1) {
-    const h = ((h1 % 360) / 360) * 6;
-    const s = s1 / 100;
-    const v = v1 / 100;
-    const i = Math.floor(h), f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s), mod = i % 6, r = [v, q, p, p, t, v][mod], g = [t, v, v, q, p, p][mod], b = [p, p, t, v, v, q][mod];
+    var h = ((h1 % 360) / 360) * 6;
+    var s = s1 / 100;
+    var v = v1 / 100;
+    var i = Math.floor(h), f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s), mod = i % 6, r = [v, q, p, p, t, v][mod], g = [t, v, v, q, p, p][mod], b = [p, p, t, v, v, q][mod];
     return { r: r * 255, g: g * 255, b: b * 255 };
 }
 //# sourceMappingURL=color-common.js.map