jattac.libs.web.zest-button 1.2.2 → 1.2.3

package/dist/index.cjs.js

@@ -2,6 +2,7 @@
 
 var require$$0 = require('react');
 var fa6 = require('react-icons/fa6');
+var fa = require('react-icons/fa');
 
 var jsxRuntime = {exports: {}};
 
@@ -1389,18 +1390,218 @@ var css_248z = "/* Styles/ZestButton.module.css */\n\n/* Define base variables f
 var styles = {"force-light":"ZestButton-module_force-light__zZTIZ","force-dark":"ZestButton-module_force-dark__cx74D","button":"ZestButton-module_button__KDafc","solid":"ZestButton-module_solid__cu4tr","outline":"ZestButton-module_outline__esgLq","text":"ZestButton-module_text__8X1xD","dashed":"ZestButton-module_dashed__ebKYF","standard":"ZestButton-module_standard__T3EGM","success":"ZestButton-module_success__XEptA","danger":"ZestButton-module_danger__nJpJ-","disabled":"ZestButton-module_disabled__gw6y3","fullWidth":"ZestButton-module_fullWidth__2ziwk","sm":"ZestButton-module_sm__G1vAP","md":"ZestButton-module_md__Y-PMO","lg":"ZestButton-module_lg__AQgdf","inner":"ZestButton-module_inner__1j2Fr","spinner":"ZestButton-module_spinner__l2hLe","spin":"ZestButton-module_spin__4asdw","content":"ZestButton-module_content__hlea3","label":"ZestButton-module_label__8x263","icon":"ZestButton-module_icon__B3DFi","animatedCheck":"ZestButton-module_animatedCheck__8K4K-","fadeIn":"ZestButton-module_fadeIn__iEave","animatedX":"ZestButton-module_animatedX__KQnt7","drawCheck":"ZestButton-module_drawCheck__3DyjT","shake":"ZestButton-module_shake__NtIjf","shakeIt":"ZestButton-module_shakeIt__ox-R3"};
 styleInject(css_248z);
 
-// --- Components ---
-const AnimatedCheckmark = () => (jsxRuntimeExports.jsx("svg", { className: styles.animatedCheck, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "3", strokeLinecap: "round", strokeLinejoin: "round", children: jsxRuntimeExports.jsx("path", { d: "M5 13l4 4L19 7" }) }));
-const AnimatedX = () => (jsxRuntimeExports.jsxs("svg", { className: styles.animatedX, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "3", strokeLinecap: "round", strokeLinejoin: "round", children: [jsxRuntimeExports.jsx("path", { d: "M6 6L18 18" }), jsxRuntimeExports.jsx("path", { d: "M6 18L18 6" })] }));
-const ZestButton = ({ className = "", disabled, children, onClick, // Destructure onClick here
-zest, // New parent prop
-...props }) => {
-    // Destructure custom props from 'zest' with defaults
-    const { visualOptions = {}, busyOptions = {}, successOptions = {}, confirmOptions, // confirmOptions can be undefined
-    isDefault = false, theme = 'system', buttonStyle = 'solid', } = zest || {}; // Provide empty object as default for zest
-    const { variant = "standard", size = "md", fullWidth = false, iconLeft, iconRight, } = visualOptions;
-    const { handleInternally = true, preventRageClick = true, minBusyDurationMs = 500, } = busyOptions;
-    const { showCheckmark = true, showFailIcon = true, autoResetAfterMs = 2000, } = successOptions;
+// Create the Zest Context with a default empty configuration
+const ZestContext = require$$0.createContext(undefined);
+// Custom hook to use the Zest Context
+const useZest = () => {
+    const context = require$$0.useContext(ZestContext);
+    // Optional: Add a check here if context is undefined, meaning provider is not used
+    // if (context === undefined) {
+    //   console.warn("useZest must be used within a ZestProvider. Falling back to default ZestButton props.");
+    // }
+    return context;
+};
+
+const semanticTypeDefaults = {
+    // Creation / Add
+    'add': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaPlus, {}),
+        },
+    },
+    'new': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaPlus, {}),
+        },
+    },
+    // Save / Submit
+    'save': {
+        visualOptions: {
+            variant: 'success',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaSave, {}),
+        },
+        busyOptions: { minBusyDurationMs: 500 }, // Default busy duration for saves
+        successOptions: { showCheckmark: true },
+    },
+    'submit': {
+        visualOptions: {
+            variant: 'success',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaSave, {}),
+        },
+        busyOptions: { minBusyDurationMs: 500 },
+        successOptions: { showCheckmark: true },
+    },
+    // Edit / Update
+    'edit': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaEdit, {}),
+        },
+    },
+    'update': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaEdit, {}),
+        },
+    },
+    // Delete / Remove
+    'delete': {
+        visualOptions: {
+            variant: 'danger',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaTrash, {}),
+        },
+        confirmOptions: {
+            displayLabel: 'Confirm Delete',
+            timeoutSecs: 5,
+        },
+        successOptions: { showFailIcon: true, autoResetAfterMs: 400 }, // Shake for fail
+    },
+    'remove': {
+        visualOptions: {
+            variant: 'danger',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaTrash, {}),
+        },
+        confirmOptions: {
+            displayLabel: 'Confirm Remove',
+            timeoutSecs: 5,
+        },
+        successOptions: { showFailIcon: true, autoResetAfterMs: 400 },
+    },
+    // Cancel / Close
+    'cancel': {
+        buttonStyle: 'outline', // Moved here
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaTimes, {}),
+        },
+    },
+    'close': {
+        buttonStyle: 'outline', // Moved here
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaTimes, {}),
+        },
+    },
+    // View / Details
+    'view': {
+        buttonStyle: 'text', // Moved here
+        visualOptions: {
+            variant: 'standard',
+            iconRight: jsxRuntimeExports.jsx(fa.FaArrowRight, {}),
+        },
+    },
+    'details': {
+        buttonStyle: 'text', // Moved here
+        visualOptions: {
+            variant: 'standard',
+            iconRight: jsxRuntimeExports.jsx(fa.FaArrowRight, {}),
+        },
+    },
+    // Download
+    'download': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaDownload, {}),
+        },
+    },
+    // Upload
+    'upload': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaUpload, {}),
+        },
+    },
+    // Refresh / Reload
+    'refresh': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaSyncAlt, {}),
+        },
+        busyOptions: { minBusyDurationMs: 500 },
+    },
+    'reload': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaSyncAlt, {}),
+        },
+        busyOptions: { minBusyDurationMs: 500 },
+    },
+    // Print
+    'print': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaPrint, {}),
+        },
+    },
+    // Share
+    'share': {
+        visualOptions: {
+            variant: 'standard',
+            iconLeft: jsxRuntimeExports.jsx(fa.FaShareAlt, {}),
+        },
+    },
+    // Confirm (generic)
+    'confirm': {
+        visualOptions: {
+            variant: 'success', // Could be standard or success
+        },
+        confirmOptions: {
+            displayLabel: 'Are you sure?',
+            timeoutSecs: 5,
+        },
+    },
+};
+
+// Define a deep merge utility function
+const deepMerge = (target, source) => {
+    const output = { ...target };
+    if (target && typeof target === 'object' && source && typeof source === 'object') {
+        Object.keys(source).forEach(key => {
+            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                if (!(key in target))
+                    Object.assign(output, { [key]: source[key] });
+                else
+                    output[key] = deepMerge(target[key], source[key]);
+            }
+            else {
+                Object.assign(output, { [key]: source[key] });
+            }
+        });
+    }
+    return output;
+};
+const useZestConfig = (localZestProps) => {
+    const globalConfig = useZest();
+    const globalDefaultProps = globalConfig?.defaultProps;
+    const customSemanticDefaults = globalConfig?.semanticTypeDefaults;
+    // 1. Start with global defaults (lowest precedence)
+    let effectiveZestConfig = deepMerge({}, globalDefaultProps || {});
+    // Determine the semanticType from either local props or the already-merged global props
+    const semanticType = localZestProps?.semanticType || effectiveZestConfig.semanticType;
+    if (semanticType) {
+        // 2. Apply built-in semantic defaults
+        if (semanticTypeDefaults[semanticType]) {
+            effectiveZestConfig = deepMerge(effectiveZestConfig, semanticTypeDefaults[semanticType]);
+        }
+        // 3. Apply custom semantic defaults from provider (overrides built-in ones)
+        if (customSemanticDefaults && customSemanticDefaults[semanticType]) {
+            effectiveZestConfig = deepMerge(effectiveZestConfig, customSemanticDefaults[semanticType]);
+        }
+    }
+    // 4. Apply local props (highest precedence)
+    effectiveZestConfig = deepMerge(effectiveZestConfig, localZestProps || {});
+    return effectiveZestConfig;
+};
+
+const useBusyState = ({ busyOptions, successOptions }) => {
+    const [internalBusy, setInternalBusy] = require$$0.useState(false);
+    const [wasSuccessful, setWasSuccessful] = require$$0.useState(false);
+    const [wasFailed, setWasFailed] = require$$0.useState(false);
+    const failTimeoutRef = require$$0.useRef(null);
+    const { handleInternally = true, preventRageClick = true, minBusyDurationMs = 500, } = busyOptions || {};
+    const { showCheckmark = true, showFailIcon = true, autoResetAfterMs = 2000, } = successOptions || {};
     // Edge Case 4: Add warnings for very short durations in development
     require$$0.useEffect(() => {
         if (process.env.NODE_ENV === 'development') {
@@ -1412,16 +1613,120 @@ zest, // New parent prop
             }
         }
     }, [minBusyDurationMs, autoResetAfterMs]);
-    const [internalBusy, setInternalBusy] = require$$0.useState(false);
-    const [wasSuccessful, setWasSuccessful] = require$$0.useState(false);
-    const [wasFailed, setWasFailed] = require$$0.useState(false);
-    const buttonRef = require$$0.useRef(null);
-    const failTimeoutRef = require$$0.useRef(null); // Bug 1: Add useRef for failTimeout
-    const [currentChildren, setCurrentChildren] = require$$0.useState(children);
+    // auto-reset success/failure state
+    require$$0.useEffect(() => {
+        if ((wasSuccessful || wasFailed) && autoResetAfterMs) {
+            const timeout = setTimeout(() => {
+                setWasSuccessful(false);
+                setWasFailed(false);
+                if (failTimeoutRef.current) { // Clear fail timeout if still active
+                    clearTimeout(failTimeoutRef.current);
+                    failTimeoutRef.current = null;
+                }
+            }, autoResetAfterMs);
+            return () => clearTimeout(timeout);
+        }
+    }, [wasSuccessful, wasFailed, autoResetAfterMs]);
+    // Cleanup for failTimeoutRef on unmount
+    require$$0.useEffect(() => {
+        return () => {
+            if (failTimeoutRef.current) {
+                clearTimeout(failTimeoutRef.current);
+            }
+        };
+    }, []);
+    const startBusy = () => {
+        setWasSuccessful(false);
+        setWasFailed(false);
+        setInternalBusy(true);
+    };
+    const endBusy = (isSuccess) => {
+        setInternalBusy(false);
+        if (isSuccess) {
+            if (showCheckmark)
+                setWasSuccessful(true);
+        }
+        else {
+            if (showFailIcon)
+                setWasFailed(true);
+            // Bug 1: Clear any existing timeout before setting a new one
+            if (failTimeoutRef.current) {
+                clearTimeout(failTimeoutRef.current);
+            }
+            failTimeoutRef.current = setTimeout(() => {
+                setWasFailed(false);
+                failTimeoutRef.current = null; // Clear ref after timeout fires
+            }, 400); // Shake animation duration
+        }
+    };
+    return {
+        internalBusy,
+        wasSuccessful,
+        wasFailed,
+        startBusy,
+        endBusy,
+        handleInternally,
+        preventRageClick,
+        minBusyDurationMs,
+        showCheckmark,
+        showFailIcon,
+        autoResetAfterMs,
+        failTimeoutRef // Expose this for ZestButton to clear if needed (e.g., confirmation failure)
+    };
+};
+
+const useConfirmation = ({ confirmOptions, originalChildren, onConfirmFail }) => {
     const [awaitingConfirm, setAwaitingConfirm] = require$$0.useState(false);
-    // ✅ interval ref for confirm countdown
+    const [currentChildren, setCurrentChildren] = require$$0.useState(originalChildren);
     const confirmIntervalRef = require$$0.useRef(null);
-    // Theme state and detection
+    require$$0.useEffect(() => {
+        if (!awaitingConfirm) {
+            setCurrentChildren(originalChildren);
+        }
+    }, [originalChildren, awaitingConfirm]);
+    const stopConfirmation = require$$0.useCallback(() => {
+        if (confirmIntervalRef.current) {
+            clearInterval(confirmIntervalRef.current);
+            confirmIntervalRef.current = null;
+        }
+        setCurrentChildren(originalChildren);
+        setAwaitingConfirm(false);
+    }, [originalChildren]);
+    const startConfirmation = require$$0.useCallback(() => {
+        if (!confirmOptions)
+            return;
+        setAwaitingConfirm(true);
+        const { displayLabel, timeoutSecs } = confirmOptions;
+        setCurrentChildren(`${displayLabel} (${timeoutSecs}s)`);
+        const startTime = Date.now();
+        confirmIntervalRef.current = setInterval(() => {
+            const elapsed = Date.now() - startTime;
+            const timeRemaining = timeoutSecs - Math.floor(elapsed / 1000);
+            if (timeRemaining <= 0) {
+                stopConfirmation();
+                onConfirmFail?.();
+            }
+            else {
+                setCurrentChildren(`${displayLabel} (${timeRemaining}s)`);
+            }
+        }, 1000);
+    }, [confirmOptions, onConfirmFail, stopConfirmation]);
+    require$$0.useEffect(() => {
+        return () => {
+            if (confirmIntervalRef.current) {
+                clearInterval(confirmIntervalRef.current);
+            }
+        };
+    }, []);
+    return {
+        awaitingConfirm,
+        currentChildren,
+        startConfirmation,
+        stopConfirmation,
+    };
+};
+
+const useThemeDetection = () => {
     const [systemTheme, setSystemTheme] = require$$0.useState('light');
     require$$0.useEffect(() => {
         const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
@@ -1432,13 +1737,25 @@ zest, // New parent prop
         mediaQuery.addEventListener('change', handleChange);
         return () => mediaQuery.removeEventListener('change', handleChange);
     }, []);
+    return systemTheme;
+};
+
+// --- Components ---
+const AnimatedCheckmark = () => (jsxRuntimeExports.jsx("svg", { className: styles.animatedCheck, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "3", strokeLinecap: "round", strokeLinejoin: "round", children: jsxRuntimeExports.jsx("path", { d: "M5 13l4 4L19 7" }) }));
+const AnimatedX = () => (jsxRuntimeExports.jsxs("svg", { className: styles.animatedX, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "3", strokeLinecap: "round", strokeLinejoin: "round", children: [jsxRuntimeExports.jsx("path", { d: "M6 6L18 18" }), jsxRuntimeExports.jsx("path", { d: "M6 18L18 6" })] }));
+const ZestButton = ({ className = "", disabled, children, onClick, zest: localZestProps, ...props }) => {
+    const effectiveZestConfig = useZestConfig(localZestProps);
+    const { visualOptions = {}, busyOptions = {}, successOptions = {}, confirmOptions, isDefault = false, theme = 'system', buttonStyle = 'solid', } = effectiveZestConfig;
+    const { variant = "standard", size = "md", fullWidth = false, iconLeft, iconRight, } = visualOptions;
+    const { handleInternally, minBusyDurationMs, preventRageClick, showCheckmark, showFailIcon, internalBusy, wasSuccessful, wasFailed, startBusy, endBusy, } = useBusyState({ busyOptions, successOptions });
+    const { awaitingConfirm, currentChildren, startConfirmation, stopConfirmation, } = useConfirmation({
+        confirmOptions,
+        originalChildren: children,
+        onConfirmFail: () => endBusy(false),
+    });
+    const buttonRef = require$$0.useRef(null);
+    const systemTheme = useThemeDetection();
     const effectiveTheme = theme === 'system' ? systemTheme : theme;
-    // keep children in sync when not in confirm mode
-    require$$0.useEffect(() => {
-        if (!awaitingConfirm) {
-            setCurrentChildren(children);
-        }
-    }, [children, awaitingConfirm]);
     const effectiveBusy = typeof props["aria-busy"] === "boolean"
         ? Boolean(props["aria-busy"])
         : handleInternally
@@ -1447,23 +1764,12 @@ zest, // New parent prop
     const isDisabled = disabled ||
         effectiveBusy ||
         (preventRageClick && (wasSuccessful || wasFailed));
-    // Move handleClick, stopWaiting, and handleConfirmClick declarations here
-    const stopWaiting = () => {
-        if (confirmIntervalRef.current) {
-            clearInterval(confirmIntervalRef.current);
-            confirmIntervalRef.current = null;
-        }
-        setCurrentChildren(children);
-        setAwaitingConfirm(false);
-    };
     const handleClick = async (e) => {
         if (preventRageClick && internalBusy)
             return;
         if (handleInternally && typeof onClick === "function") {
             try {
-                setWasSuccessful(false);
-                setWasFailed(false);
-                setInternalBusy(true);
+                startBusy();
                 const startTime = Date.now();
                 await onClick(e);
                 const elapsed = Date.now() - startTime;
@@ -1471,69 +1777,33 @@ zest, // New parent prop
                 if (remaining > 0) {
                     await new Promise((resolve) => setTimeout(resolve, remaining));
                 }
-                if (showCheckmark)
-                    setWasSuccessful(true);
+                endBusy(true);
             }
             catch (err) {
                 console.error(err);
-                if (showFailIcon)
-                    setWasFailed(true);
-            }
-            finally {
-                setInternalBusy(false);
+                endBusy(false);
             }
         }
         else if (onClick) {
             onClick(e);
         }
     };
-    const handleConfirmClick = async (e) => {
-        if (!confirmOptions) { // Use destructured confirmOptions
-            return handleClick(e);
-        }
-        // Edge Case 3: Add warning for missing onClick with confirmOptions
-        if (confirmOptions && !onClick) { // Use destructured confirmOptions and onClick
-            console.warn("ZestButton: 'confirmOptions' are provided but 'onClick' handler is missing. The button will confirm but perform no action.");
-        }
+    const handleConfirmClick = (e) => {
         if (awaitingConfirm) {
-            stopWaiting();
-            return handleClick(e);
+            stopConfirmation();
+            handleClick(e);
+            return;
         }
-        const { displayLabel, timeoutSecs } = confirmOptions; // Use destructured confirmOptions
-        const startTime = Date.now();
-        setAwaitingConfirm(true);
-        setCurrentChildren(`${displayLabel} (${timeoutSecs}s)`); // Initial display
-        confirmIntervalRef.current = setInterval(() => {
-            const elapsed = Date.now() - startTime;
-            const timeRemaining = timeoutSecs - Math.floor(elapsed / 1000);
-            if (timeRemaining <= 0) {
-                stopWaiting();
-                setWasFailed(true); // Indicate failure for shake animation
-                // Bug 1: Clear any existing timeout before setting a new one
-                if (failTimeoutRef.current) {
-                    clearTimeout(failTimeoutRef.current);
-                }
-                failTimeoutRef.current = setTimeout(() => {
-                    setWasFailed(false);
-                    failTimeoutRef.current = null; // Clear ref after timeout fires
-                }, 400); // Shake animation duration
-            }
-            else {
-                setCurrentChildren(`${displayLabel} (${timeRemaining}s)`);
+        if (confirmOptions) {
+            if (!onClick) {
+                console.warn("ZestButton: 'confirmOptions' are provided but 'onClick' handler is missing.");
             }
-        }, 1000); // Update once per second
-    };
-    // auto-reset success/failure state
-    require$$0.useEffect(() => {
-        if ((wasSuccessful || wasFailed) && autoResetAfterMs) {
-            const timeout = setTimeout(() => {
-                setWasSuccessful(false);
-                setWasFailed(false);
-            }, autoResetAfterMs);
-            return () => clearTimeout(timeout);
+            startConfirmation();
         }
-    }, [wasSuccessful, wasFailed, autoResetAfterMs]);
-    // Enter key handler if isDefault
+        else {
+            handleClick(e);
+        }
+    };
     require$$0.useEffect(() => {
         if (!isDefault || isDisabled)
             return;
@@ -1542,54 +1812,50 @@ zest, // New parent prop
             if (e.key === "Enter" &&
                 !e.repeat &&
                 !e.defaultPrevented &&
-                !(target instanceof HTMLTextAreaElement)) {
+                !(target instanceof HTMLTextAreaElement) &&
+                buttonRef.current &&
+                document.activeElement !== buttonRef.current // Optional: prevent double-action if button is focused
+            ) {
                 e.preventDefault();
-                // Bug 2: Directly call handleConfirmClick to respect confirmation logic
-                handleConfirmClick(e);
+                buttonRef.current.click();
             }
         };
         document.addEventListener("keydown", listener);
         return () => document.removeEventListener("keydown", listener);
-    }, [isDefault, isDisabled, handleConfirmClick]); // Bug 2: Add handleConfirmClick to dependencies
-    // cleanup on unmount
-    require$$0.useEffect(() => {
-        return () => {
-            if (confirmIntervalRef.current) {
-                clearInterval(confirmIntervalRef.current);
-            }
-            // Bug 1: Add cleanup for failTimeoutRef
-            if (failTimeoutRef.current) {
-                clearTimeout(failTimeoutRef.current);
-            }
-        };
-    }, []);
+    }, [isDefault, isDisabled]);
     const renderLeftIcon = () => {
         if (effectiveBusy) {
             return (jsxRuntimeExports.jsx("span", { className: `${styles.icon} ${styles.fadeIn}`, children: jsxRuntimeExports.jsx(fa6.FaSpinner, { className: styles.spinner }) }));
         }
-        else if (wasSuccessful && showCheckmark) {
+        if (wasSuccessful && showCheckmark) {
             return (jsxRuntimeExports.jsx("span", { className: `${styles.icon} ${styles.fadeIn}`, children: jsxRuntimeExports.jsx(AnimatedCheckmark, {}) }));
         }
-        else if (wasFailed && showFailIcon) {
+        if (wasFailed && showFailIcon) {
             return (jsxRuntimeExports.jsx("span", { className: `${styles.icon} ${styles.fadeIn}`, children: jsxRuntimeExports.jsx(AnimatedX, {}) }));
         }
-        else if (iconLeft) {
+        if (iconLeft) {
             return jsxRuntimeExports.jsx("span", { className: styles.icon, children: iconLeft });
         }
         return null;
     };
     return (jsxRuntimeExports.jsx("button", { ref: buttonRef, className: [
             styles.button,
-            styles[buttonStyle], // Apply buttonStyle class
+            styles[buttonStyle],
             styles[variant],
             styles[size],
             fullWidth ? styles.fullWidth : "",
             isDisabled ? styles.disabled : "",
             wasFailed ? styles.shake : "",
-            effectiveTheme === 'light' ? styles['force-light'] : styles['force-dark'], // Apply theme override class
+            effectiveTheme === 'light' ? styles['force-light'] : styles['force-dark'],
             className,
         ].join(" "), disabled: isDisabled, "aria-busy": effectiveBusy, onClick: handleConfirmClick, ...props, children: jsxRuntimeExports.jsxs("span", { className: styles.inner, children: [renderLeftIcon(), jsxRuntimeExports.jsxs("span", { className: styles.content, children: [currentChildren, iconRight && jsxRuntimeExports.jsx("span", { className: styles.icon, children: iconRight })] })] }) }));
 };
 
-module.exports = ZestButton;
+const ZestProvider = ({ config, children }) => {
+    return (jsxRuntimeExports.jsx(ZestContext.Provider, { value: config, children: children }));
+};
+
+exports.ZestButton = ZestButton;
+exports.ZestProvider = ZestProvider;
+exports.useZest = useZest;
 //# sourceMappingURL=index.cjs.js.map