react-iro-gradient-picker 1.2.1 → 1.2.3

package/dist/index.js

@@ -6394,111 +6394,139 @@ var isValidRgba = (function (rgba) {
     return !!rgbaToHex(rgba);
 });
 
-var combineRegExp = function (regexpList, flags) {
-    return new RegExp(regexpList.reduce(function (result, item) {
-        return result + (typeof item === 'string' ? item : item.source);
-    }, ''), flags);
-};
-var generateRegExp = function () {
-    var searchFlags = 'gi';
-    var rAngle = /(?:[+-]?\d*\.?\d+)(?:deg|grad|rad|turn)/;
-    var rSideCornerCapture = /to\s+((?:(?:left|right)(?:\s+(?:top|bottom))?))/;
-    var rRadial = /circle at\s+((?:(?:left|right|center|top|bottom)(?:\s+(?:left|right|center|top|bottom))?))/;
-    var rComma = /\s*,\s*/;
-    var rColorHex = /\#(?:[a-f0-9]{6,8}|[a-f0-9]{3})/;
-    var rDigits3 = /\(\s*(?:\d{1,3}%?\s*,\s*){2}%?\d{1,3}%?\s*\)/;
-    var rDigits4 = /\(\s*(?:\d{1,3}%?\s*,\s*){2}%?\d{1,3}%?\s*,\s*\d*\.?\d+\)/;
-    var rValue = /(?:[+-]?\d*\.?\d+)(?:%|[a-z]+)?/;
-    var rKeyword = /[_a-z-][_a-z0-9-]*/;
-    var rColor = combineRegExp([
-        '(?:',
-        rColorHex,
-        '|',
-        '(?:rgb|hsl)',
-        rDigits3,
-        '|',
-        '(?:rgba|hsla)',
-        rDigits4,
-        '|',
-        rKeyword,
-        ')'
-    ], '');
-    var rColorStop = combineRegExp([rColor, '(?:\\s+', rValue, '(?:\\s+', rValue, ')?)?'], '');
-    var rColorStopList = combineRegExp(['(?:', rColorStop, rComma, ')*', rColorStop], '');
-    var rLineCapture = combineRegExp(['(?:(', rAngle, ')|', rSideCornerCapture, '|', rRadial, ')'], '');
-    var rGradientSearch = combineRegExp(['(?:(', rLineCapture, ')', rComma, ')?(', rColorStopList, ')'], searchFlags);
-    var rColorStopSearch = combineRegExp([
-        '\\s*(',
-        rColor,
-        ')',
-        '(?:\\s+',
-        '(',
-        rValue,
-        '))?',
-        '(?:',
-        rComma,
-        '\\s*)?'
-    ], searchFlags);
-    return {
-        gradientSearch: rGradientSearch,
-        colorStopSearch: rColorStopSearch
-    };
-};
-var parseGradient$1 = function (regExpLib, input) {
-    var result = {
-        stops: [],
-        angle: '',
-        line: '',
-        original: ''
-    };
-    var matchGradient, matchColorStop, stopResult;
-    regExpLib.gradientSearch.lastIndex = 0;
-    matchGradient = regExpLib.gradientSearch.exec(input);
-    if (matchGradient !== null) {
-        result = __assign(__assign({}, result), { original: matchGradient[0] });
-        if (matchGradient[1]) {
-            result.line = matchGradient[1];
+var validGradient = (function (input) {
+    try {
+        // Clean input
+        var cleanInput = input
+            .trim()
+            .replace(/;$/, '')
+            .replace(/^background-image:\s*/, '');
+        // Extract gradient type and content
+        var gradientMatch = cleanInput.match(/^(linear|radial)-gradient\s*\(\s*(.*)\s*\)$/i);
+        if (!gradientMatch) {
+            return 'Failed to find gradient';
         }
-        if (matchGradient[2]) {
-            result.angle = matchGradient[2];
+        var _a = __read(gradientMatch, 3), type = _a[1], content = _a[2];
+        var parts = [];
+        var currentPart = '';
+        var parenDepth = 0;
+        var inQuotes = false;
+        // Parse content by splitting on commas, but respect parentheses and quotes
+        for (var i = 0; i < content.length; i++) {
+            var char = content[i];
+            if (char === '"' || char === "'") {
+                inQuotes = !inQuotes;
+            }
+            else if (!inQuotes) {
+                if (char === '(')
+                    parenDepth++;
+                else if (char === ')')
+                    parenDepth--;
+                else if (char === ',' && parenDepth === 0) {
+                    parts.push(currentPart.trim());
+                    currentPart = '';
+                    continue;
+                }
+            }
+            currentPart += char;
         }
-        if (matchGradient[3]) {
-            result.sideCorner = matchGradient[3];
+        if (currentPart.trim()) {
+            parts.push(currentPart.trim());
         }
-        regExpLib.colorStopSearch.lastIndex = 0;
-        matchColorStop = regExpLib.colorStopSearch.exec(matchGradient[5]);
-        while (matchColorStop !== null) {
-            var tinyColor = tinycolor(matchColorStop[1]);
-            stopResult = {
-                color: tinyColor.toRgbString()
-            };
-            if (matchColorStop[2]) {
-                stopResult.position = Number((parseInt(matchColorStop[2], 10) / 100).toFixed(2));
+        var angle = '';
+        var line = '';
+        var colorStops = [];
+        // Determine if first part is direction/angle or color stop
+        var firstPart = parts[0];
+        var isDirection = /^\d+deg$/i.test(firstPart) ||
+            /^to\s+/.test(firstPart) ||
+            /^(?:circle|ellipse)/.test(firstPart) ||
+            /at\s+/.test(firstPart);
+        if (isDirection) {
+            if (type === 'linear') {
+                if (/^\d+deg$/i.test(firstPart)) {
+                    angle = firstPart.replace(/deg$/i, '');
+                }
+                else if (/^to\s+/.test(firstPart)) {
+                    line = firstPart;
+                    // Convert named directions to angles
+                    var directionMap = {
+                        'to top': '0',
+                        'to top right': '45',
+                        'to right': '90',
+                        'to bottom right': '135',
+                        'to bottom': '180',
+                        'to bottom left': '225',
+                        'to left': '270',
+                        'to top left': '315'
+                    };
+                    angle = directionMap[firstPart] || '0';
+                }
+            }
+            else {
+                line = firstPart;
             }
-            result.stops.push(stopResult);
-            matchColorStop = regExpLib.colorStopSearch.exec(matchGradient[5]);
+            colorStops = parts.slice(1);
         }
-    }
-    return result;
-};
-var validGradient = (function (input) {
-    var regExpLib = generateRegExp();
-    var result;
-    var rGradientEnclosedInBrackets = /.*gradient\s*\(((?:\([^\)]*\)|[^\)\(]*)*)\)/;
-    var match = rGradientEnclosedInBrackets.exec(input);
-    if (match !== null) {
-        result = parseGradient$1(regExpLib, match[1]);
-        if (result.original.trim() !== match[1].trim()) {
-            result.parseWarning = true;
+        else {
+            // No explicit direction, use defaults
+            angle = type === 'linear' ? '180' : '';
+            line = type === 'radial' ? 'circle at center' : '';
+            colorStops = parts;
+        }
+        // Parse color stops
+        var stops_1 = [];
+        for (var i = 0; i < colorStops.length; i++) {
+            var stopString = colorStops[i].trim();
+            // Try to extract color and position
+            var stopMatch = stopString.match(/^(.+?)(?:\s+(\d+(?:\.\d+)?)(%)?)?$/);
+            if (stopMatch) {
+                var _b = __read(stopMatch, 4), colorStr = _b[1], positionStr = _b[2], isPercent = _b[3];
+                var tinyColorInstance = tinycolor(colorStr.trim());
+                if (tinyColorInstance.isValid()) {
+                    var stop_1 = {
+                        color: tinyColorInstance.toRgbString()
+                    };
+                    if (positionStr) {
+                        var position = parseFloat(positionStr);
+                        // Assume percentage if no unit specified
+                        if (isPercent || !isPercent) {
+                            position = position / 100;
+                        }
+                        stop_1.position = Math.max(0, Math.min(1, position));
+                    }
+                    stops_1.push(stop_1);
+                }
+            }
         }
-        if (result.stops.every(function (item) { return item.hasOwnProperty('position'); }) === false) {
-            result = 'Not correct position';
+        // Auto-assign positions if missing
+        stops_1.forEach(function (stop, index) {
+            if (!stop.hasOwnProperty('position')) {
+                stop.position = stops_1.length > 1 ? index / (stops_1.length - 1) : 0;
+            }
+        });
+        // Ensure we have at least 2 stops
+        if (stops_1.length === 0) {
+            return 'No valid color stops found';
+        }
+        else if (stops_1.length === 1) {
+            // Duplicate the single stop to create a valid gradient
+            stops_1.push({
+                color: stops_1[0].color,
+                position: 1
+            });
         }
+        return {
+            stops: stops_1,
+            angle: angle,
+            line: line,
+            original: cleanInput
+        };
     }
-    else {
-        result = 'Failed to find gradient';
+    catch (error) {
+        console.warn('Error parsing gradient:', error);
+        return 'Failed to parse gradient';
     }
-    return result;
 });
 
 var LINEAR_POS = [
@@ -7739,7 +7767,19 @@ var IroGradient = function (_a) {
     // Store the initial value for reset functionality
     var initialValue = React.useRef(value);
     var parsedColors = React.useCallback(function () {
-        return parseGradient(value);
+        try {
+            var parsed = parseGradient(value);
+            // If parsing failed, return fallback gradient
+            if (typeof parsed === 'string') {
+                console.warn('Gradient parsing failed, using fallback:', parsed);
+                return parseGradient('linear-gradient(90deg, #ffffff 0%, #000000 100%)');
+            }
+            return parsed;
+        }
+        catch (error) {
+            console.warn('Error parsing gradient, using fallback:', error);
+            return parseGradient('linear-gradient(90deg, #ffffff 0%, #000000 100%)');
+        }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [value]);
     var _s = parsedColors(), stops = _s.stops, type = _s.type, modifier = _s.modifier;