@indico-data/design-system 1.0.55 → 1.0.56

package/lib/index.js

@@ -2342,6 +2342,42 @@ const SingleCombobox = React__namespace.default.forwardRef((props, ref) => {
     return jsxRuntime$1.jsx(ComboboxComponent, {});
 });
 
+const mix = function (color_1, color_2, weight) {
+    function d2h(d) {
+        return d.toString(16);
+    } // convert a decimal value to hex
+    function h2d(h) {
+        return parseInt(h, 16);
+    } // convert a hex value to decimal
+    function s2l(hex) {
+        return `${hex}${hex}`;
+    }
+    weight = typeof weight !== 'undefined' ? weight : 50; // set the weight to 50%, if that argument is omitted
+    color_1 = color_1.replace(/#/g, '');
+    color_2 = color_2.replace(/#/g, '');
+    // check if colors are shorthand or longhand - covert to longhand
+    color_1 = color_1.length === 3 ? s2l(color_1) : color_1;
+    color_2 = color_2.length === 3 ? s2l(color_2) : color_2;
+    let color = '#';
+    for (let i = 0; i <= 5; i += 2) {
+        // loop through each of the 3 hex pairs—red, green, and blue
+        const v1 = h2d(color_1.substr(i, 2)); // extract the current pairs
+        const v2 = h2d(color_2.substr(i, 2));
+        // combine the current pairs from each source color, according to the specified weight
+        let val = d2h(Math.floor(v2 + (v1 - v2) * (weight / 100.0)));
+        while (val.length < 2) {
+            val = '0' + val;
+        } // prepend a '0' if val results in a single digit
+        color += val; // concatenate val to our new color string
+    }
+    return color; // PROFIT!
+};
+const shade = (color, percentage) => {
+    return mix('#000000', color, percentage);
+};
+const tint = (color, percentage) => {
+    return mix('#ffffff', color, percentage);
+};
 /**
  * Converts hex color values to rgb or rgba values if a opacity is supplied
  * @param hex
@@ -2362,7 +2398,120 @@ const hexToRgb = (hex, opacity) => {
     }
     return undefined;
 };
+/**
+ * Takes a 3- or 6-character hex color value, and returns an object containing
+ * its equivalent HSL values.
+ *
+ * @see {@link https://css-tricks.com/converting-color-spaces-in-javascript/}
+ * @see {@link https://gist.github.com/mjackson/5311256}
+ */
+function hexToHsl(hexColor) {
+    // convert to 6-character hex string, if necessary
+    const fullHexColor = (() => {
+        if (hexColor.length === 4) {
+            return ('#' +
+                hexColor
+                    .replace('#', '')
+                    .split('')
+                    .reduce((acc, char) => (acc += char + char), ''));
+        }
+        return hexColor;
+    })();
+    const rgbValues = {
+        red: parseInt(fullHexColor.slice(1, 3), 16) / 255,
+        green: parseInt(fullHexColor.slice(3, 5), 16) / 255,
+        blue: parseInt(fullHexColor.slice(-2), 16) / 255,
+    };
+    const allValues = Object.values(rgbValues);
+    const channelMax = Math.max(...allValues);
+    const channelMin = Math.min(...allValues);
+    const channelDelta = channelMax - channelMin;
+    const hslValues = {
+        hue: 0,
+        saturation: 0,
+        lightness: (channelMax + channelMin) / 2,
+    };
+    if (channelDelta !== 0) {
+        // calculate hue
+        if (channelMax === rgbValues.red) {
+            hslValues.hue = ((rgbValues.green - rgbValues.blue) / channelDelta) % 6;
+        }
+        else if (channelMax === rgbValues.green) {
+            hslValues.hue = (rgbValues.blue - rgbValues.red) / channelDelta + 2;
+        }
+        else {
+            hslValues.hue = (rgbValues.red - rgbValues.green) / channelDelta + 4;
+        }
+        // calculate saturation
+        hslValues.saturation = channelDelta / (1 - Math.abs(2 * hslValues.lightness - 1));
+    }
+    hslValues.hue = Math.round(hslValues.hue * 60);
+    hslValues.saturation = +(hslValues.saturation * 100).toFixed(0);
+    hslValues.lightness = +(hslValues.lightness * 100).toFixed(0);
+    // make negative hues positive
+    if (hslValues.hue < 0) {
+        hslValues.hue += 360;
+    }
+    return hslValues;
+}
 
+var color = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    hexToHsl: hexToHsl,
+    hexToRgb: hexToRgb,
+    mix: mix,
+    shade: shade,
+    tint: tint
+});
+
+const camelCaseToUpperUnderscore = (string) => {
+    return string
+        .replace(/([A-Z])/g, function ($1) {
+        return '_' + $1;
+    })
+        .toUpperCase();
+};
+const camelCaseToSpaceUpper = (string) => {
+    return (string
+        // insert a space before all caps
+        .replace(/([A-Z])/g, ' $1')
+        // uppercase the first character
+        .replace(/^./, function (str) {
+        return str.toUpperCase();
+    }));
+};
+const underscoreToCapitalize = (string) => {
+    return (string
+        // replace all _ with spaces
+        .replace(/_/g, ' ')
+        // uppercase the first character
+        .replace(/^./, function (str) {
+        return str.toUpperCase();
+    }));
+};
+const snakeCaseToCamelCase = (string) => {
+    const parts = string.split('_').map((part, i) => {
+        if (i > 0) {
+            return part.replace(/^./, function (str) {
+                return str.toUpperCase();
+            });
+        }
+        else {
+            return part;
+        }
+    });
+    return parts.join().replace(/,/g, '');
+};
+function capitalize(string) {
+    if (typeof string !== 'string')
+        return '';
+    return string.slice(0, 1).toUpperCase() + string.slice(1).toLowerCase();
+}
+function capitalizeFirstOnly(string) {
+    if (typeof string !== 'string')
+        return '';
+    return string.slice(0, 1).toUpperCase() + string.slice(1);
+}
 /**
  * Generates a random string of English alphabet characters. Defaults to a length of 8.
  */
@@ -2374,6 +2523,33 @@ function createRandomString(length) {
     }
     return result;
 }
+const maxLengthWithEllipse = (string, maxLength) => {
+    if (string.length <= maxLength) {
+        return string;
+    }
+    else {
+        return string.slice(0, maxLength - 2).concat('...');
+    }
+};
+const maxLengthWithMiddleEllipsis = (string, maxLength) => {
+    const frontSegment = string.slice(0, Math.floor(maxLength / 2) - 2);
+    const endSegmentLength = string.length - (Math.floor(maxLength / 2) - 1);
+    const endSegment = string.slice(endSegmentLength, string.length);
+    return string.length <= maxLength ? string : `${frontSegment}...${endSegment}`;
+};
+
+var string = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    camelCaseToSpaceUpper: camelCaseToSpaceUpper,
+    camelCaseToUpperUnderscore: camelCaseToUpperUnderscore,
+    capitalize: capitalize,
+    capitalizeFirstOnly: capitalizeFirstOnly,
+    createRandomString: createRandomString,
+    maxLengthWithEllipse: maxLengthWithEllipse,
+    maxLengthWithMiddleEllipsis: maxLengthWithMiddleEllipsis,
+    snakeCaseToCamelCase: snakeCaseToCamelCase,
+    underscoreToCapitalize: underscoreToCapitalize
+});
 
 /**
  * Takes a number and formats it nicely.
@@ -2384,6 +2560,31 @@ function createRandomString(length) {
 function numberWithCommas(value) {
     return new Intl.NumberFormat(navigator.language || 'en-US').format(value);
 }
+/**
+ * Takes a number and returns it, rounded up to the maximum decimal places specified.
+ *
+ * @example maxDecimalPlaces(0.1694915254237288, 2)
+ * // returns 0.17
+ *
+ * @example maxDecimalPlaces(0.1694915254237288, 3)
+ * // returns 0.169
+ *
+ * @example maxDecimalPlaces(12.902, 2)
+ * // returns 12.9
+ */
+function maxDecimalPlaces(value, decimalPlaces) {
+    return +value.toFixed(decimalPlaces);
+}
+function formatConfidence(confidence) {
+    return Math.min(Math.floor(confidence * 100), 99);
+}
+
+var number = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    formatConfidence: formatConfidence,
+    maxDecimalPlaces: maxDecimalPlaces,
+    numberWithCommas: numberWithCommas
+});
 
 const cardTableLoading = styled.keyframes `
   25% {
@@ -25958,6 +26159,9 @@ exports.Wizard = Wizard;
 exports.WizardCard = WizardCard;
 exports.WizardSection = WizardSection;
 exports.WizardWithSidebar = WizardWithSidebar;
+exports.colorUtils = color;
 exports.faIcons = faIcons;
 exports.indicons = indicons;
+exports.numberUtils = number;
+exports.stringUtils = string;
 //# sourceMappingURL=index.js.map