@pedidopago/ui 1.0.6

package/dist/utils/colorCheck.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stripThemeColors = exports.parseHslColorToString = exports.parseHexColorToRgba = exports.isRgbHslColor = exports.isHexColor = void 0;
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+/**
+ * Verifies if the provided color is a valid hex color.
+ * @param color : color value;
+ * @returns : true if color is valid, false otherwise;
+ * @see https://stackoverflow.com/questions/8027423/how-to-check-if-a-string-is-a-valid-hex-color-representation/8027444#8027444
+ */
+var isHexColor = function isHexColor(color) {
+  var hexColorWithSixLetters = /^#[0-9A-F]{6}$/i;
+  var hexColorWithThreeLetters = /^#([0-9A-F]{3}){1,2}$/i;
+  return hexColorWithSixLetters.test(color) || hexColorWithThreeLetters.test(color);
+};
+/**
+ * Verifies if the provided color is a valid rgb or hsl color.
+ * @param color : color value;
+ * @returns : true if color is valid, false otherwise;
+ * @see https://stackoverflow.com/questions/2353211/hsl-to-rgb-color-conversion
+ */
+
+
+exports.isHexColor = isHexColor;
+
+var isRgbHslColor = function isRgbHslColor(color) {
+  var regexModel = /^(rgb|hsl)(a?)[(]\s*([\d.]+\s*%?)\s*,\s*([\d.]+\s*%?)\s*,\s*([\d.]+\s*%?)\s*(?:,\s*([\d.]+)\s*)?[)]$/;
+  return regexModel.test(color);
+};
+/**
+ * Verifies if the provided color is a valid theme color and returns the theme color value.
+ * @param color : theme color tag value;
+ * @param themeColors : theme colors object;
+ * @returns : theme color value if color is valid, null otherwise;
+ */
+
+
+exports.isRgbHslColor = isRgbHslColor;
+
+var stripThemeColors = function stripThemeColors(color, themeColors) {
+  var splitColor = color.split('.');
+  var colorCategory = splitColor[0];
+  var colorVariant = splitColor[1];
+
+  if (themeColors[colorCategory]) {
+    if (themeColors[colorCategory][colorVariant]) {
+      return themeColors[colorCategory][colorVariant];
+    }
+  }
+
+  return null;
+};
+/**
+ * Convert a hex color to rgba color.
+ * @param color : hex color value;
+ * @param opacity : opacity value;
+ * @returns : rgba color value;
+ */
+
+
+exports.stripThemeColors = stripThemeColors;
+
+var parseHexColorToRgba = function parseHexColorToRgba(color, opacity) {
+  if (isHexColor(color)) {
+    return "rgba(".concat(parseInt(color.slice(1, 3), 16), ", ").concat(parseInt(color.slice(3, 5), 16), ", ").concat(parseInt(color.slice(5, 7), 16), ", ").concat(opacity, ")");
+  }
+
+  return 'rgba(0, 0, 0, 0)';
+};
+/**
+ * Convert a hsl array color to string
+ * @param color : hsl color array;
+ * @returns : hsl color value;
+ */
+
+
+exports.parseHexColorToRgba = parseHexColorToRgba;
+
+var parseHslColorToString = function parseHslColorToString(color) {
+  var _color = _slicedToArray(color, 3),
+      h = _color[0],
+      s = _color[1],
+      l = _color[2];
+
+  return "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)");
+};
+
+exports.parseHslColorToString = parseHslColorToString;

package/dist/utils/colorFunctions.d.ts

@@ -0,0 +1,3 @@
+export declare function hoverFunction(col: string, amt?: number): string;
+export declare function focusFunction(col: string, amt?: number): string;
+//# sourceMappingURL=colorFunctions.d.ts.map

package/dist/utils/colorFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorFunctions.d.ts","sourceRoot":"","sources":["../../src/utils/colorFunctions.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,SAAM,UAyBnD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,SAAM,UAyBnD"}

package/dist/utils/colorFunctions.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.focusFunction = focusFunction;
+exports.hoverFunction = hoverFunction;
+
+function hoverFunction(col) {
+  var amt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -20;
+  var usePound = false;
+
+  if (col[0] === '#') {
+    col = col.slice(1);
+    usePound = true;
+  }
+
+  var num = parseInt(col, 16);
+  var r = (num >> 16) + amt;
+  if (r > 255) r = 255;else if (r < 0) r = 0;
+  var b = (num >> 8 & 0x00ff) + amt;
+  if (b > 255) b = 255;else if (b < 0) b = 0;
+  var g = (num & 0x0000ff) + amt;
+  if (g > 255) g = 255;else if (g < 0) g = 0;
+  return (usePound ? '#' : '') + (g | b << 8 | r << 16).toString(16);
+}
+
+function focusFunction(col) {
+  var amt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -35;
+  var usePound = false;
+
+  if (col[0] === '#') {
+    col = col.slice(1);
+    usePound = true;
+  }
+
+  var num = parseInt(col, 16);
+  var r = (num >> 16) + amt;
+  if (r > 255) r = 255;else if (r < 0) r = 0;
+  var b = (num >> 8 & 0x00ff) + amt;
+  if (b > 255) b = 255;else if (b < 0) b = 0;
+  var g = (num & 0x0000ff) + amt;
+  if (g > 255) g = 255;else if (g < 0) g = 0;
+  return (usePound ? '#' : '') + (g | b << 8 | r << 16).toString(16);
+}

package/dist/utils/colorToGray.d.ts

@@ -0,0 +1,6 @@
+import { ArrayColor, objectGray } from '../components/Progress/type';
+export declare function numberToHex(c: number): string;
+export declare function rgbToHex(color: ArrayColor): string;
+export declare function convertColor(color: string | ArrayColor): objectGray;
+export declare const parseHslColorToString: (color: number[]) => string;
+//# sourceMappingURL=colorToGray.d.ts.map

package/dist/utils/colorToGray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorToGray.d.ts","sourceRoot":"","sources":["../../src/utils/colorToGray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAErE,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,UAGpC;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,UAEzC;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAoCnE;AAED,eAAO,MAAM,qBAAqB,UAAW,MAAM,EAAE,KAAG,MAIvD,CAAC"}

package/dist/utils/colorToGray.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertColor = convertColor;
+exports.numberToHex = numberToHex;
+exports.parseHslColorToString = void 0;
+exports.rgbToHex = rgbToHex;
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function numberToHex(c) {
+  var hex = c.toString(16);
+  return hex.length === 1 ? '0' + hex : hex;
+}
+
+function rgbToHex(color) {
+  return '#' + numberToHex(color[0]) + numberToHex(color[1]) + numberToHex(color[2]);
+}
+
+function convertColor(color) {
+  var hex = typeof color === 'string' ? color : rgbToHex(color);
+  var r = parseInt(hex.substr(1, 2), 16) / 255; // Grab the hex representation of red (chars 1-2) and convert to decimal (base 10).
+
+  var g = parseInt(hex.substr(3, 2), 16) / 255;
+  var b = parseInt(hex.substr(5, 2), 16) / 255;
+  var equal0 = r === g && g === b;
+  var max = Math.max(r, g, b);
+  var min = Math.min(r, g, b);
+  var h = (max + min) / 2;
+  var d = max - min;
+
+  switch (max) {
+    case r:
+      h = (g - b) / d + (g < b ? 6 : 0);
+      break;
+
+    case g:
+      h = (b - r) / d + 2;
+      break;
+
+    case b:
+      h = (r - g) / d + 4;
+      break;
+  }
+
+  h /= 6;
+  h = Math.round(h * 360);
+  if (equal0) h = 0;
+  return {
+    neutral1: [h - 4, 14, 93],
+    neutral2: [h - 5, 13, 82],
+    neutral3: [h - 3, 13, 68],
+    neutral4: [h - 1, 13, 50],
+    neutral5: [h + 1, 12, 39],
+    neutral6: [h + 1, 12, 31],
+    black: [h - 1, 12, 23]
+  };
+}
+
+var parseHslColorToString = function parseHslColorToString(color) {
+  var _color = _slicedToArray(color, 3),
+      h = _color[0],
+      s = _color[1],
+      l = _color[2];
+
+  return "hsl(".concat(h, ",").concat(s, "%,").concat(l, "%)");
+};
+
+exports.parseHslColorToString = parseHslColorToString;

package/dist/utils/fuctionsColors.d.ts

@@ -0,0 +1,3 @@
+export declare function hoverFunction(col: string, amt?: number): string;
+export declare function focusFunction(col: string, amt?: number): string;
+//# sourceMappingURL=fuctionsColors.d.ts.map

package/dist/utils/fuctionsColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuctionsColors.d.ts","sourceRoot":"","sources":["../../src/utils/fuctionsColors.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,SAAM,UAyBnD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,SAAM,UAyBnD"}

package/dist/utils/fuctionsColors.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.focusFunction = focusFunction;
+exports.hoverFunction = hoverFunction;
+
+function hoverFunction(col) {
+  var amt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -20;
+  var usePound = false;
+
+  if (col[0] === '#') {
+    col = col.slice(1);
+    usePound = true;
+  }
+
+  var num = parseInt(col, 16);
+  var r = (num >> 16) + amt;
+  if (r > 255) r = 255;else if (r < 0) r = 0;
+  var b = (num >> 8 & 0x00ff) + amt;
+  if (b > 255) b = 255;else if (b < 0) b = 0;
+  var g = (num & 0x0000ff) + amt;
+  if (g > 255) g = 255;else if (g < 0) g = 0;
+  return (usePound ? '#' : '') + (g | b << 8 | r << 16).toString(16);
+}
+
+function focusFunction(col) {
+  var amt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -35;
+  var usePound = false;
+
+  if (col[0] === '#') {
+    col = col.slice(1);
+    usePound = true;
+  }
+
+  var num = parseInt(col, 16);
+  var r = (num >> 16) + amt;
+  if (r > 255) r = 255;else if (r < 0) r = 0;
+  var b = (num >> 8 & 0x00ff) + amt;
+  if (b > 255) b = 255;else if (b < 0) b = 0;
+  var g = (num & 0x0000ff) + amt;
+  if (g > 255) g = 255;else if (g < 0) g = 0;
+  return (usePound ? '#' : '') + (g | b << 8 | r << 16).toString(16);
+}

package/dist/utils/generateUUID.d.ts

@@ -0,0 +1,2 @@
+export declare function generateUUID(): string;
+//# sourceMappingURL=generateUUID.d.ts.map

package/dist/utils/generateUUID.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateUUID.d.ts","sourceRoot":"","sources":["../../src/utils/generateUUID.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,WAM3B"}

package/dist/utils/generateUUID.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateUUID = generateUUID;
+
+function generateUUID() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = Math.random() * 16 | 0;
+    var v = c === 'x' ? r : r & 0x3 | 0x8;
+    return v.toString(16);
+  });
+}

package/dist/utils/getColorValue.d.ts

@@ -0,0 +1,298 @@
+/**
+ * This function takes a color string and returns the color value related to the theme or the original color string
+ * @param color : color value;
+ * @param theme : theme object;
+ * @param defaultValue : default value if color is not valid;
+ * @returns color value;
+ * @example
+ * getColorValue('primary.default', props.theme); // returns '#22E0A1'
+ */
+export declare const getColorValue: (color: string, theme?: {
+    fontSizes: {
+        xxxs: string;
+        xxs: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        /**
+         * This function takes a color string and returns the color value related to the theme or the original color string
+         * @param color : color value;
+         * @param theme : theme object;
+         * @param defaultValue : default value if color is not valid;
+         * @returns color value;
+         * @example
+         * getColorValue('primary.default', props.theme); // returns '#22E0A1'
+         */
+        xxl: string;
+        xxxl: string;
+        display: string;
+        giant: string;
+    };
+    fontWeight: {
+        normal: string;
+        bold: string;
+        '100': string;
+        '200': string;
+        '300': string;
+        '400': string;
+        '500': string;
+        '600': string;
+        '700': string;
+        '800': string;
+        '900': string;
+    };
+    breakpoints: {
+        base: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        xxl: string;
+    };
+    colors: {
+        body: {
+            light: string;
+            dark: string;
+        };
+        primary: {
+            alert: string;
+            disabled: string;
+            default: string;
+            hover: string;
+            focus: string;
+            transparent: string;
+        };
+        secondary: {
+            disabled: string;
+            default: string;
+            hover: string;
+            focus: string;
+        };
+        tertiary: {
+            disabled: string;
+            default: string;
+            hover: string;
+            focus: string;
+        };
+        neutral: {
+            white: string;
+            neutral1: string;
+            neutral2: string;
+            neutral3: string;
+            neutral4: string;
+            neutral5: string;
+            neutral6: string;
+            black: string;
+        };
+        background: {
+            linear1: string;
+            linear2: string;
+            linear3: string;
+            light: string;
+        };
+        informative: {
+            default: string;
+            blurred: string;
+            dark: string;
+            gradient: string;
+        };
+        success: {
+            default: string;
+            blurred: string;
+            dark: string;
+            gradient: string;
+        };
+        success_secondary: {
+            default: string;
+            blurred: string;
+            dark: string;
+            gradient: string;
+        };
+        warning: {
+            default: string;
+            blurred: string;
+            dark: string;
+            gradient: string;
+        };
+        warning_secondary: {
+            default: string;
+            blurred: string;
+            dark: string;
+            gradient: string;
+        };
+        error: {
+            default: string;
+            blurred: string;
+            dark: string;
+            gradient: string;
+        };
+        critical: {
+            default: string;
+            blurred: string;
+            dark: string;
+            gradient: string;
+        };
+    };
+    space: {
+        px: string;
+        0.5: string;
+        1: string;
+        1.5: string;
+        2: string;
+        2.5: string;
+        3: string;
+        3.5: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        12: string;
+        14: string;
+        16: string;
+        20: string;
+        24: string;
+        28: string;
+        32: string;
+        36: string;
+        40: string;
+        44: string;
+        48: string;
+        52: string;
+        56: string;
+        60: string;
+        64: string;
+        72: string;
+        80: string;
+        96: string;
+        112: string;
+        128: string;
+    };
+    spacing: {
+        quarck: string;
+        nano: string;
+        xxxs: string;
+        xxs: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+        xxl: string;
+        xxxl: string;
+        huge: string;
+        giant: string;
+        px: string;
+        0.5: string;
+        1: string;
+        1.5: string;
+        2: string;
+        2.5: string;
+        3: string;
+        3.5: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        12: string;
+        14: string;
+        16: string;
+        20: string;
+        24: string;
+        28: string;
+        32: string;
+        36: string;
+        40: string;
+        44: string;
+        48: string;
+        52: string;
+        56: string;
+        60: string;
+        64: string;
+        72: string;
+        80: string;
+        96: string;
+        112: string;
+        128: string;
+    };
+    spacingest: {
+        quarck: string;
+        nano: string;
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        px: string;
+        0.5: string;
+        1: string;
+        1.5: string;
+        2: string;
+        2.5: string;
+        3: string;
+        3.5: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        12: string;
+        14: string;
+        16: string;
+        20: string;
+        24: string;
+        28: string;
+        32: string;
+        36: string;
+        40: string;
+        44: string;
+        48: string;
+        52: string;
+        56: string;
+        60: string;
+        64: string;
+        72: string;
+        80: string;
+        96: string;
+        112: string;
+        128: string;
+    };
+    borderRadius: {
+        default: string;
+    };
+    shadow: {
+        level1: string;
+        level2: string;
+        level3: string;
+    };
+    buttonSize: {
+        sm: string;
+        md: string;
+        xl: string;
+    };
+    transition: {
+        speed: string;
+    };
+    zIndex: {
+        default: string;
+        level1: string;
+        level2: string;
+        level3: string;
+        level4: string;
+        level6: string;
+        level8: string;
+        level12: string;
+        level16: string;
+        level24: string;
+        level48: string;
+    };
+} | undefined, defaultValue?: string | undefined) => string;
+//# sourceMappingURL=getColorValue.d.ts.map

package/dist/utils/getColorValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getColorValue.d.ts","sourceRoot":"","sources":["../../src/utils/getColorValue.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,UACjB,MAAM;;;;;;;;;QAVf;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAKA,MAMF,CAAC"}

package/dist/utils/getColorValue.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getColorValue = void 0;
+
+var _colorCheck = require("../utils/colorCheck");
+
+/**
+ * This function takes a color string and returns the color value related to the theme or the original color string
+ * @param color : color value;
+ * @param theme : theme object;
+ * @param defaultValue : default value if color is not valid;
+ * @returns color value;
+ * @example
+ * getColorValue('primary.default', props.theme); // returns '#22E0A1'
+ */
+var getColorValue = function getColorValue(color, theme, defaultValue) {
+  if ((0, _colorCheck.isHexColor)(color) || (0, _colorCheck.isRgbHslColor)(color)) return color;
+  var colorIsThemeColor = theme && (0, _colorCheck.stripThemeColors)(color, theme.colors);
+  return colorIsThemeColor || defaultValue || 'inherit';
+};
+
+exports.getColorValue = getColorValue;

package/dist/utils/getSvg.d.ts

@@ -0,0 +1,11 @@
+declare type IconsObject = {
+    name: string;
+    width: number;
+    height: number;
+    viewBox: string;
+    html: string;
+    xmlns: string;
+};
+export declare const getSvg: (name: string, allIcons: IconsObject[]) => IconsObject;
+export {};
+//# sourceMappingURL=getSvg.d.ts.map

package/dist/utils/getSvg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSvg.d.ts","sourceRoot":"","sources":["../../src/utils/getSvg.ts"],"names":[],"mappings":"AAAA,aAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,MAAM,SAAU,MAAM,YAAY,WAAW,EAAE,gBAQ3D,CAAC"}

package/dist/utils/getSvg.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSvg = void 0;
+
+var getSvg = function getSvg(name, allIcons) {
+  var filterIcon = allIcons.find(function (icon) {
+    return icon.name === name;
+  });
+
+  if (!filterIcon) {
+    throw new Error("Icon ".concat(name, " not found"));
+  } else {
+    return filterIcon;
+  }
+};
+
+exports.getSvg = getSvg;