dhre-component-lib 0.1.6 → 0.1.7

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

@@ -0,0 +1,36 @@
+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.d.ts

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

package/dist/components/OtpInput/index.js

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

package/dist/components/PdfView/PdfView.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+export interface PdfViewerProps {
+    content: string;
+    contentType?: string;
+    buttonText?: string;
+    loadingText?: string;
+    errorText?: string;
+    cleanUpDelay?: number;
+    buttonVariant?: "text" | "outlined" | "contained";
+    buttonColor?: "inherit" | "primary" | "secondary" | "error" | "info" | "success" | "warning";
+    buttonSize?: "small" | "medium" | "large";
+    showLoadingSpinner?: boolean;
+    spinnerSize?: number;
+    spinnerColor?: "inherit" | "primary" | "secondary";
+    className?: string;
+}
+declare const PdfView: React.FC<PdfViewerProps>;
+export default PdfView;

package/dist/components/PdfView/PdfView.js

@@ -0,0 +1,59 @@
+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.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

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

@@ -0,0 +1,41 @@
+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.d.ts

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

package/dist/components/PdfView/index.js

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

package/dist/components/Progress/Progress.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface ProgressProps {
+    value: number;
+    max: number;
+    className?: string;
+    barContainerClassName?: string;
+    barClassName?: string;
+    labelClassName?: string;
+    label?: string;
+}
+declare const Progress: React.FC<ProgressProps>;
+export default Progress;

package/dist/components/Progress/Progress.js

@@ -0,0 +1,9 @@
+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.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

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

@@ -0,0 +1,34 @@
+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.d.ts

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

package/dist/components/Progress/index.js

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

package/dist/components/RadioButton/RadioButton.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+interface RadioButtonProps {
+    name: string;
+    value: string;
+    checked?: boolean;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    className?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    id?: string;
+    [key: string]: any;
+}
+declare const CustomRadioButton: React.FC<RadioButtonProps>;
+export default CustomRadioButton;

package/dist/components/RadioButton/RadioButton.js

@@ -0,0 +1,7 @@
+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.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

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

@@ -0,0 +1,29 @@
+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.d.ts

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

package/dist/components/RadioButton/index.js

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

package/dist/components/Switch/Switch.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import './Switch.css';
+export interface SwitchProps {
+    checked: boolean;
+    handleChange: () => void;
+    switchClassName: string;
+    label?: string;
+    labelClassName?: string;
+    containerClassName?: string;
+    toggleClassName?: string;
+}
+declare const Switch: React.FC<SwitchProps>;
+export default Switch;

package/dist/components/Switch/Switch.js

@@ -0,0 +1,10 @@
+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.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

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

@@ -0,0 +1,45 @@
+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.d.ts

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

package/dist/components/Switch/index.js

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

package/dist/components/Tag/Tag.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export interface TagProps {
+    content: string | number;
+    tagClassName?: string;
+    handleClick?: () => void;
+    style?: React.CSSProperties;
+}
+declare const Tag: React.FC<TagProps>;
+export default Tag;

package/dist/components/Tag/Tag.js

@@ -0,0 +1,6 @@
+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;

package/dist/components/Tag/Tag.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/components/Tag/Tag.test.js

@@ -0,0 +1,43 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Tag from './Tag';
+describe('Tag Component', () => {
+    let handleClick;
+    beforeEach(() => {
+        handleClick = jest.fn(); // Reset the mock function before each test
+    });
+    // Function to generate default props for each test
+    const getDefaultProps = () => ({
+        content: 'Sample Tag',
+        tagClassName: 'tag-class',
+        handleClick,
+    });
+    it('renders the tag with the correct content', () => {
+        render(React.createElement(Tag, { ...getDefaultProps() }));
+        const tagElement = screen.getByText('Sample Tag');
+        expect(tagElement).toBeInTheDocument();
+    });
+    it('applies the correct className to the tag', () => {
+        render(React.createElement(Tag, { ...getDefaultProps() }));
+        const tagElement = screen.getByText('Sample Tag');
+        expect(tagElement).toHaveClass('tag-class');
+    });
+    it('calls the handleClick function when the tag is clicked', () => {
+        render(React.createElement(Tag, { ...getDefaultProps() }));
+        const tagElement = screen.getByText('Sample Tag');
+        fireEvent.click(tagElement);
+        expect(handleClick).toHaveBeenCalledTimes(1);
+    });
+    it('does not call handleClick when the tag is not clicked', () => {
+        render(React.createElement(Tag, { ...getDefaultProps() }));
+        expect(handleClick).not.toHaveBeenCalled();
+    });
+    it('renders correctly with different content', () => {
+        const newContent = 'New Tag Content';
+        render(React.createElement(Tag, { ...getDefaultProps(), content: newContent }));
+        const tagElement = screen.getByText(newContent);
+        expect(tagElement).toBeInTheDocument();
+        expect(tagElement).toHaveTextContent(newContent);
+    });
+});

package/dist/components/Tag/index.d.ts

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

package/dist/components/Tag/index.js

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

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export interface TooltipProps {
+    content: string;
+    tooltipClassName: string;
+    children: React.ReactNode;
+    containerClassName?: string;
+}
+declare const Tooltip: React.FC<TooltipProps>;
+export default Tooltip;

package/dist/components/Tooltip/Tooltip.js

@@ -0,0 +1,11 @@
+import React, { useState } from "react";
+import styles from './Tooltip.module.scss';
+const Tooltip = ({ content, tooltipClassName, children, containerClassName = "", }) => {
+    const [visible, setVisible] = useState(false);
+    const showTooltip = () => setVisible(true);
+    const hideTooltip = () => setVisible(false);
+    return (React.createElement("div", { className: `${styles.tooltipWrapper} ${containerClassName}`, onMouseEnter: showTooltip, onMouseLeave: hideTooltip },
+        children,
+        visible && (React.createElement("div", { className: `${styles.customTooltipClass} ${tooltipClassName}` }, content))));
+};
+export default Tooltip;

package/dist/components/Tooltip/Tooltip.test.d.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom";

package/dist/components/Tooltip/Tooltip.test.js

@@ -0,0 +1,48 @@
+import React from "react";
+import { render, screen, fireEvent } from "@testing-library/react";
+import "@testing-library/jest-dom";
+import Tooltip from "./Tooltip";
+describe("Tooltip Component", () => {
+    const defaultProps = {
+        content: "Tooltip content",
+        tooltipClassName: "tooltip-class",
+        children: React.createElement("button", null, "Hover me"),
+    };
+    it("renders the children correctly", () => {
+        render(React.createElement(Tooltip, { ...defaultProps }));
+        const childElement = screen.getByText("Hover me");
+        expect(childElement).toBeInTheDocument();
+    });
+    it("does not show tooltip content by default", () => {
+        render(React.createElement(Tooltip, { ...defaultProps }));
+        const tooltipElement = screen.queryByText(defaultProps.content);
+        expect(tooltipElement).not.toBeInTheDocument();
+    });
+    it("shows tooltip content on mouse enter and hides it on mouse leave", () => {
+        render(React.createElement(Tooltip, { ...defaultProps }));
+        const childElement = screen.getByText("Hover me");
+        // Trigger mouse enter
+        fireEvent.mouseEnter(childElement);
+        let tooltipElement = screen.queryByText(defaultProps.content);
+        expect(tooltipElement).toBeInTheDocument();
+        expect(tooltipElement).toHaveClass(defaultProps.tooltipClassName);
+        // Trigger mouse leave
+        fireEvent.mouseLeave(childElement);
+        tooltipElement = screen.queryByText(defaultProps.content);
+        // Ensure tooltipElement is null if it was not found
+        expect(tooltipElement).toBeNull();
+    });
+    it("applies the correct container className", () => {
+        const customClassName = "custom-container-class";
+        render(React.createElement(Tooltip, { ...defaultProps, containerClassName: customClassName }));
+        const containerElement = screen.getByText("Hover me").parentElement;
+        expect(containerElement).toHaveClass(customClassName);
+    });
+    it("handles tooltip visibility correctly", () => {
+        render(React.createElement(Tooltip, { ...defaultProps }));
+        const childElement = screen.getByText("Hover me");
+        fireEvent.mouseEnter(childElement);
+        const tooltipElement = screen.queryByText(defaultProps.content);
+        expect(tooltipElement).toBeInTheDocument();
+    });
+});

package/dist/components/Tooltip/index.d.ts

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

package/dist/components/Tooltip/index.js

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

package/dist/components/index.d.ts

@@ -0,0 +1,15 @@
+export { default as Button } from "./Button";
+export { default as Avatar } from "./Avatar";
+export { default as Badge } from "./Badge";
+export { default as BreadCrumb } from "./BreadCrumb";
+export { default as Checkbox } from "./Checkbox";
+export { default as CircularProgress } from "./CircularProgress";
+export { default as Divider } from "./Divider";
+export { default as Link } from "./Link";
+export { default as Progress } from "./Progress";
+export { default as RadioButton } from "./RadioButton";
+export { default as InputTextField } from "./InputTextField";
+export { default } from "./PdfView";
+export { default as Directions } from "./Map/Directions";
+export { default as GoogleMap } from "./Map/GoogleMap";
+export { default as OtpInput } from "./OtpInput/OtpInput";

package/dist/components/index.js

@@ -0,0 +1,15 @@
+export { default as Button } from "./Button";
+export { default as Avatar } from "./Avatar";
+export { default as Badge } from "./Badge";
+export { default as BreadCrumb } from "./BreadCrumb";
+export { default as Checkbox } from "./Checkbox";
+export { default as CircularProgress } from "./CircularProgress";
+export { default as Divider } from "./Divider";
+export { default as Link } from "./Link";
+export { default as Progress } from "./Progress";
+export { default as RadioButton } from "./RadioButton";
+export { default as InputTextField } from "./InputTextField";
+export { default } from "./PdfView";
+export { default as Directions } from "./Map/Directions";
+export { default as GoogleMap } from "./Map/GoogleMap";
+export { default as OtpInput } from "./OtpInput/OtpInput";

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './components';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './components';

package/dist/theme/colors.d.ts

@@ -0,0 +1 @@
+export declare const COLORS: {};

package/dist/theme/colors.js

@@ -0,0 +1,2 @@
+// format: Color name: BRAND_800
+export const COLORS = {};