dhre-component-lib 0.1.5 → 0.1.7

package/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export interface AvatarProps {
+    src: string;
+    alt: string;
+    imgClassName: string;
+    handleClick?: () => void;
+}
+declare const Avatar: React.FC<AvatarProps>;
+export default Avatar;

package/dist/components/Avatar/Avatar.js

@@ -0,0 +1,6 @@
+import React from "react";
+const Avatar = ({ src, alt, imgClassName, handleClick, }) => {
+    return (React.createElement("button", { onClick: handleClick },
+        React.createElement("img", { src: src, alt: alt, className: imgClassName })));
+};
+export default Avatar;

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

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

package/dist/components/Avatar/Avatar.test.js

@@ -0,0 +1,39 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Avatar from './Avatar';
+describe('Avatar Component', () => {
+    const defaultProps = {
+        src: 'test-image.jpg',
+        alt: 'Test Avatar',
+        imgClassName: 'avatar-class',
+    };
+    it('renders the image with the provided src and alt attributes', () => {
+        render(React.createElement(Avatar, { ...defaultProps }));
+        const imgElement = screen.getByAltText(defaultProps.alt);
+        expect(imgElement).toHaveAttribute('src', defaultProps.src);
+        expect(imgElement).toHaveAttribute('alt', defaultProps.alt);
+    });
+    it('applies the correct className to the image', () => {
+        render(React.createElement(Avatar, { ...defaultProps }));
+        const imgElement = screen.getByAltText(defaultProps.alt);
+        expect(imgElement).toHaveClass(defaultProps.imgClassName);
+    });
+    it('handles the onClick event correctly', () => {
+        const handleClick = jest.fn();
+        render(React.createElement(Avatar, { ...defaultProps, handleClick: handleClick }));
+        const imgElement = screen.getByAltText(defaultProps.alt);
+        fireEvent.click(imgElement);
+        expect(handleClick).toHaveBeenCalledTimes(1);
+    });
+    it('does not crash without handleClick prop', () => {
+        render(React.createElement(Avatar, { ...defaultProps }));
+        const imgElement = screen.getByAltText(defaultProps.alt);
+        expect(() => fireEvent.click(imgElement)).not.toThrow();
+    });
+    it('renders correctly without crashing', () => {
+        render(React.createElement(Avatar, { ...defaultProps }));
+        const imgElement = screen.getByAltText(defaultProps.alt);
+        expect(imgElement).toBeInTheDocument();
+    });
+});

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

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

package/dist/components/Avatar/index.js

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

package/dist/components/Badge/Badge.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export interface BadgeProps {
+    content: string | number;
+    badgeClassName?: string;
+    handleClick?: () => void;
+}
+declare const Badge: React.FC<BadgeProps>;
+export default Badge;

package/dist/components/Badge/Badge.js

@@ -0,0 +1,6 @@
+import React from "react";
+import styles from './Badge.module.scss';
+const Badge = ({ content, badgeClassName, handleClick, }) => {
+    return (React.createElement("button", { onClick: handleClick, className: `${styles.badge} ${badgeClassName}` }, content));
+};
+export default Badge;

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

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

package/dist/components/Badge/Badge.test.js

@@ -0,0 +1,44 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Badge from './Badge';
+describe('Badge Component', () => {
+    const defaultProps = {
+        content: 'Test Badge',
+        badgeClassName: 'badge-class',
+    };
+    it('renders the badge with the provided content', () => {
+        render(React.createElement(Badge, { ...defaultProps }));
+        const badgeElement = screen.getByText(defaultProps.content);
+        expect(badgeElement).toBeInTheDocument();
+    });
+    it('handles the onClick event correctly', () => {
+        const handleClick = jest.fn();
+        render(React.createElement(Badge, { ...defaultProps, handleClick: handleClick }));
+        const badgeElement = screen.getByText(defaultProps.content);
+        fireEvent.click(badgeElement);
+        expect(handleClick).toHaveBeenCalledTimes(1);
+    });
+    it('does not crash without handleClick prop', () => {
+        render(React.createElement(Badge, { ...defaultProps }));
+        const badgeElement = screen.getByText(defaultProps.content);
+        expect(() => fireEvent.click(badgeElement)).not.toThrow();
+    });
+    it('renders correctly with numeric content', () => {
+        const numericProps = {
+            ...defaultProps,
+            content: 99,
+        };
+        render(React.createElement(Badge, { ...numericProps }));
+        const badgeElement = screen.getByText(numericProps.content.toString());
+        expect(badgeElement).toBeInTheDocument();
+        expect(badgeElement).toHaveTextContent('99');
+    });
+    it('renders correctly with different content', () => {
+        const newContent = 'Updated Badge';
+        render(React.createElement(Badge, { ...defaultProps, content: newContent }));
+        const badgeElement = screen.getByText(newContent);
+        expect(badgeElement).toBeInTheDocument();
+        expect(badgeElement).toHaveTextContent(newContent);
+    });
+});

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

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

package/dist/components/Badge/index.js

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

package/dist/components/BreadCrumb/BreadCrumb.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export interface BreadcrumbItem {
+    label: string;
+    handleClick?: () => void;
+}
+export interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    breadcrumbClassName: string;
+    itemClassName?: string;
+    separator?: string;
+    separatorClassName?: string;
+}
+declare const Breadcrumb: React.FC<BreadcrumbProps>;
+export default Breadcrumb;

package/dist/components/BreadCrumb/BreadCrumb.js

@@ -0,0 +1,8 @@
+import React from "react";
+import styles from './Breadcrumb.module.scss';
+const Breadcrumb = ({ items, breadcrumbClassName, itemClassName, separator = "/", separatorClassName, }) => {
+    return (React.createElement("nav", { className: `${styles.breadcrumb} ${breadcrumbClassName}` }, items.map((item, index) => (React.createElement(React.Fragment, { key: index },
+        React.createElement("button", { className: `${styles.breadcrumbItem} ${itemClassName}`, onClick: item.handleClick }, item.label),
+        index < items.length - 1 && (React.createElement("span", { className: `${styles.separator} ${separatorClassName}` }, separator)))))));
+};
+export default Breadcrumb;

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

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

package/dist/components/BreadCrumb/BreadCrumb.test.js

@@ -0,0 +1,55 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Breadcrumb from './BreadCrumb';
+describe('Breadcrumb', () => {
+    it('should render with given props', () => {
+        const items = [
+            { label: 'Home', handleClick: () => { } },
+            { label: 'Library' },
+            { label: 'Data' },
+        ];
+        render(React.createElement(Breadcrumb, { items: items, breadcrumbClassName: "breadcrumb-class", itemClassName: "item-class", separator: ">", separatorClassName: "separator-class" }));
+        // Check if breadcrumb container is rendered
+        const breadcrumb = screen.getByRole('navigation');
+        expect(breadcrumb).toBeInTheDocument();
+        expect(breadcrumb).toHaveClass('breadcrumb-class');
+        // Check if breadcrumb items are rendered
+        items.forEach((item) => {
+            const itemElement = screen.getByText(item.label);
+            expect(itemElement).toBeInTheDocument();
+            expect(itemElement).toHaveClass('item-class');
+        });
+        // Check if separators are rendered
+        const separators = screen.getAllByText('>');
+        expect(separators.length).toBe(items.length - 1);
+        separators.forEach(separator => expect(separator).toHaveClass('separator-class'));
+    });
+    it('should call handleClick when a breadcrumb item is clicked', () => {
+        const handleClick = jest.fn();
+        const items = [
+            { label: 'Home', handleClick },
+            { label: 'Library' },
+        ];
+        render(React.createElement(Breadcrumb, { items: items, breadcrumbClassName: "breadcrumb-class", itemClassName: "item-class", separator: ">", separatorClassName: "separator-class" }));
+        const homeItem = screen.getByText('Home');
+        fireEvent.click(homeItem);
+        expect(handleClick).toHaveBeenCalled();
+    });
+    it('should render without separators if none are provided', () => {
+        const items = [
+            { label: 'Home' },
+            { label: 'Library' },
+        ];
+        render(React.createElement(Breadcrumb, { items: items, breadcrumbClassName: "breadcrumb-class", itemClassName: "item-class", separator: "" // Pass an empty string for separator
+         }));
+        // Check if breadcrumb items are rendered
+        items.forEach((item) => {
+            const itemElement = screen.getByText(item.label);
+            expect(itemElement).toBeInTheDocument();
+        });
+        // Check that no separators are present by querying with the separator class name
+        const separators = screen.queryAllByRole('presentation');
+        expect(separators.length).toBe(0);
+    });
+});

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

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

package/dist/components/BreadCrumb/index.js

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

package/dist/components/Button/Button.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export interface ButtonProps {
+    label: string;
+    variant: 'text' | 'outlined' | 'contained';
+    color: 'primary' | 'secondary' | 'success' | 'error' | 'warning' | 'info';
+    size: 'small' | 'medium' | 'large';
+    handleClick: () => void;
+}
+declare const Button: React.FC<ButtonProps>;
+export default Button;

package/dist/components/Button/Button.js

@@ -0,0 +1,6 @@
+import React from "react";
+import styles from './Button.module.scss';
+const Button = ({ label, variant, color, size, handleClick, }) => {
+    return (React.createElement("button", { onClick: handleClick, className: `${styles.button} ${styles[variant]} ${styles[color]} ${styles[size]}` }, label));
+};
+export default Button;

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

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

package/dist/components/Button/Button.test.js

@@ -0,0 +1,36 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Button from './Button';
+describe('Button Component', () => {
+    let handleClick;
+    beforeEach(() => {
+        handleClick = jest.fn(); // Initialize the mock function before each test
+    });
+    const renderButton = (props = {}) => {
+        const defaultProps = {
+            label: 'Click Me',
+            variant: 'contained',
+            color: 'primary',
+            size: 'small',
+            handleClick: handleClick
+        };
+        return render(React.createElement(Button, { ...defaultProps }));
+    };
+    it('renders the button with the correct label', () => {
+        renderButton();
+        const buttonElement = screen.getByText('Click Me');
+        expect(buttonElement).toBeInTheDocument();
+        expect(buttonElement.tagName).toBe('BUTTON');
+    });
+    it('calls the handleClick function when the button is clicked', () => {
+        renderButton();
+        const buttonElement = screen.getByText('Click Me');
+        fireEvent.click(buttonElement);
+        expect(handleClick).toHaveBeenCalledTimes(1); // Ensure the mock function is called once
+    });
+    it('does not call handleClick when the button is not clicked', () => {
+        renderButton();
+        expect(handleClick).not.toHaveBeenCalled();
+    });
+});

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

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

package/dist/components/Button/index.js

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

package/dist/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface CustomCheckboxProps {
+    label?: string;
+    checked?: boolean;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    className?: string;
+    checkboxClassName?: string;
+    labelClassName?: string;
+}
+declare const CustomCheckbox: React.FC<CustomCheckboxProps>;
+export default CustomCheckbox;

package/dist/components/Checkbox/Checkbox.js

@@ -0,0 +1,7 @@
+import React from 'react';
+const CustomCheckbox = ({ label, checked = false, onChange, className = '', checkboxClassName = '', labelClassName = '', ...rest }) => {
+    return (React.createElement("div", { className: className },
+        React.createElement("input", { type: "checkbox", checked: checked, onChange: onChange, className: checkboxClassName, ...rest }),
+        label && React.createElement("label", { className: labelClassName }, label)));
+};
+export default CustomCheckbox;

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

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

package/dist/components/Checkbox/Checkbox.test.js

@@ -0,0 +1,59 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import CustomCheckbox from './Checkbox';
+describe('CustomCheckbox Component', () => {
+    let handleChange;
+    // Function to generate default props for each test
+    const getDefaultProps = () => ({
+        label: 'Accept Terms',
+        checked: false,
+        onChange: handleChange,
+        className: 'custom-container',
+        checkboxClassName: 'custom-checkbox',
+        labelClassName: 'custom-label',
+    });
+    beforeEach(() => {
+        handleChange = jest.fn(); // Reset the mock function before each test
+    });
+    it('renders the checkbox with a label', () => {
+        render(React.createElement(CustomCheckbox, { ...getDefaultProps() }));
+        const checkboxElement = screen.getByRole('checkbox');
+        const labelElement = screen.getByText('Accept Terms');
+        expect(checkboxElement).toBeInTheDocument();
+        expect(labelElement).toBeInTheDocument();
+    });
+    it('applies the correct className to the checkbox container', () => {
+        render(React.createElement(CustomCheckbox, { ...getDefaultProps() }));
+        const container = screen.getByRole('checkbox').parentElement;
+        expect(container).toHaveClass('custom-container');
+    });
+    it('applies the correct className to the checkbox', () => {
+        render(React.createElement(CustomCheckbox, { ...getDefaultProps() }));
+        const checkboxElement = screen.getByRole('checkbox');
+        expect(checkboxElement).toHaveClass('custom-checkbox');
+    });
+    it('applies the correct className to the label', () => {
+        render(React.createElement(CustomCheckbox, { ...getDefaultProps() }));
+        const labelElement = screen.getByText('Accept Terms');
+        expect(labelElement).toHaveClass('custom-label');
+    });
+    it('checks the checkbox based on the checked prop', () => {
+        render(React.createElement(CustomCheckbox, { ...getDefaultProps(), checked: true }));
+        const checkboxElement = screen.getByRole('checkbox');
+        expect(checkboxElement).toBeChecked();
+    });
+    it('calls the onChange function when the checkbox state changes', () => {
+        render(React.createElement(CustomCheckbox, { ...getDefaultProps(), checked: false }));
+        const checkboxElement = screen.getByRole('checkbox');
+        fireEvent.click(checkboxElement); // Toggle the checkbox
+        expect(handleChange).toHaveBeenCalledTimes(1);
+    });
+    it('renders correctly with different label', () => {
+        const newLabel = 'Agree to Privacy Policy';
+        render(React.createElement(CustomCheckbox, { ...getDefaultProps(), label: newLabel }));
+        const labelElement = screen.getByText(newLabel);
+        expect(labelElement).toBeInTheDocument();
+        expect(labelElement).toHaveTextContent(newLabel);
+    });
+});

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

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

package/dist/components/Checkbox/index.js

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

package/dist/components/CircularProgress/CircularProgress.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface CircularProgressProps {
+    value?: number;
+    variant?: 'determinate' | 'indeterminate';
+    color?: 'primary' | 'secondary' | 'error' | 'success' | 'info' | 'warning';
+    thickness?: number;
+    size?: number | string;
+}
+declare const CircularProgress: React.FC<CircularProgressProps>;
+export default CircularProgress;

package/dist/components/CircularProgress/CircularProgress.js

@@ -0,0 +1,15 @@
+import React from 'react';
+import styles from './CircularProgress.module.scss';
+const CircularProgress = ({ value = 0, variant = 'indeterminate', color = 'primary', thickness = 4, size = 100, }) => {
+    const isDeterminate = variant === 'determinate';
+    const rotationStyle = isDeterminate
+        ? { transform: `rotate(${(value / 100) * 360}deg)` }
+        : {};
+    return (React.createElement("div", { className: `${styles.spinner} ${styles[color]}`, style: {
+            width: typeof size === 'number' ? `${size}px` : size,
+            height: typeof size === 'number' ? `${size}px` : size,
+            borderWidth: `${thickness}px`,
+            ...rotationStyle,
+        } }));
+};
+export default CircularProgress;

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

@@ -0,0 +1 @@
+export {};

package/dist/components/CircularProgress/CircularProgress.test.js

@@ -0,0 +1,31 @@
+import React from "react";
+import { render } from "@testing-library/react";
+import CircularProgress from "./CircularProgress";
+describe("Loading Component", () => {
+    const renderComponent = (props) => render(React.createElement(CircularProgress, { ...props }));
+    it("applies the correct size and thickness", () => {
+        const { container } = renderComponent({ size: 60, thickness: 5 });
+        const spinner = container.firstChild;
+        expect(spinner).not.toBeNull();
+        expect(spinner.style.width).toBe("60px");
+        expect(spinner.style.height).toBe("60px");
+        expect(spinner.style.borderWidth).toBe("5px");
+    });
+    it("renders the determinate spinner with the correct rotation", () => {
+        const { container } = renderComponent({
+            variant: "determinate",
+            value: 75,
+        });
+        const spinner = container.firstChild;
+        const expectedRotation = `rotate(${(75 / 100) * 360}deg)`;
+        expect(spinner).not.toBeNull();
+        expect(spinner.style.transform).toBe(expectedRotation);
+    });
+    it("handles string size correctly", () => {
+        const { container } = renderComponent({ size: "50%" });
+        const spinner = container.firstChild;
+        expect(spinner).not.toBeNull();
+        expect(spinner.style.width).toBe("50%");
+        expect(spinner.style.height).toBe("50%");
+    });
+});

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

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

package/dist/components/CircularProgress/index.js

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

package/dist/components/Divider/Divider.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+interface CustomDividerProps {
+    orientation?: string;
+    className?: string;
+    dividerClassName?: string;
+}
+declare const CustomDivider: React.FC<CustomDividerProps>;
+export default CustomDivider;

package/dist/components/Divider/Divider.js

@@ -0,0 +1,7 @@
+import React from "react";
+import { DIVIDER_ORIENTATION } from "../Enum";
+const CustomDivider = ({ orientation = DIVIDER_ORIENTATION.Horizontal, className = "", dividerClassName = "", ...rest }) => {
+    return (React.createElement("div", { className: `${className} ${orientation}`, ...rest },
+        React.createElement("div", { className: dividerClassName })));
+};
+export default CustomDivider;

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

@@ -0,0 +1 @@
+export {};

package/dist/components/Divider/Divider.test.js

@@ -0,0 +1,30 @@
+import React from "react";
+import { render } from "@testing-library/react";
+import CustomDivider from "./Divider";
+import { DIVIDER_ORIENTATION } from "../Enum";
+describe("CustomDivider Component", () => {
+    it("renders without crashing", () => {
+        const { container } = render(React.createElement(CustomDivider, null));
+        expect(container.firstChild).toBeTruthy();
+    });
+    it("applies the correct default orientation class", () => {
+        const { container } = render(React.createElement(CustomDivider, null));
+        expect(container.firstChild).toHaveClass(DIVIDER_ORIENTATION.Horizontal);
+    });
+    it("applies a custom orientation class", () => {
+        const { container } = render(React.createElement(CustomDivider, { orientation: DIVIDER_ORIENTATION.Vertical }));
+        expect(container.firstChild).toHaveClass(DIVIDER_ORIENTATION.Vertical);
+    });
+    it("applies the passed className to the outer div", () => {
+        const { container } = render(React.createElement(CustomDivider, { className: "custom-class" }));
+        expect(container.firstChild).toHaveClass("custom-class");
+    });
+    it("applies the passed dividerClassName to the inner div", () => {
+        const { container } = render(React.createElement(CustomDivider, { dividerClassName: "inner-class" }));
+        expect(container.firstChild?.firstChild).toHaveClass("inner-class");
+    });
+    it("passes additional props to the outer div", () => {
+        const { container } = render(React.createElement(CustomDivider, { "data-testid": "custom-divider" }));
+        expect(container.firstChild).toHaveAttribute("data-testid", "custom-divider");
+    });
+});

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

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

package/dist/components/Divider/index.js

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

package/dist/components/Enum.d.ts

@@ -0,0 +1,17 @@
+export declare const INPUT_TYPES: {
+    PASSWORD: string;
+    TEXT: string;
+    EMAIL: string;
+    NUMBER: string;
+    DATE: string;
+};
+export declare const DIVIDER_ORIENTATION: {
+    Horizontal: string;
+    Vertical: string;
+};
+export declare const LINK_TARGET: {
+    Self: string;
+    Blank: string;
+    Parent: string;
+    Top: string;
+};

package/dist/components/Enum.js

@@ -0,0 +1,17 @@
+export const INPUT_TYPES = {
+    PASSWORD: 'password',
+    TEXT: 'text',
+    EMAIL: 'email',
+    NUMBER: 'number',
+    DATE: 'date',
+};
+export const DIVIDER_ORIENTATION = {
+    Horizontal: "horizontal",
+    Vertical: "vertical",
+};
+export const LINK_TARGET = {
+    Self: '_self',
+    Blank: '_blank',
+    Parent: '_parent',
+    Top: '_top',
+};

package/dist/components/InputTextField/InputTextField.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export interface CustomInputFieldProps {
+    label?: string;
+    value?: string;
+    type?: string;
+    placeholder?: string;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    className?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    error?: string;
+    errorClassName?: string;
+    id?: string;
+}
+declare const CustomInputField: React.FC<CustomInputFieldProps>;
+export default CustomInputField;

package/dist/components/InputTextField/InputTextField.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { INPUT_TYPES } from '../Enum';
+const CustomInputField = ({ label, value = '', type = INPUT_TYPES.TEXT, placeholder = '', onChange, className = '', inputClassName = '', labelClassName = '', error = '', errorClassName = '', ...rest }) => {
+    return (React.createElement("div", { className: className },
+        label && React.createElement("label", { className: labelClassName }, label),
+        React.createElement("input", { type: type, value: value, placeholder: placeholder, onChange: onChange, className: inputClassName, ...rest }),
+        error && React.createElement("div", { className: errorClassName }, error)));
+};
+export default CustomInputField;

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

@@ -0,0 +1 @@
+export {};