@itwin/itwinui-react 2.0.0-dev.1 → 2.0.0-dev.3

package/cjs/core/utils/color/ColorValue.js

@@ -1,43 +1,32 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ColorValue = exports.isHsvColor = exports.isHslColor = exports.isRgbColor = void 0;
 /*---------------------------------------------------------------------------------------------
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-var numbers_1 = require("../functions/numbers");
+const numbers_1 = require("../functions/numbers");
 // portions adapted from Three.js Copyright © 2010-2017 three.js authors
-var scratchBytes = new Uint8Array(4);
-var scratchUInt32 = new Uint32Array(scratchBytes.buffer);
+const scratchBytes = new Uint8Array(4);
+const scratchUInt32 = new Uint32Array(scratchBytes.buffer);
 /**
  * isRgbValue type guard.
  */
-var isRgbColor = function (value) {
+const isRgbColor = (value) => {
     return (typeof value !== 'string' && 'r' in value && 'g' in value && 'b' in value);
 };
 exports.isRgbColor = isRgbColor;
 /**
  * isHslValue type guard.
  */
-var isHslColor = function (value) {
+const isHslColor = (value) => {
     return (typeof value !== 'string' && 'h' in value && 's' in value && 'l' in value);
 };
 exports.isHslColor = isHslColor;
 /**
  * isHsvValue type guard.
  */
-var isHsvColor = function (value) {
+const isHsvColor = (value) => {
     return (typeof value !== 'string' && 'h' in value && 's' in value && 'v' in value);
 };
 exports.isHsvColor = isHsvColor;
@@ -52,8 +41,8 @@ exports.isHsvColor = isHsvColor;
  *
  * @public
  */
-var ColorValue = /** @class */ (function () {
-    function ColorValue(tbgr, hue) {
+class ColorValue {
+    constructor(tbgr, hue) {
         scratchUInt32[0] = tbgr; // Force to be a 32-bit unsigned integer
         this._tbgr = scratchUInt32[0];
         this._hue = hue;
@@ -69,7 +58,7 @@ var ColorValue = /** @class */ (function () {
      * *"hsl(120,50%,50%)"*
      * *"#rrggbb"*
      */
-    ColorValue.create = function (val) {
+    static create(val) {
         if (!val) {
             return ColorValue.fromTbgr(0);
         }
@@ -86,36 +75,36 @@ var ColorValue = /** @class */ (function () {
             return ColorValue.fromString(val, ColorValue.fromTbgr(0));
         }
         return ColorValue.fromTbgr(0);
-    };
+    }
     /**
      * Convert this ColorValue to an unsigned 32 bit integer representing the 0xTTBBGGRR value
      */
-    ColorValue.prototype.toTbgr = function () {
+    toTbgr() {
         return this._tbgr;
-    };
+    }
     /**
      * Create a ColorValue from its 0xTTBBGGRR representation.
      */
-    ColorValue.fromTbgr = function (tbgr) {
+    static fromTbgr(tbgr) {
         return new ColorValue(tbgr);
-    };
+    }
     /**
      * Create a ColorValue from Red, Green, Blue, Transparency values. All inputs should be integers between 0-255.
      */
-    ColorValue.fromRgbt = function (red, green, blue, transparency) {
+    static fromRgbt(red, green, blue, transparency) {
         return this.fromTbgr(this.computeTbgrFromComponents(red, green, blue, transparency));
-    };
+    }
     /**
      * Compute the 0xTTBBGGRR value corresponding to the specified Red, Green, Blue, Transparency components.
      *  All inputs should be integers between 0-255.
      */
-    ColorValue.computeTbgrFromComponents = function (red, green, blue, transparency) {
+    static computeTbgrFromComponents(red, green, blue, transparency) {
         scratchBytes[0] = red;
         scratchBytes[1] = green;
         scratchBytes[2] = blue;
         scratchBytes[3] = transparency || 0;
         return scratchUInt32[0];
-    };
+    }
     /**
      * Create a ColorValue from a string representation. The following representations are supported:
      * *"rgb(255,0,0)"*
@@ -126,51 +115,51 @@ var ColorValue = /** @class */ (function () {
      * NOTE: If defaultColorIfNotParsed is not defined and string is invalid then error is thrown.
      * This allows component builders to know if they received bad input from user.
      */
-    ColorValue.fromString = function (val, defaultColorIfNotParsed) {
-        var _a = this.computeTbgrFromString(val, defaultColorIfNotParsed === null || defaultColorIfNotParsed === void 0 ? void 0 : defaultColorIfNotParsed.toTbgr()), tbgr = _a[0], hue = _a[1];
+    static fromString(val, defaultColorIfNotParsed) {
+        const [tbgr, hue] = this.computeTbgrFromString(val, defaultColorIfNotParsed === null || defaultColorIfNotParsed === void 0 ? void 0 : defaultColorIfNotParsed.toTbgr());
         return new ColorValue(tbgr, hue);
-    };
+    }
     /** Create a ColorValue from hue, saturation, lightness values.  */
-    ColorValue.fromHSL = function (hsl) {
+    static fromHSL(hsl) {
         var _a;
-        var alpha = (_a = hsl.a) !== null && _a !== void 0 ? _a : 1;
+        const alpha = (_a = hsl.a) !== null && _a !== void 0 ? _a : 1;
         return new ColorValue(this.computeTbgrFromHSL(hsl.h / 360, hsl.s / 100, hsl.l / 100, Math.round((1 - alpha) * 255)), hsl.h);
-    };
+    }
     /** Create a ColorValue from an RgbColor */
-    ColorValue.fromRGB = function (rgb) {
+    static fromRGB(rgb) {
         var _a;
-        var alpha = (_a = rgb.a) !== null && _a !== void 0 ? _a : 1;
+        const alpha = (_a = rgb.a) !== null && _a !== void 0 ? _a : 1;
         return ColorValue.fromRgbt(rgb.r, rgb.g, rgb.b, Math.round((1 - alpha) * 255));
-    };
+    }
     /**
      * Create a ColorValue from an HsvColor
      */
-    ColorValue.fromHSV = function (hsv) {
+    static fromHSV(hsv) {
         var _a;
-        var alpha = (_a = hsv.a) !== null && _a !== void 0 ? _a : 1;
-        var transparency = Math.round((1 - alpha) * 255);
+        const alpha = (_a = hsv.a) !== null && _a !== void 0 ? _a : 1;
+        const transparency = Math.round((1 - alpha) * 255);
         // Check for simple case first.
         if (!hsv.s || hsv.h === -1) {
             // hue must be undefined, have no color only white
-            var white = 0xff & Math.floor((255.0 * hsv.v) / 100.0 + 0.5 + 3.0e-14);
+            const white = 0xff & Math.floor((255.0 * hsv.v) / 100.0 + 0.5 + 3.0e-14);
             return ColorValue.fromRgbt(white, white, white, 0);
         }
-        var dhue = hsv.h, dsaturation = hsv.s, dvalue = hsv.v;
+        let dhue = hsv.h, dsaturation = hsv.s, dvalue = hsv.v;
         if (dhue === 360) {
             dhue = 0.0;
         }
         dhue /= 60; // hue is now [0..6]
-        var hueIntpart = Math.floor(dhue); // convert double -> int
-        var hueFractpart = dhue - hueIntpart;
+        const hueIntpart = Math.floor(dhue); // convert double -> int
+        const hueFractpart = dhue - hueIntpart;
         dvalue /= 100;
         dsaturation /= 100;
-        var p = 0xff & Math.floor(dvalue * (1.0 - dsaturation) * 255.0 + 0.5);
-        var q = 0xff &
+        const p = 0xff & Math.floor(dvalue * (1.0 - dsaturation) * 255.0 + 0.5);
+        const q = 0xff &
             Math.floor(dvalue * (1.0 - dsaturation * hueFractpart) * 255.0 + 0.5);
-        var t = 0xff &
+        const t = 0xff &
             Math.floor(dvalue * (1.0 - dsaturation * (1.0 - hueFractpart)) * 255.0 + 0.5);
-        var v = 0xff & Math.floor(dvalue * 255 + 0.5);
-        var r = 0, b = 0, g = 0;
+        const v = 0xff & Math.floor(dvalue * 255 + 0.5);
+        let r = 0, b = 0, g = 0;
         switch (hueIntpart) {
             case 0:
                 r = v;
@@ -199,7 +188,7 @@ var ColorValue = /** @class */ (function () {
                 break; // magenta-ish
         }
         return new ColorValue(ColorValue.computeTbgrFromComponents(r, g, b, transparency), hsv.h);
-    };
+    }
     /**
      * Compute the 0xTTBBGGRR value corresponding to a string representation of a color. The following representations are supported:
      * *"rgb(255,0,0)"*
@@ -208,26 +197,26 @@ var ColorValue = /** @class */ (function () {
      * *"hsl(120,50%,50%)"*
      * *"#rrggbb"*
      */
-    ColorValue.computeTbgrFromString = function (val, defaultColorIfNotParsed) {
+    static computeTbgrFromString(val, defaultColorIfNotParsed) {
         val = val.toLowerCase();
-        var m = /^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(val);
+        let m = /^((?:rgb|hsl)a?)\(([^\)]*)\)/.exec(val);
         if (m) {
             // rgb / hsl
-            var color = void 0;
-            var name_1 = m[1];
-            var components = m[2];
-            var hasPercent_1 = function (str) { return str[str.length - 1] === '%'; };
-            var floatOrPercent = function (str) {
-                var v = parseFloat(str);
-                return 255 * (0, numbers_1.getBoundedValue)(hasPercent_1(str) ? v / 100 : v, 0, 1);
+            let color;
+            const name = m[1];
+            const components = m[2];
+            const hasPercent = (str) => str[str.length - 1] === '%';
+            const floatOrPercent = (str) => {
+                const v = parseFloat(str);
+                return 255 * (0, numbers_1.getBoundedValue)(hasPercent(str) ? v / 100 : v, 0, 1);
             };
-            var intOrPercent = function (str) {
-                var v = hasPercent_1(str)
+            const intOrPercent = (str) => {
+                const v = hasPercent(str)
                     ? (parseFloat(str) / 100) * 255
                     : parseInt(str, 10);
                 return (0, numbers_1.getBoundedValue)(v, 0, 255);
             };
-            switch (name_1) {
+            switch (name) {
                 case 'rgb':
                 case 'rgba':
                     color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components);
@@ -246,10 +235,10 @@ var ColorValue = /** @class */ (function () {
                     color = /^(\d*\.?\d+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components);
                     if (color) {
                         // hsl(120,50%,50%) hsla(120,50%,50%,0.5)
-                        var h = parseFloat(color[1]);
-                        var s = parseInt(color[2], 10) / 100;
-                        var l = parseInt(color[3], 10) / 100;
-                        var t = typeof color[4] === 'string' ? 255 - floatOrPercent(color[4]) : 0;
+                        const h = parseFloat(color[1]);
+                        const s = parseInt(color[2], 10) / 100;
+                        const l = parseInt(color[3], 10) / 100;
+                        const t = typeof color[4] === 'string' ? 255 - floatOrPercent(color[4]) : 0;
                         return [this.computeTbgrFromHSL(h / 360, s, l, t), h];
                     }
                     break;
@@ -258,8 +247,8 @@ var ColorValue = /** @class */ (function () {
         }
         else if ((m = /^\#([A-Fa-f\d]+)$/.exec(val))) {
             // hex color
-            var hex = m[1];
-            var size = hex.length;
+            const hex = m[1];
+            const size = hex.length;
             if (size === 3) {
                 // #ff0
                 return [
@@ -286,11 +275,11 @@ var ColorValue = /** @class */ (function () {
             return [defaultColorIfNotParsed, undefined];
         }
         throw new Error('unable to parse string into ColorValue');
-    };
+    }
     /**
      * Get the r,g,b,t values encoded in an 0xTTBBGGRR value. Values will be integers between 0-255.
      */
-    ColorValue.getColors = function (tbgr) {
+    static getColors(tbgr) {
         scratchUInt32[0] = tbgr;
         return {
             b: scratchBytes[2],
@@ -298,11 +287,11 @@ var ColorValue = /** @class */ (function () {
             r: scratchBytes[0],
             t: scratchBytes[3],
         };
-    };
+    }
     /**
      * Get the RGB value of the 0xTTBBGGRR color as a number in 0xRRGGBB or 0xRRGGBBAA format
      */
-    ColorValue.prototype.getRgb = function (includeAlpha) {
+    getRgb(includeAlpha) {
         scratchUInt32[0] = this._tbgr;
         if (includeAlpha) {
             return ((scratchBytes[0] << 24) +
@@ -311,45 +300,44 @@ var ColorValue = /** @class */ (function () {
                 (255 - scratchBytes[3]));
         }
         return (scratchBytes[0] << 16) + (scratchBytes[1] << 8) + scratchBytes[2];
-    };
+    }
     /**
      * Get the alpha value for this ColorDef. Will be between 0-255
      */
-    ColorValue.prototype.getAlpha = function () {
+    getAlpha() {
         return ColorValue.getAlpha(this._tbgr);
-    };
+    }
     /**
      * Extract the alpha value from a 0xTTBBGGRR color.
      */
-    ColorValue.getAlpha = function (tbgr) {
+    static getAlpha(tbgr) {
         scratchUInt32[0] = tbgr;
         return 255 - scratchBytes[3];
-    };
+    }
     /**
      * Convert this ColorValue to a string in the form "#rrggbb" or "#rrggbbaa" where values are hex digits of the respective colors
      */
-    ColorValue.prototype.toHexString = function (includeAlpha) {
+    toHexString(includeAlpha) {
         if (includeAlpha) {
-            var value = this.getRgb(includeAlpha);
+            let value = this.getRgb(includeAlpha);
             if (value < 0) {
                 value = 0xffffffff + value + 1;
             }
-            return "#".concat("00000000".concat(value.toString(16)).slice(-8));
+            return `#${`00000000${value.toString(16)}`.slice(-8)}`;
         }
-        return "#".concat("000000".concat(this.getRgb().toString(16)).slice(-6));
-    };
+        return `#${`000000${this.getRgb().toString(16)}`.slice(-6)}`;
+    }
     /**
      * Compute the 0xTTBBGGRR color corresponding to the specified hue, saturation, lightness values.
      */
-    ColorValue.computeTbgrFromHSL = function (
+    static computeTbgrFromHSL(
     /** 0-1 */
     h, 
     /** 0-1 */
     s, 
     /** 0-1 */
-    l, transparency) {
-        if (transparency === void 0) { transparency = 0; }
-        var torgb = function (p1, q1, t) {
+    l, transparency = 0) {
+        const torgb = (p1, q1, t) => {
             if (t < 0) {
                 t += 1;
             }
@@ -367,10 +355,8 @@ var ColorValue = /** @class */ (function () {
             }
             return p1;
         };
-        var hue2rgb = function (p1, q1, t) {
-            return Math.round(torgb(p1, q1, t) * 255);
-        };
-        var modulo = function (n, m) { return ((n % m) + m) % m; };
+        const hue2rgb = (p1, q1, t) => Math.round(torgb(p1, q1, t) * 255);
+        const modulo = (n, m) => ((n % m) + m) % m;
         // h,s,l ranges are in 0.0 - 1.0
         h = modulo(h, 1);
         s = (0, numbers_1.getBoundedValue)(s, 0, 1);
@@ -379,27 +365,30 @@ var ColorValue = /** @class */ (function () {
             l *= 255;
             return this.computeTbgrFromComponents(l, l, l, transparency);
         }
-        var p = l <= 0.5 ? l * (1 + s) : l + s - l * s;
-        var q = 2 * l - p;
+        const p = l <= 0.5 ? l * (1 + s) : l + s - l * s;
+        const q = 2 * l - p;
         return this.computeTbgrFromComponents(hue2rgb(q, p, h + 1 / 3), hue2rgb(q, p, h), hue2rgb(q, p, h - 1 / 3), transparency);
-    };
+    }
     /**
      * Return HslColor from this ColorValue
      */
-    ColorValue.prototype.toHslColor = function () {
-        return __assign(__assign({}, ColorValue.toHsl(this._tbgr)), (this._hue != undefined && { h: this._hue }));
-    };
+    toHslColor() {
+        return {
+            ...ColorValue.toHsl(this._tbgr),
+            ...(this._hue != undefined && { h: this._hue }),
+        };
+    }
     /** Create an HslColor from this ColorValue */
-    ColorValue.toHsl = function (tbgr) {
-        var _a = ColorValue.getColors(tbgr), r = _a.r, g = _a.g, b = _a.b;
-        var red = r / 255;
-        var green = g / 255;
-        var blue = b / 255;
-        var cMin = Math.min(red, green, blue);
-        var cMax = Math.max(red, green, blue);
-        var delta = cMax - cMin;
-        var hue = 0;
-        var saturation = 0;
+    static toHsl(tbgr) {
+        const { r, g, b } = ColorValue.getColors(tbgr);
+        const red = r / 255;
+        const green = g / 255;
+        const blue = b / 255;
+        const cMin = Math.min(red, green, blue);
+        const cMax = Math.max(red, green, blue);
+        const delta = cMax - cMin;
+        let hue = 0;
+        let saturation = 0;
         if (0 === delta) {
             hue = 0;
         }
@@ -416,7 +405,7 @@ var ColorValue = /** @class */ (function () {
         if (hue < 0) {
             hue += 360;
         }
-        var lightness = (cMax + cMin) / 2;
+        let lightness = (cMax + cMin) / 2;
         saturation = 0 === delta ? 0 : delta / (1 - Math.abs(2 * lightness - 1));
         // round values to 1 decimal place
         saturation = Number((saturation * 100).toFixed(1));
@@ -427,32 +416,35 @@ var ColorValue = /** @class */ (function () {
             l: lightness,
             a: this.getAlpha(tbgr) / 255,
         };
-    };
+    }
     /**
      * Create an RgbColor from this ColorValue
      */
-    ColorValue.prototype.toRgbColor = function () {
-        var _a = ColorValue.getColors(this._tbgr), r = _a.r, g = _a.g, b = _a.b;
-        return { r: r, g: g, b: b, a: this.getAlpha() / 255 };
-    };
+    toRgbColor() {
+        const { r, g, b } = ColorValue.getColors(this._tbgr);
+        return { r, g, b, a: this.getAlpha() / 255 };
+    }
     /**
      * Return HsvColor from this ColorValue
      */
-    ColorValue.prototype.toHsvColor = function () {
-        return __assign(__assign({}, ColorValue.toHsv(this._tbgr)), (this._hue != undefined && { h: this._hue }));
-    };
+    toHsvColor() {
+        return {
+            ...ColorValue.toHsv(this._tbgr),
+            ...(this._hue != undefined && { h: this._hue }),
+        };
+    }
     /**
      * Create an HsvColor from this ColorValue
      */
-    ColorValue.toHsv = function (tbgr) {
-        var _a = ColorValue.getColors(tbgr), r = _a.r, g = _a.g, b = _a.b;
-        var red = r / 255;
-        var green = g / 255;
-        var blue = b / 255;
-        var cMin = Math.min(red, green, blue);
-        var cMax = Math.max(red, green, blue);
-        var delta = cMax - cMin;
-        var hue = 0;
+    static toHsv(tbgr) {
+        const { r, g, b } = ColorValue.getColors(tbgr);
+        const red = r / 255;
+        const green = g / 255;
+        const blue = b / 255;
+        const cMin = Math.min(red, green, blue);
+        const cMax = Math.max(red, green, blue);
+        const delta = cMax - cMin;
+        let hue = 0;
         if (0 === delta) {
             hue = 0;
         }
@@ -469,8 +461,8 @@ var ColorValue = /** @class */ (function () {
         if (hue < 0) {
             hue += 360;
         }
-        var brightness = cMax;
-        var saturation = cMax === 0 ? 0 : delta / cMax;
+        let brightness = cMax;
+        let saturation = cMax === 0 ? 0 : delta / cMax;
         // round values to 1 decimal place
         saturation = Number((saturation * 100).toFixed(1));
         brightness = Number((brightness * 100).toFixed(1));
@@ -480,51 +472,49 @@ var ColorValue = /** @class */ (function () {
             v: brightness,
             a: this.getAlpha(tbgr) / 255,
         };
-    };
+    }
     /** True if the value of this ColorValue is the same as another ColorValue. */
-    ColorValue.prototype.equals = function (other) {
+    equals(other) {
         return this._tbgr === other._tbgr;
-    };
-    ColorValue.getFormattedColorNumber = function (value, precision) {
-        if (precision === void 0) { precision = 1; }
+    }
+    static getFormattedColorNumber(value, precision = 1) {
         if (0 === precision) {
             Math.round(value).toString();
         }
         return Number(value.toFixed(precision)).toString();
-    };
+    }
     /** Convert the 0xTTBBGGRR color to a string of the form "rgba(r,g,b,a)" where the color components are specified in decimal and the alpha component is a fraction. */
-    ColorValue.prototype.toRgbString = function (includeAlpha) {
+    toRgbString(includeAlpha) {
         var _a;
-        var rgb = this.toRgbColor();
-        var rgbString = "".concat(rgb.r, ", ").concat(rgb.g, ", ").concat(rgb.b);
+        const rgb = this.toRgbColor();
+        const rgbString = `${rgb.r}, ${rgb.g}, ${rgb.b}`;
         if (includeAlpha) {
-            var alpha = (_a = rgb.a) !== null && _a !== void 0 ? _a : 1;
-            return "rgba(".concat(rgbString, ", ").concat(ColorValue.getFormattedColorNumber(alpha, 2), ")");
+            const alpha = (_a = rgb.a) !== null && _a !== void 0 ? _a : 1;
+            return `rgba(${rgbString}, ${ColorValue.getFormattedColorNumber(alpha, 2)})`;
         }
-        return "rgb(".concat(rgbString, ")");
-    };
+        return `rgb(${rgbString})`;
+    }
     /** Convert this ColorValue to a string in the form "hsl(h,s,l) or hsla(h,s,l,a)" - i.e hsl(120,50%,50%). */
-    ColorValue.prototype.toHslString = function (includeAlpha) {
+    toHslString(includeAlpha) {
         var _a, _b;
-        var hsl = this.toHslColor();
-        var hslString = "".concat(ColorValue.getFormattedColorNumber((_a = this._hue) !== null && _a !== void 0 ? _a : hsl.h), ", ").concat(ColorValue.getFormattedColorNumber(hsl.s), "%, ").concat(ColorValue.getFormattedColorNumber(hsl.l), "%");
+        const hsl = this.toHslColor();
+        const hslString = `${ColorValue.getFormattedColorNumber((_a = this._hue) !== null && _a !== void 0 ? _a : hsl.h)}, ${ColorValue.getFormattedColorNumber(hsl.s)}%, ${ColorValue.getFormattedColorNumber(hsl.l)}%`;
         if (includeAlpha) {
-            var alpha = (_b = hsl.a) !== null && _b !== void 0 ? _b : 1;
-            return "hsla(".concat(hslString, ", ").concat(ColorValue.getFormattedColorNumber(alpha, 2), ")");
+            const alpha = (_b = hsl.a) !== null && _b !== void 0 ? _b : 1;
+            return `hsla(${hslString}, ${ColorValue.getFormattedColorNumber(alpha, 2)})`;
         }
-        return "hsl(".concat(hslString, ")");
-    };
+        return `hsl(${hslString})`;
+    }
     /** Convert this ColorValue to a string in the form "hsv(h,s,v) or hsva(h,s,v,a)" - i.e hsv(120,50%,50%). */
-    ColorValue.prototype.toHsvString = function (includeAlpha) {
+    toHsvString(includeAlpha) {
         var _a, _b;
-        var hsv = this.toHsvColor();
-        var hsvString = "".concat((_a = this._hue) !== null && _a !== void 0 ? _a : hsv.h, ", ").concat(hsv.s, "%, ").concat(hsv.v, "%");
+        const hsv = this.toHsvColor();
+        const hsvString = `${(_a = this._hue) !== null && _a !== void 0 ? _a : hsv.h}, ${hsv.s}%, ${hsv.v}%`;
         if (includeAlpha) {
-            var alpha = (_b = hsv.a) !== null && _b !== void 0 ? _b : 1;
-            return "hsva(".concat(hsvString, ", ").concat(ColorValue.getFormattedColorNumber(alpha, 2), ")");
+            const alpha = (_b = hsv.a) !== null && _b !== void 0 ? _b : 1;
+            return `hsva(${hsvString}, ${ColorValue.getFormattedColorNumber(alpha, 2)})`;
         }
-        return "hsv(".concat(hsvString, ")");
-    };
-    return ColorValue;
-}());
+        return `hsv(${hsvString})`;
+    }
+}
 exports.ColorValue = ColorValue;

package/cjs/core/utils/components/FocusTrap.js

@@ -8,24 +8,24 @@ exports.FocusTrap = void 0;
  * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
-var react_1 = __importDefault(require("react"));
-var focusable_1 = require("../functions/focusable");
-var useMergedRefs_1 = require("../hooks/useMergedRefs");
+const react_1 = __importDefault(require("react"));
+const focusable_1 = require("../functions/focusable");
+const useMergedRefs_1 = require("../hooks/useMergedRefs");
 /**
  * Trap focus within child container.
  * Used for modals and dialogs.
  */
-var FocusTrap = function (props) {
-    var children = props.children;
-    var childRef = react_1.default.useRef();
-    var getFirstLastFocusables = function () {
-        var elements = (0, focusable_1.getTabbableElements)(childRef.current);
-        var firstElement = elements[0];
-        var lastElement = elements[(elements.length || 1) - 1];
+const FocusTrap = (props) => {
+    const { children } = props;
+    const childRef = react_1.default.useRef();
+    const getFirstLastFocusables = () => {
+        const elements = (0, focusable_1.getTabbableElements)(childRef.current);
+        const firstElement = elements[0];
+        const lastElement = elements[(elements.length || 1) - 1];
         return [firstElement, lastElement];
     };
-    var onFirstFocus = function (event) {
-        var _a = getFirstLastFocusables(), firstElement = _a[0], lastElement = _a[1];
+    const onFirstFocus = (event) => {
+        const [firstElement, lastElement] = getFirstLastFocusables();
         if (event.relatedTarget === firstElement) {
             lastElement === null || lastElement === void 0 ? void 0 : lastElement.focus();
         }
@@ -33,8 +33,8 @@ var FocusTrap = function (props) {
             firstElement === null || firstElement === void 0 ? void 0 : firstElement.focus();
         }
     };
-    var onLastFocus = function (event) {
-        var _a = getFirstLastFocusables(), firstElement = _a[0], lastElement = _a[1];
+    const onLastFocus = (event) => {
+        const [firstElement, lastElement] = getFirstLastFocusables();
         if (event.relatedTarget === lastElement) {
             firstElement === null || firstElement === void 0 ? void 0 : firstElement.focus();
         }