@dreamcommerce/aurora 2.12.1-21 → 2.12.1-22

package/build/esm/external/react-best-gradient-color-picker/dist/esm/utils/gradientParser.js

@@ -0,0 +1,339 @@
+import tinycolor from '../../../external/tinycolor2/tinycolor.js';
+import { high, low } from './formatters.js';
+import { isUpperCase } from './utils.js';
+
+const gradientParser = (input = '') => {
+    const tokens = {
+        linearGradient: /^(-(webkit|o|ms|moz)-)?(linear-gradient)/i,
+        repeatingLinearGradient: /^(-(webkit|o|ms|moz)-)?(repeating-linear-gradient)/i,
+        radialGradient: /^(-(webkit|o|ms|moz)-)?(radial-gradient)/i,
+        repeatingRadialGradient: /^(-(webkit|o|ms|moz)-)?(repeating-radial-gradient)/i,
+        sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
+        extentKeywords: /^(closest-side|closest-corner|farthest-side|farthest-corner|contain|cover)/,
+        positionKeywords: /^(left|center|right|top|bottom)/i,
+        pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
+        percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))%/,
+        emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
+        angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
+        startCall: /^\(/,
+        endCall: /^\)/,
+        comma: /^,/,
+        hexColor: /^#([0-9a-fA-F]+)/,
+        literalColor: /^([a-zA-Z]+)/,
+        rgbColor: /^rgb/i,
+        spacedRgbColor: /^(\d{1,3})\s+(\d{1,3})\s+(\d{1,3})\s+\/\s+([0-1](\.\d+)?)/,
+        rgbaColor: /^rgba/i,
+        hslColor: /^hsl/i,
+        hsvColor: /^hsv/i,
+        number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/,
+    };
+    function error(msg) {
+        const err = new Error(input + ': ' + msg);
+        // err.source = input
+        throw err;
+    }
+    function consume(size) {
+        input = input.substr(size);
+    }
+    function scan(regexp) {
+        const blankCaptures = /^[\n\r\t\s]+/.exec(input);
+        if (blankCaptures) {
+            consume(blankCaptures[0].length);
+        }
+        const captures = regexp.exec(input);
+        if (captures) {
+            consume(captures[0].length);
+        }
+        return captures;
+    }
+    function matchListing(matcher) {
+        let captures = matcher();
+        const result = [];
+        if (captures) {
+            result.push(captures);
+            while (scan(tokens.comma)) {
+                captures = matcher();
+                if (captures) {
+                    result.push(captures);
+                }
+                else {
+                    error('One extra comma');
+                }
+            }
+        }
+        return result;
+    }
+    function match(type, pattern, captureIndex) {
+        const captures = scan(pattern);
+        if (captures) {
+            return {
+                type: type,
+                value: captures[captureIndex],
+            };
+        }
+    }
+    function matchHexColor() {
+        const hexObj = match('hex', tokens.hexColor, 1);
+        if (hexObj?.value) {
+            const { r, g, b, a } = tinycolor(hexObj?.value).toRgb();
+            return {
+                value: `rgba(${r}, ${g}, ${b}, ${a})`,
+            };
+        }
+    }
+    const checkCaps = (val) => {
+        const capIt = isUpperCase(val?.[0]);
+        return {
+            value: `${capIt ? 'RGBA' : 'rgba'}(${matchListing(matchNumber)})`,
+        };
+    };
+    function matchCall(pattern, callback) {
+        const captures = scan(pattern);
+        if (captures) {
+            if (!scan(tokens.startCall)) {
+                error('Missing (');
+            }
+            const result = callback(captures);
+            if (!scan(tokens.endCall)) {
+                error('Missing )');
+            }
+            return result;
+        }
+    }
+    function matchHSLColor() {
+        return matchCall(tokens.hslColor, convertHsl);
+    }
+    function matchRGBAColor() {
+        return matchCall(tokens.rgbaColor, checkCaps);
+    }
+    function matchRGBColor() {
+        return matchCall(tokens.rgbColor, convertRgb);
+    }
+    function matchLiteralColor() {
+        const litObj = match('literal', tokens.literalColor, 0);
+        if (litObj?.value) {
+            const { r, g, b, a } = tinycolor(litObj?.value).toRgb();
+            return {
+                value: `rgba(${r}, ${g}, ${b}, ${a})`,
+            };
+        }
+    }
+    function matchHSVColor() {
+        return matchCall(tokens.hsvColor, convertHsv);
+    }
+    function matchColor() {
+        return (matchHexColor() ||
+            matchHSLColor() ||
+            matchRGBAColor() ||
+            matchRGBColor() ||
+            matchLiteralColor() ||
+            matchHSVColor());
+    }
+    function matchColorStop() {
+        const color = matchColor();
+        if (!color) {
+            error('Expected color definition');
+        }
+        color.left = parseInt(matchDistance()?.value);
+        return color;
+    }
+    function matchGradient(gradientType, pattern, orientationMatcher) {
+        return matchCall(pattern, function () {
+            const orientation = orientationMatcher();
+            if (orientation) {
+                if (!scan(tokens.comma)) {
+                    error('Missing comma before color stops');
+                }
+            }
+            return {
+                type: gradientType,
+                orientation: orientation,
+                colorStops: matchListing(matchColorStop),
+            };
+        });
+    }
+    function matchLinearOrientation() {
+        return matchSideOrCorner() || matchAngle();
+    }
+    function matchDefinition() {
+        return (matchGradient('linear-gradient', tokens.linearGradient, matchLinearOrientation) ||
+            matchGradient('repeating-linear-gradient', tokens.repeatingLinearGradient, matchLinearOrientation) ||
+            matchGradient('radial-gradient', tokens.radialGradient, matchListRadialOrientations) ||
+            matchGradient('repeating-radial-gradient', tokens.repeatingRadialGradient, matchListRadialOrientations));
+    }
+    function matchListDefinitions() {
+        return matchListing(matchDefinition);
+    }
+    function getAST() {
+        const ast = matchListDefinitions();
+        if (input.length > 0) {
+            error('Invalid input not EOF');
+        }
+        const ast0 = ast[0];
+        const checkSelected = ast0?.colorStops?.filter((c) => isUpperCase(c.value)).length;
+        const getGradientObj = () => {
+            if (checkSelected > 0) {
+                return ast0;
+            }
+            else {
+                const val = (c, i) => (i === 0 ? high(c) : low(c));
+                return {
+                    ...ast0,
+                    colorStops: ast0.colorStops.map((c, i) => ({
+                        ...c,
+                        value: val(c, i),
+                    })),
+                };
+            }
+        };
+        return getGradientObj();
+    }
+    function matchSideOrCorner() {
+        return match('directional', tokens.sideOrCorner, 1);
+    }
+    function matchAngle() {
+        return match('angular', tokens.angleValue, 1);
+    }
+    function matchListRadialOrientations() {
+        var radialOrientations, radialOrientation = matchRadialOrientation(), lookaheadCache;
+        if (radialOrientation) {
+            radialOrientations = [];
+            radialOrientations.push(radialOrientation);
+            lookaheadCache = input;
+            if (scan(tokens.comma)) {
+                radialOrientation = matchRadialOrientation();
+                if (radialOrientation) {
+                    radialOrientations.push(radialOrientation);
+                }
+                else {
+                    input = lookaheadCache;
+                }
+            }
+        }
+        return radialOrientations;
+    }
+    function matchRadialOrientation() {
+        let radialType = matchCircle() || matchEllipse();
+        if (radialType) {
+            // @ts-expect-error - need to circle back for these types
+            radialType.at = matchAtPosition();
+        }
+        else {
+            const extent = matchExtentKeyword();
+            if (extent) {
+                radialType = extent;
+                const positionAt = matchAtPosition();
+                if (positionAt) {
+                    // @ts-expect-error - need to circle back for these types
+                    radialType.at = positionAt;
+                }
+            }
+            else {
+                const defaultPosition = matchPositioning();
+                if (defaultPosition) {
+                    radialType = {
+                        type: 'default-radial',
+                        // @ts-expect-error - need to circle back for these types
+                        at: defaultPosition,
+                    };
+                }
+            }
+        }
+        return radialType;
+    }
+    function matchLength() {
+        return match('px', tokens.pixelValue, 1) || match('em', tokens.emValue, 1);
+    }
+    function matchCircle() {
+        const circle = match('shape', /^(circle)/i, 0);
+        if (circle) {
+            // @ts-expect-error - need to circle back for these types
+            circle.style = matchLength() || matchExtentKeyword();
+        }
+        return circle;
+    }
+    function matchEllipse() {
+        const ellipse = match('shape', /^(ellipse)/i, 0);
+        if (ellipse) {
+            // @ts-expect-error - need to circle back for these types
+            ellipse.style = matchDistance() || matchExtentKeyword();
+        }
+        return ellipse;
+    }
+    function matchExtentKeyword() {
+        return match('extent-keyword', tokens.extentKeywords, 1);
+    }
+    function matchAtPosition() {
+        if (match('position', /^at/, 0)) {
+            const positioning = matchPositioning();
+            if (!positioning) {
+                error('Missing positioning value');
+            }
+            return positioning;
+        }
+    }
+    function matchPositioning() {
+        const location = matchCoordinates();
+        if (location.x || location.y) {
+            return {
+                type: 'position',
+                value: location,
+            };
+        }
+    }
+    function matchCoordinates() {
+        return {
+            x: matchDistance(),
+            y: matchDistance(),
+        };
+    }
+    function matchNumber() {
+        return scan(tokens.number)[1];
+    }
+    const convertHsl = (val) => {
+        const capIt = isUpperCase(val?.[0]);
+        const hsl = matchListing(matchNumber);
+        const { r, g, b, a } = tinycolor({
+            h: hsl[0],
+            s: hsl[1],
+            l: hsl[2],
+            a: hsl[3] || 1,
+        }).toRgb();
+        return {
+            value: `${capIt ? 'RGBA' : 'rgba'}(${r}, ${g}, ${b}, ${a})`,
+        };
+    };
+    const convertHsv = (val) => {
+        const capIt = isUpperCase(val?.[0]);
+        const hsv = matchListing(matchNumber);
+        const { r, g, b, a } = tinycolor({
+            h: hsv[0],
+            s: hsv[1],
+            v: hsv[2],
+            a: hsv[3] || 1,
+        }).toRgb();
+        return {
+            value: `${capIt ? 'RGBA' : 'rgba'}(${r}, ${g}, ${b}, ${a})`,
+        };
+    };
+    const convertRgb = (val) => {
+        const capIt = isUpperCase(val?.[0]);
+        const captures = scan(tokens.spacedRgbColor);
+        const [, r, g, b, a = 1] = captures || [null, ...matchListing(matchNumber)];
+        return {
+            value: `${capIt ? 'RGBA' : 'rgba'}(${r}, ${g}, ${b}, ${a})`,
+        };
+    };
+    function matchDistance() {
+        return (match('%', tokens.percentageValue, 1) ||
+            matchPositionKeyword() ||
+            matchLength());
+    }
+    function matchPositionKeyword() {
+        return match('position-keyword', tokens.positionKeywords, 1);
+    }
+    return getAST();
+};
+
+export { gradientParser };
+//# sourceMappingURL=gradientParser.js.map

package/build/esm/external/react-best-gradient-color-picker/dist/esm/utils/gradientParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":null,"sources":[null],"sourcesContent":[null],"names":[],"mappings":"AAAA,sBAAsB,2CAA+C;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;"}

package/build/esm/external/react-best-gradient-color-picker/dist/esm/utils/utils.js

@@ -0,0 +1,148 @@
+import { config } from '../constants.js';
+import { formatInputValues } from './formatters.js';
+
+const { barSize, crossSize } = config;
+const safeBounds = (e) => {
+    const client = e.target.parentNode.getBoundingClientRect();
+    const className = e.target.className;
+    const adjuster = className === 'c-resize ps-rl' ? 15 : 0;
+    return {
+        offsetLeft: client?.x + adjuster,
+        offsetTop: client?.y,
+        clientWidth: client?.width,
+        clientHeight: client?.height,
+    };
+};
+function getHandleValue(e) {
+    const { offsetLeft, clientWidth } = safeBounds(e);
+    const pos = e.clientX - offsetLeft - barSize / 2;
+    const adjuster = clientWidth - 18;
+    const bounded = formatInputValues(pos, 0, adjuster);
+    return Math.round(bounded / (adjuster / 100));
+}
+function computeSquareXY(s, v, squareWidth, squareHeight) {
+    const x = s * squareWidth - crossSize / 2;
+    const y = ((100 - v) / 100) * squareHeight - crossSize / 2;
+    return [x, y];
+}
+const getClientXY = (e) => {
+    if (e.clientX) {
+        return { clientX: e.clientX, clientY: e.clientY };
+    }
+    else {
+        const touch = e.touches[0] || {};
+        return { clientX: touch.clientX, clientY: touch.clientY };
+    }
+};
+function computePickerPosition(e) {
+    const { offsetLeft, offsetTop, clientWidth, clientHeight } = safeBounds(e);
+    const { clientX, clientY } = getClientXY(e);
+    const getX = () => {
+        const xPos = clientX - offsetLeft - crossSize / 2;
+        return formatInputValues(xPos, -9, clientWidth - 10);
+    };
+    const getY = () => {
+        const yPos = clientY - offsetTop - crossSize / 2;
+        return formatInputValues(yPos, -9, clientHeight - 10);
+    };
+    return [getX(), getY()];
+}
+// export const getGradientType = (value: string) => {
+//   return value?.split('(')[0]
+// }
+const isUpperCase = (str) => {
+    return str?.[0] === str?.[0]?.toUpperCase();
+};
+// export const compareGradients = (g1: string, g2: string) => {
+//   const ng1 = g1?.toLowerCase()?.replaceAll(' ', '')
+//   const ng2 = g2?.toLowerCase()?.replaceAll(' ', '')
+//   if (ng1 === ng2) {
+//     return true
+//   } else {
+//     return false
+//   }
+// }
+const convertShortHandDeg = (dir) => {
+    if (dir === 'to top') {
+        return 0;
+    }
+    else if (dir === 'to bottom') {
+        return 180;
+    }
+    else if (dir === 'to left') {
+        return 270;
+    }
+    else if (dir === 'to right') {
+        return 90;
+    }
+    else if (dir === 'to top right') {
+        return 45;
+    }
+    else if (dir === 'to bottom right') {
+        return 135;
+    }
+    else if (dir === 'to bottom left') {
+        return 225;
+    }
+    else if (dir === 'to top left') {
+        return 315;
+    }
+    else {
+        const safeDir = dir || 0;
+        return parseInt(safeDir);
+    }
+};
+const objectToString = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    else {
+        if (value?.type?.includes('gradient')) {
+            const sorted = value?.colorStops?.sort((a, b) => a?.left - b?.left);
+            const string = sorted
+                ?.map((c) => `${c?.value} ${c?.left}%`)
+                ?.join(', ');
+            const type = value?.type;
+            const degs = convertShortHandDeg(value?.orientation?.value);
+            const gradientStr = type === 'linear-gradient' ? `${degs}deg` : 'circle';
+            return `${type}(${gradientStr}, ${string})`;
+        }
+        else {
+            const color = value?.colorStops[0]?.value || 'rgba(175, 51, 242, 1)';
+            return color;
+        }
+    }
+};
+const getColorObj = (colors) => {
+    const idxCols = colors?.map((c, i) => ({
+        ...c,
+        index: i,
+    }));
+    const upperObj = idxCols?.find((c) => isUpperCase(c.value));
+    const ccObj = upperObj || idxCols[0];
+    return {
+        currentColor: ccObj?.value || config?.defaultGradient,
+        selectedColor: ccObj?.index || 0,
+        currentLeft: ccObj?.left || 0,
+    };
+};
+const getDegrees = (value) => {
+    const s1 = value?.split(',')[0];
+    const s2 = s1?.split('(')[1]?.replace('deg', '');
+    return convertShortHandDeg(s2);
+};
+const getDetails = (value) => {
+    const isGradient = value?.includes('gradient');
+    const gradientType = value?.split('(')[0];
+    const degrees = getDegrees(value);
+    const degreeStr = gradientType === 'linear-gradient' ? `${degrees}deg` : 'circle';
+    return {
+        degrees,
+        degreeStr,
+        isGradient,
+        gradientType,
+    };
+};
+
+export { computePickerPosition, computeSquareXY, getColorObj, getDetails, getHandleValue, isUpperCase, objectToString, safeBounds };
+//# sourceMappingURL=utils.js.map

package/build/esm/external/react-best-gradient-color-picker/dist/esm/utils/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":null,"sources":[null],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;"}