dhre-component-lib 0.1.7 → 0.1.8

package/dist/components/Map/GoogleMap.js

@@ -1,104 +0,0 @@
-import React, { useState, useRef, useEffect } from "react";
-import { GoogleMap, Marker, Circle, DirectionsRenderer, } from "@react-google-maps/api";
-import { useGoogleMapsLoader } from "./GoogleMapsLoader";
-import styles from './GoogleMap.module.scss';
-const MapComponent = ({ containerClassName = "map-container", zoom = 18, mapOptions = {
-    zoomControl: true,
-    tilt: 0,
-    gestureHandling: "auto",
-    mapTypeId: "roadmap",
-}, radius = 5000, googleMapsUrls, buttonText, buttonClassName, }) => {
-    const [location, setLocation] = useState(null);
-    const [mapVisible, setMapVisible] = useState(false);
-    const [directionsResponse, setDirectionsResponse] = useState(null);
-    const mapRef = useRef(null);
-    const directionsService = useRef(null);
-    const directionsRenderer = useRef(null);
-    const handleLocationRequest = () => {
-        if ("geolocation" in navigator) {
-            navigator.geolocation.getCurrentPosition(({ coords }) => {
-                const { latitude, longitude } = coords;
-                setLocation({ latitude, longitude });
-                setMapVisible(true);
-            }, () => {
-                alert("Failed to get location. Please try again.");
-            });
-        }
-        else {
-            alert("Geolocation is not supported by this browser.");
-        }
-    };
-    const handleMarkerClick = (lat, lng) => {
-        if (location) {
-            const directionsServiceInstance = directionsService.current || new google.maps.DirectionsService();
-            const directionsRendererInstance = directionsRenderer.current || new google.maps.DirectionsRenderer();
-            if (!directionsService.current)
-                directionsService.current = directionsServiceInstance;
-            if (!directionsRenderer.current)
-                directionsRenderer.current = directionsRendererInstance;
-            const directionsRequest = {
-                origin: { lat: location.latitude, lng: location.longitude },
-                destination: { lat, lng },
-                travelMode: google.maps.TravelMode.DRIVING,
-            };
-            directionsService.current.route(directionsRequest, (result, status) => {
-                if (status === google.maps.DirectionsStatus.OK) {
-                    setDirectionsResponse(result);
-                    if (mapRef.current && directionsRenderer.current) {
-                        directionsRenderer.current.setMap(mapRef.current);
-                        directionsRenderer.current.setDirections(result);
-                    }
-                }
-                else {
-                    alert("Failed to get directions. Please try again.");
-                }
-            });
-        }
-    };
-    const extractCoordinatesFromUrl = (url) => {
-        const regex = /@(-?\d+\.\d+),(-?\d+\.\d+)/;
-        const match = url.match(regex);
-        if (match) {
-            return {
-                lat: parseFloat(match[1]),
-                lng: parseFloat(match[2]),
-            };
-        }
-        return null;
-    };
-    const { isLoaded } = useGoogleMapsLoader();
-    useEffect(() => { }, [isLoaded]);
-    useEffect(() => { }, [mapVisible]);
-    if (!isLoaded) {
-        return React.createElement("div", null, "Loading map...");
-    }
-    if (mapVisible && location) {
-        return (React.createElement("div", { className: containerClassName },
-            React.createElement("button", { onClick: handleLocationRequest, className: buttonClassName }, buttonText),
-            React.createElement(GoogleMap, { mapContainerStyle: styles.mapContainerStyle, center: { lat: location.latitude, lng: location.longitude }, zoom: zoom, options: mapOptions, onLoad: (map) => {
-                    mapRef.current = map;
-                    directionsRenderer.current = new google.maps.DirectionsRenderer();
-                    directionsRenderer.current.setMap(map);
-                } },
-                React.createElement(Marker, { position: { lat: location.latitude, lng: location.longitude }, icon: "http://maps.google.com/mapfiles/ms/icons/red-dot.png" }),
-                React.createElement(Circle, { center: { lat: location.latitude, lng: location.longitude }, radius: radius, options: {
-                        strokeColor: "#FF0000",
-                        strokeOpacity: 0.8,
-                        strokeWeight: 2,
-                        fillColor: "#FF0000",
-                        fillOpacity: 0,
-                    } }),
-                googleMapsUrls.map((url, index) => {
-                    const coord = extractCoordinatesFromUrl(url);
-                    if (!coord)
-                        return null;
-                    return (React.createElement(Marker, { key: index, position: { lat: coord.lat, lng: coord.lng }, title: `Sample Location ${index + 1}`, icon: "http://maps.google.com/mapfiles/ms/icons/blue-dot.png", onClick: () => handleMarkerClick(coord.lat, coord.lng) }));
-                }),
-                directionsResponse && (React.createElement(DirectionsRenderer, { directions: directionsResponse, options: { suppressMarkers: true } })))));
-    }
-    else {
-        return (React.createElement("div", { className: containerClassName },
-            React.createElement("button", { onClick: handleLocationRequest, className: buttonClassName }, buttonText)));
-    }
-};
-export default MapComponent;

package/dist/components/Map/GoogleMapsLoader.js

@@ -1,10 +0,0 @@
-import { useJsApiLoader } from '@react-google-maps/api';
-const GOOGLE_MAPS_API_KEY = process.env.NEXT_PUBLIC_GOOGLE_MAP_API; // Ensure you are using environment variable
-export const useGoogleMapsLoader = () => {
-    return useJsApiLoader({
-        googleMapsApiKey: GOOGLE_MAPS_API_KEY, // Replace with your API key
-        libraries: ['places', 'drawing', 'geometry'], // Include all libraries you need
-        language: 'en',
-        region: 'US',
-    });
-};

package/dist/components/Map/index.js

@@ -1,3 +0,0 @@
-export { default as Directions } from "./Directions";
-export { default as GoogleMap } from "./GoogleMap";
-import "./GoogleMap.module.scss";

package/dist/components/Modal/Modal.js

@@ -1,14 +0,0 @@
-import React from "react";
-import styles from './Modal.module.scss';
-const Modal = ({ isOpen, onClose, children, modalOverlayClassname = '', modalContentClassname = '' }) => {
-    if (!isOpen)
-        return null;
-    const handleOverlayClick = (event) => {
-        if (event.target === event.currentTarget) {
-            onClose();
-        }
-    };
-    return (React.createElement("button", { className: `${styles.modalOverlay} ${modalOverlayClassname}`, onClick: handleOverlayClick },
-        React.createElement("div", { className: `${styles.modalContent} ${modalContentClassname}` }, children)));
-};
-export default Modal;

package/dist/components/Modal/Modal.test.js

@@ -1,52 +0,0 @@
-import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
-import Modal from './Modal';
-describe('Modal Component', () => {
-    const onCloseMock = jest.fn();
-    const modalContentText = 'This is the modal content';
-    const renderModal = (isOpen, modalOverlayClassname, modalContentClassname) => {
-        render(React.createElement(Modal, { isOpen: isOpen, onClose: onCloseMock, modalOverlayClassname: modalOverlayClassname, modalContentClassname: modalContentClassname },
-            React.createElement("div", null, modalContentText)));
-    };
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it('renders the modal when isOpen is true', () => {
-        renderModal(true);
-        expect(screen.getByText(modalContentText)).toBeInTheDocument();
-    });
-    it('does not render the modal when isOpen is false', () => {
-        renderModal(false);
-        expect(screen.queryByText(modalContentText)).not.toBeInTheDocument();
-    });
-    it('calls onClose when clicking on the overlay', () => {
-        renderModal(true);
-        const overlay = screen.getByText(modalContentText).closest('button');
-        fireEvent.click(overlay);
-        expect(onCloseMock).toHaveBeenCalled();
-    });
-    it('does not call onClose when clicking inside the modal content', () => {
-        renderModal(true);
-        const modalContent = screen.getByText(modalContentText);
-        fireEvent.click(modalContent);
-        expect(onCloseMock).not.toHaveBeenCalled();
-    });
-    it('applies the provided modalOverlayClassname', () => {
-        const overlayClass = 'customOverlayClass';
-        renderModal(true, overlayClass);
-        const overlay = screen.getByText(modalContentText).closest('button');
-        expect(overlay).toHaveClass(overlayClass);
-    });
-    it('applies the provided modalContentClassname', () => {
-        const contentClass = 'customContentClass';
-        renderModal(true, undefined, contentClass);
-        const modalContent = screen.getByText(modalContentText);
-        expect(modalContent.parentElement).toHaveClass(contentClass);
-    });
-    it('does not render modal when isOpen is false, even if modalOverlayClassname and modalContentClassname are provided', () => {
-        const overlayClass = 'customOverlayClass';
-        const contentClass = 'customContentClass';
-        renderModal(false, overlayClass, contentClass);
-        expect(screen.queryByText(modalContentText)).not.toBeInTheDocument();
-    });
-});

package/dist/components/Modal/index.js

@@ -1,2 +0,0 @@
-export { default } from "./Modal";
-import "./Modal.module.scss";

package/dist/components/Notification/Notification.js

@@ -1,21 +0,0 @@
-import React, { useEffect } from "react";
-import './Notification.module.scss';
-const Notification = ({ message, severity = 'info', autoHideDuration = 6000, onClose, }) => {
-    useEffect(() => {
-        if (autoHideDuration && onClose) {
-            const timer = setTimeout(() => {
-                onClose(new Event('timeout'), 'timeout');
-            }, autoHideDuration);
-            return () => clearTimeout(timer);
-        }
-    }, [autoHideDuration, onClose]);
-    const handleClose = (event, reason) => {
-        if (onClose) {
-            onClose(event, reason);
-        }
-    };
-    return (React.createElement("div", { className: `notification ${severity}`, onClick: (e) => handleClose(e), role: "alert" },
-        React.createElement("div", { className: "notification-message" }, message),
-        React.createElement("button", { className: "close-button", onClick: (e) => handleClose(e, 'close'), "aria-label": "Close notification" }, "\u00D7")));
-};
-export default Notification;

package/dist/components/Notification/Notification.test.js

@@ -1,40 +0,0 @@
-import React from 'react';
-import { render, screen, fireEvent, waitFor } from '@testing-library/react';
-import Notification from './Notification';
-describe('Notification Component', () => {
-    const defaultProps = {
-        message: 'Test Message',
-        severity: 'info',
-        autoHideDuration: 6000,
-        onClose: jest.fn(),
-    };
-    const renderNotification = (props = {}) => {
-        return render(React.createElement(Notification, { ...defaultProps, ...props }));
-    };
-    test('renders notification with the correct message', () => {
-        render(React.createElement(Notification, { message: "Test Message", severity: "info" }));
-        // Check if the element exists by querying it
-        const notificationElement = screen.getByText('Test Message');
-        expect(notificationElement).not.toBeNull(); // Equivalent to `toBeInTheDocument`
-        // Alternatively, check for the presence of the role or className
-        const alertElement = screen.getByRole('alert');
-        expect(alertElement.className).toContain('info'); // Check if className includes "info"
-    });
-    test('calls onClose when the notification is clicked', () => {
-        const onClose = jest.fn();
-        renderNotification({ onClose });
-        fireEvent.click(screen.getByRole('alert'));
-        expect(onClose).toHaveBeenCalled();
-    });
-    test('calls onClose when the close button is clicked', () => {
-        const onClose = jest.fn();
-        renderNotification({ onClose });
-        fireEvent.click(screen.getByLabelText('Close notification'));
-        expect(onClose).toHaveBeenCalledWith(expect.anything(), 'close');
-    });
-    test('calls onClose after autoHideDuration expires', async () => {
-        const onClose = jest.fn();
-        renderNotification({ onClose, autoHideDuration: 1000 });
-        await waitFor(() => expect(onClose).toHaveBeenCalledWith(expect.anything(), 'timeout'), { timeout: 1500 });
-    });
-});

package/dist/components/Notification/index.js

@@ -1,2 +0,0 @@
-export { default } from "./Notification";
-import "./Notification.module.scss";

package/dist/components/OtpInput/OtpInput.js

@@ -1,68 +0,0 @@
-import React, { useEffect, useState } from "react";
-import "./OtpInput.module.scss";
-const OTPInput = ({ length = 4, onChange, autoFocus = false, onResend, resendDelay = 60, error = false, errorText, resendText, }) => {
-    const [otp, setOtp] = useState(Array(length).fill(""));
-    const [timer, setTimer] = useState(resendDelay);
-    const [isComplete, setIsComplete] = useState(false);
-    useEffect(() => {
-        const countdown = setInterval(() => {
-            setTimer((prevTimer) => (prevTimer > 0 ? prevTimer - 1 : 0));
-        }, 1000);
-        return () => clearInterval(countdown);
-    }, []);
-    const handleChange = (value, index) => {
-        if (isNaN(Number(value)))
-            return;
-        const newOtp = [...otp];
-        newOtp[index] = value;
-        setOtp(newOtp);
-        onChange(newOtp.join(""));
-        if (value && index < length - 1) {
-            const nextInput = document.getElementById(`otp-input-${index + 1}`);
-            if (nextInput) {
-                nextInput.focus();
-            }
-        }
-    };
-    const handleKeyDown = (e, index) => {
-        if (e.key === "Backspace" && !otp[index] && index > 0) {
-            const prevInput = document.getElementById(`otp-input-${index - 1}`);
-            if (prevInput) {
-                prevInput.focus();
-            }
-        }
-    };
-    const handleResendClick = () => {
-        onResend();
-        setOtp(Array(length).fill(""));
-        setTimer(resendDelay);
-        setIsComplete(false);
-    };
-    useEffect(() => {
-        setIsComplete(otp.every((digit) => digit !== ""));
-    }, [otp]);
-    useEffect(() => {
-        if (error) {
-            setTimer(0);
-        }
-    }, [error]);
-    function getReadableStatus() {
-        if (error) {
-            return "#EB0542";
-        }
-        return isComplete ? "#00B578" : "#A7A7A7";
-    }
-    return (React.createElement("div", { className: "otpMainContainer" },
-        React.createElement("div", { className: "otpInputDiv" }, Array(length)
-            .fill("")
-            .map((_, index) => (React.createElement("input", { key: index, type: "text", id: `otp-input-${index}`, value: otp[index], "data-testid": `otp-input-${index}`, role: "textbox", onChange: (e) => handleChange(e.target.value, index), onKeyDown: (e) => handleKeyDown(e, index), maxLength: 1, style: { border: `1px solid ${getReadableStatus()}` }, className: "otpInput", autoFocus: autoFocus && index === 0 })))),
-        React.createElement("div", { className: "resendContainer" },
-            error ? (React.createElement("div", { className: "errorText" }, errorText)) : (React.createElement("div", { className: "timerText" }, timer > 0 ? `00:${timer} secs` : "")),
-            React.createElement("button", { onClick: handleResendClick, disabled: timer > 0, style: {
-                    border: "none",
-                    background: "none",
-                    cursor: timer > 0 ? "not-allowed" : "pointer",
-                } },
-                React.createElement("div", { className: "resendText" }, resendText)))));
-};
-export default OTPInput;

package/dist/components/OtpInput/OtpInput.test.js

@@ -1,36 +0,0 @@
-import React from 'react';
-import { render, fireEvent, screen } from '@testing-library/react';
-import OTPInput from './OtpInput';
-import '@testing-library/jest-dom';
-describe('OTPInput Component', () => {
-    it('renders the correct number of input fields based on the length prop', () => {
-        render(React.createElement(OTPInput, { length: 4, onChange: () => { }, onResend: () => { }, resendText: "Resend OTP" }));
-        const inputs = screen.getAllByRole('textbox');
-        expect(inputs).toHaveLength(4);
-    });
-    it('calls onChange prop when input changes', () => {
-        const handleChange = jest.fn();
-        render(React.createElement(OTPInput, { length: 4, onChange: handleChange, onResend: () => { }, resendText: "Resend OTP" }));
-        const inputs = screen.getAllByRole('textbox');
-        fireEvent.change(inputs[0], { target: { value: '1' } });
-        expect(handleChange).toHaveBeenCalledWith('1');
-    });
-    it('calls onResend prop when the resend button is clicked', async () => {
-        const handleResend = jest.fn();
-        render(React.createElement(OTPInput, { length: 4, onChange: () => { }, onResend: handleResend, resendText: "Resend OTP", resendDelay: 0 }));
-        const resendButton = screen.getByRole('button', { name: /resend otp/i });
-        fireEvent.click(resendButton);
-        expect(handleResend).toHaveBeenCalled();
-    });
-    it('displays error text when the error prop is true', () => {
-        const errorMessage = 'Invalid OTP';
-        render(React.createElement(OTPInput, { length: 4, onChange: () => { }, onResend: () => { }, resendText: "Resend OTP", error: true, errorText: errorMessage }));
-        const errorElement = screen.getByText(errorMessage);
-        expect(errorElement).toBeInTheDocument();
-    });
-    it('changes border color to red when the error prop is true', () => {
-        render(React.createElement(OTPInput, { length: 4, onChange: () => { }, onResend: () => { }, resendText: "Resend OTP", error: true }));
-        const firstInput = screen.getByTestId('otp-input-0');
-        expect(firstInput).toHaveStyle('border: 1px solid #EB0542');
-    });
-});

package/dist/components/OtpInput/index.js

@@ -1,2 +0,0 @@
-export { default } from "./OtpInput";
-import "./OtpInput.module.scss";

package/dist/components/PdfView/PdfView.js

@@ -1,59 +0,0 @@
-import React, { useEffect } from "react";
-import styles from './PdfView.module.scss';
-const PdfView = ({ content, contentType = "application/pdf", buttonText = "View PDF", loadingText = "Loading...", errorText = "Failed to load PDF", cleanUpDelay = 1000, buttonVariant = "contained", buttonColor = "primary", buttonSize = "medium", showLoadingSpinner = false, spinnerSize = 24, spinnerColor = "primary", className = "", }) => {
-    const [isLoading, setIsLoading] = React.useState(false);
-    const [isError, setIsError] = React.useState(false);
-    const [errorMsg, setErrorMsg] = React.useState(errorText);
-    useEffect(() => {
-        if (btoa(atob(content)) !== content) {
-            setIsError(true);
-        }
-    }, [content]);
-    const base64ToBlob = (content, contentType = "application/pdf") => {
-        try {
-            const byteCharacters = atob(content);
-            const byteArray = new Uint8Array(byteCharacters.length);
-            for (let i = 0; i < byteCharacters.length; i++) {
-                byteArray[i] = byteCharacters.charCodeAt(i);
-            }
-            return new Blob([byteArray], { type: contentType });
-        }
-        catch (error) {
-            setIsError(true);
-            setErrorMsg("Invalid base64 string:");
-            return null;
-        }
-    };
-    const handleViewPdf = async () => {
-        setIsLoading(true);
-        setIsError(false);
-        const blob = base64ToBlob(content, contentType);
-        if (blob) {
-            const url = URL.createObjectURL(blob);
-            window.open(url, "_blank");
-            setTimeout(() => {
-                URL.revokeObjectURL(url);
-            }, cleanUpDelay);
-            setIsLoading(false);
-        }
-        else {
-            setIsLoading(false);
-            setIsError(true);
-            setErrorMsg("Failed to create Blob from base64 string.");
-        }
-    };
-    const buttonClass = `
-    ${styles.button} 
-    ${styles[`button${buttonVariant.charAt(0).toUpperCase() + buttonVariant.slice(1)}`]} 
-    ${styles[`button${buttonColor.charAt(0).toUpperCase() + buttonColor.slice(1)}`]} 
-    ${styles[`button${buttonSize.charAt(0).toUpperCase() + buttonSize.slice(1)}`]}
-  `;
-    const spinnerClass = `${styles.spinner} ${styles.spinnerInner}`;
-    return (React.createElement("div", { className: `${styles.container} ${className}` },
-        isLoading && showLoadingSpinner && (React.createElement("div", { "data-testid": "spinnertest", className: spinnerClass, style: { width: spinnerSize, height: spinnerSize, borderColor: spinnerColor } },
-            React.createElement("div", { className: styles.spinnerInner }))),
-        isError && React.createElement("p", { className: styles.errorText }, errorMsg),
-        !isLoading && !isError && (React.createElement("button", { onClick: handleViewPdf, className: buttonClass }, buttonText)),
-        isLoading && !showLoadingSpinner && React.createElement("p", null, loadingText)));
-};
-export default PdfView;

package/dist/components/PdfView/PdfView.test.js

@@ -1,41 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import PdfView from './PdfView';
-// Dummy base64 content for testing
-const validBase64Content = 'JVBERi0xLjQKJeLjz9MNCjEgMCBvYmoKPDwvTGluay9QYWdlcyAyIDAgUj4+CnN0YXJ0eHJlZgoyNCAwIFIKZW5kb2JqCjEgMCBvYmoKPDwvTGluay9QYWdlcyAyIDAgUj4+CnN0YXJ0eHJlZgo2IDAgUgo+';
-const invalidBase64Content = 'invalid base64 content';
-const errorText = 'Failed to load PDF';
-const buttonText = 'View PDF';
-const loadingText = 'Loading...';
-// Save the original implementation of createObjectURL
-const originalCreateObjectURL = global.URL.createObjectURL;
-describe('PdfView Component', () => {
-    beforeAll(() => {
-        // Mock URL.createObjectURL directly
-        global.URL.createObjectURL = jest.fn(() => 'mock-url');
-    });
-    afterAll(() => {
-        // Restore the original implementation
-        global.URL.createObjectURL = originalCreateObjectURL;
-    });
-    it('renders correctly with default props', () => {
-        render(React.createElement(PdfView, { content: validBase64Content }));
-        expect(screen.getByText(buttonText)).toBeInTheDocument();
-    });
-    it('shows error message if content is invalid', () => {
-        render(React.createElement(PdfView, { content: invalidBase64Content }));
-        expect(screen.getByText(errorText)).toBeInTheDocument();
-    });
-    it('applies the provided class names', () => {
-        const className = 'custom-class';
-        render(React.createElement(PdfView, { content: validBase64Content, className: className }));
-        expect(screen.getByText(buttonText).parentElement).toHaveClass(className);
-    });
-    it('does not show spinner or loading text if isLoading is false', () => {
-        render(React.createElement(PdfView, { content: validBase64Content }));
-        // The component should not be in a loading state initially
-        expect(screen.queryByTestId('spinnertest')).not.toBeInTheDocument();
-        expect(screen.queryByText(loadingText)).not.toBeInTheDocument();
-    });
-});

package/dist/components/PdfView/index.js

@@ -1,2 +0,0 @@
-export { default } from "./PdfView";
-import "./PdfView.module.scss";

package/dist/components/Progress/Progress.js

@@ -1,9 +0,0 @@
-import React from 'react';
-const Progress = ({ value, max, className = '', barContainerClassName = '', barClassName = '', labelClassName = '', label, ...rest }) => {
-    const percentage = (value / max) * 100;
-    return (React.createElement("div", { className: className, ...rest },
-        label && React.createElement("div", { className: labelClassName }, label),
-        React.createElement("div", { className: barContainerClassName },
-            React.createElement("div", { "data-testid": "progress-bar", className: barClassName, style: { width: `${percentage}%` } }))));
-};
-export default Progress;

package/dist/components/Progress/Progress.test.js

@@ -1,34 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import Progress from './Progress';
-describe('Progress Component', () => {
-    it('renders the progress bar with correct percentage width', () => {
-        render(React.createElement(Progress, { value: 50, max: 100, barClassName: "progress-bar" }));
-        const progressBar = screen.getByTestId('progress-bar');
-        expect(progressBar).toHaveStyle('width: 50%');
-    });
-    it('renders the label when provided', () => {
-        render(React.createElement(Progress, { value: 30, max: 100, label: "Loading", labelClassName: "label-class" }));
-        expect(screen.getByText('Loading')).toHaveClass('label-class');
-    });
-    it('does not render the label when not provided', () => {
-        render(React.createElement(Progress, { value: 30, max: 100 }));
-        expect(screen.queryByText('Loading')).not.toBeInTheDocument();
-    });
-    it('handles zero values correctly', () => {
-        render(React.createElement(Progress, { value: 0, max: 100, barClassName: "progress-bar" }));
-        const progressBar = screen.getByTestId('progress-bar');
-        expect(progressBar).toHaveStyle('width: 0%');
-    });
-    it('handles max values correctly', () => {
-        render(React.createElement(Progress, { value: 100, max: 100, barClassName: "progress-bar" }));
-        const progressBar = screen.getByTestId('progress-bar');
-        expect(progressBar).toHaveStyle('width: 100%');
-    });
-    it('handles values greater than max', () => {
-        render(React.createElement(Progress, { value: 150, max: 100, barClassName: "progress-bar" }));
-        const progressBar = screen.getByTestId('progress-bar');
-        expect(progressBar).toHaveStyle('width: 150%'); // Matches the component's behavior
-    });
-});

package/dist/components/Progress/index.js

@@ -1 +0,0 @@
-export { default } from "./Progress";

package/dist/components/RadioButton/RadioButton.js

@@ -1,7 +0,0 @@
-import React from 'react';
-const CustomRadioButton = ({ name, value, checked = false, onChange, className = '', inputClassName = '', labelClassName = '', id, ...rest }) => {
-    return (React.createElement("div", { className: className },
-        React.createElement("input", { type: "radio", name: name, value: value, checked: checked, onChange: onChange, id: id, className: inputClassName, ...rest }),
-        React.createElement("label", { htmlFor: id, className: labelClassName }, value)));
-};
-export default CustomRadioButton;

package/dist/components/RadioButton/RadioButton.test.js

@@ -1,29 +0,0 @@
-import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import CustomRadioButton from './RadioButton';
-describe('CustomRadioButton', () => {
-    it('should render with given props', () => {
-        render(React.createElement(CustomRadioButton, { name: "testName", value: "testValue", checked: true, onChange: () => { }, className: "custom-class", inputClassName: "input-class", labelClassName: "label-class", id: "radio1" }));
-        const radioInput = screen.getByRole('radio');
-        const label = screen.getByText('testValue'); // Use text to find the label
-        // Assert that the radio input is rendered correctly
-        expect(radioInput).toBeInTheDocument();
-        expect(radioInput).toHaveAttribute('name', 'testName');
-        expect(radioInput).toHaveAttribute('value', 'testValue');
-        expect(radioInput).toBeChecked();
-        expect(radioInput).toHaveClass('input-class');
-        // Assert that the label is rendered correctly
-        expect(label).toBeInTheDocument();
-        // Ensure the label has the correct class by finding the label element directly
-        const labelElement = document.querySelector(`label[for="radio1"]`);
-        expect(labelElement).toHaveClass('label-class');
-    });
-    it('should call onChange handler when clicked', () => {
-        const handleChange = jest.fn();
-        render(React.createElement(CustomRadioButton, { name: "testName", value: "testValue", onChange: handleChange, id: "radio1" }));
-        const radioInput = screen.getByRole('radio');
-        fireEvent.click(radioInput);
-        expect(handleChange).toHaveBeenCalled();
-    });
-});

package/dist/components/RadioButton/index.js

@@ -1 +0,0 @@
-export { default } from "./RadioButton";

package/dist/components/Switch/Switch.js

@@ -1,10 +0,0 @@
-import React from "react";
-import './Switch.css';
-const Switch = ({ checked, handleChange, switchClassName, label, labelClassName, containerClassName, toggleClassName }) => {
-    return (React.createElement("div", { className: containerClassName },
-        label && React.createElement("span", { className: labelClassName }, label),
-        React.createElement("label", { className: toggleClassName },
-            React.createElement("input", { type: "checkbox", checked: checked, onChange: handleChange }),
-            React.createElement("span", { className: switchClassName }))));
-};
-export default Switch;

package/dist/components/Switch/Switch.test.js

@@ -1,45 +0,0 @@
-import React, { useState } from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
-import '@testing-library/jest-dom';
-import Switch from './Switch';
-describe('Switch Component', () => {
-    it('renders with basic props', () => {
-        const { container } = render(React.createElement(Switch, { checked: true, handleChange: () => { }, switchClassName: "switch-class" }));
-        const switchInput = screen.getByRole('checkbox');
-        const switchToggle = container.querySelector('.switch-class');
-        expect(switchInput).toBeInTheDocument();
-        expect(switchInput).toBeChecked();
-        expect(switchToggle).toBeInTheDocument();
-    });
-    it('renders with a label', () => {
-        render(React.createElement(Switch, { checked: true, handleChange: () => { }, switchClassName: "switch-class", label: "Toggle Switch", labelClassName: "label-class" }));
-        const label = screen.getByText('Toggle Switch');
-        const switchInput = screen.getByRole('checkbox');
-        expect(label).toBeInTheDocument();
-        expect(label).toHaveClass('label-class');
-        expect(switchInput).toBeChecked();
-    });
-    it('calls handleChange handler when clicked', () => {
-        // Simulate a component that manages its own state
-        const TestComponent = () => {
-            const [checked, setChecked] = useState(false);
-            return (React.createElement(Switch, { checked: checked, handleChange: () => setChecked(!checked), switchClassName: "switch-class" }));
-        };
-        render(React.createElement(TestComponent, null));
-        const switchInput = screen.getByRole('checkbox');
-        expect(switchInput).not.toBeChecked();
-        // Simulate the click event
-        fireEvent.click(switchInput);
-        // Check if the switchInput is now checked
-        expect(switchInput).toBeChecked();
-    });
-    it('applies custom classes', () => {
-        const { container } = render(React.createElement(Switch, { checked: true, handleChange: () => { }, switchClassName: "switch-class", containerClassName: "container-class", toggleClassName: "toggle-class", label: "Toggle Switch", labelClassName: "label-class" }));
-        const containerDiv = container.querySelector('.container-class');
-        const switchToggle = container.querySelector('.switch-class');
-        const label = screen.getByText('Toggle Switch');
-        expect(containerDiv).toHaveClass('container-class');
-        expect(switchToggle).toHaveClass('switch-class');
-        expect(label).toHaveClass('label-class');
-    });
-});

package/dist/components/Switch/index.js

@@ -1 +0,0 @@
-export { default } from "./Switch";

package/dist/components/Tag/Tag.js

@@ -1,6 +0,0 @@
-import React from "react";
-import styles from "./Tag.module.scss";
-const Tag = ({ content, tagClassName = styles.customTagClass, handleClick, style }) => {
-    return (React.createElement("button", { onClick: handleClick, style: style, className: tagClassName }, content));
-};
-export default Tag;