@pk-design/react-tailwind 1.0.2

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

@@ -0,0 +1,13 @@
+import React, { type InputHTMLAttributes } from 'react';
+import { type InputCustomProps } from '../common-type';
+export interface CheckboxProps extends InputHTMLAttributes<HTMLInputElement>, Omit<InputCustomProps, 'labelHint'> {
+    /**
+     * Type is constant 'checkbox'
+     */
+    type?: 'checkbox';
+    /**
+     * Input wrapper class
+     */
+    wrapperClass?: string;
+}
+export declare const Checkbox: React.FC<CheckboxProps>;

package/dist/types/components/CheckboxGroup/index.d.ts

@@ -0,0 +1,56 @@
+import React, { type ChangeEvent, type ReactNode } from 'react';
+export type CheckboxGroupItem = {
+    /**
+     * Checkbox item label
+     */
+    label: string;
+    /**
+     * Checkbox item value
+     */
+    value: any;
+};
+export interface CheckboxGroupProps {
+    /**
+     * Group name
+     */
+    name?: string;
+    /**
+     * Selected value
+     */
+    value?: any;
+    /**
+     * Label of checkbox group field
+     */
+    label?: ReactNode;
+    /**
+     * Label class for checkbox group field
+     */
+    labelClass?: string;
+    /**
+     * Label wrapper class for checkbox group field
+     */
+    labelWrapperClass?: string;
+    /**
+     * Group field hint
+     */
+    labelHint?: ReactNode;
+    /**
+     * Group field container
+     */
+    containerClass?: string;
+    /**
+     * On change handler
+     * @param e ChangeEvent<HTMLInputElement>
+     * @returns void
+     */
+    onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * List of checkbox field option
+     */
+    options: string[] | CheckboxGroupItem[];
+    /**
+     * Defines whether to list the checkbox inline
+     */
+    inline?: boolean;
+}
+export declare const CheckboxGroup: React.FC<CheckboxGroupProps>;

package/dist/types/components/DetailedInformation/index.d.ts

@@ -0,0 +1,63 @@
+import React, { type ReactNode, type JSX, type JSXElementConstructor } from 'react';
+export type Detail = {
+    /**
+     * Label of the information to be displayed
+     */
+    label: string;
+    /**
+     * Information to be displayed
+     */
+    value?: ReactNode;
+    /**
+     * Classname of the value content sections
+     */
+    contentClass?: string;
+    /**
+     * Defines if the items should be hidden.
+     */
+    hidden?: boolean;
+};
+export interface DetailedInformationProps {
+    className?: string;
+    /**
+     * Title for the information section
+     */
+    title?: ReactNode;
+    /**
+     * Subtitle for the information section
+     */
+    subTitle?: ReactNode;
+    /**
+     * List of details / information to be displayed
+     */
+    details: Detail[];
+    /**
+     * Defines if the layout should be compact
+     */
+    compact?: boolean;
+    /**
+     * Defines if the section should have borders
+     */
+    bordered?: boolean;
+    /**
+     * Defines if each item in section should have divider
+     */
+    divider?: boolean;
+    /**
+     * Classname for title element
+     */
+    titleClass?: string;
+    /**
+     * Classname for details section
+     */
+    detailsClass?: string;
+    /**
+     * JSX element to be rendered as.
+     */
+    as?: keyof JSX.IntrinsicElements | JSXElementConstructor<any>;
+    /**
+     * When rendering as Link, use `to` prop for navigation
+     */
+    to?: string;
+}
+export declare const DetailedInformation: React.FC<DetailedInformationProps>;

package/dist/types/components/Dot/index.d.ts

@@ -0,0 +1,4 @@
+import React, { type HTMLAttributes, type JSX, type JSXElementConstructor } from 'react';
+export declare const Dot: React.FC<HTMLAttributes<HTMLElement> & {
+    as?: keyof JSX.IntrinsicElements | JSXElementConstructor<any>;
+}>;

package/dist/types/components/Drawer/Drawer.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { type DrawerProps } from './type';
+export declare const Drawer: React.FC<DrawerProps>;

package/dist/types/components/Drawer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Drawer';
+export * from './type';

package/dist/types/components/Drawer/type.d.ts

@@ -0,0 +1,71 @@
+import { type ReactNode } from 'react';
+export type DrawerAlignment = 'center' | 'start' | 'end' | 'top' | 'bottom' | 'top-center';
+export type DrawerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+export interface DrawerProps {
+    /**
+     * Controls if Drawer is open
+     */
+    isOpen: boolean;
+    /**
+     * Handler method that invokes on close attempt
+     * @returns void
+     */
+    onClose?: () => void;
+    /**
+     * Drawer alignment on the page
+     * @default "end"
+     */
+    align?: DrawerAlignment;
+    /**
+     * Whether to add backdrop, when drawer is open
+     * @default "true"
+     */
+    backdrop?: boolean;
+    /**
+     * Drawer title
+     */
+    title: ReactNode;
+    /**
+     * Controls if the title should be sticky on top
+     */
+    titleSticky?: boolean;
+    /**
+     * Drawer description section
+     */
+    description?: ReactNode;
+    /**
+     * Content of the drawer
+     */
+    children?: ReactNode;
+    /**
+     * Drawer size
+     * @default "md"
+     */
+    size?: DrawerSize;
+    /**
+     * Dialog Panel class
+     */
+    panelClass?: string;
+    /**
+     * Drawer content class
+     */
+    contentClass?: string;
+    /**
+     * Drawer title class
+     */
+    titleClass?: string;
+    /**
+     * Drawer description class
+     */
+    descriptionClass?: string;
+    /**
+     * Should show back button on Drawer
+     */
+    showBackButton?: boolean;
+}
+export type AlignmentMap = {
+    [key in DrawerAlignment]: string;
+};
+export type SizeMap = {
+    [key in DrawerSize]: string;
+};

package/dist/types/components/Dropdown/index.d.ts

@@ -0,0 +1,62 @@
+import React, { type ReactNode } from 'react';
+type Align = 'start' | 'end';
+type Placement = 'top' | 'right' | 'bottom' | 'left';
+type AnchorTo = `${Placement}` | `${Placement} ${Align}`;
+type BaseAnchorProps = {
+    /**
+     * The `gap` is the space between the trigger and the panel.
+     */
+    gap: number | string;
+    /**
+     * The `offset` is the amount the panel should be nudged from its original position.
+     */
+    offset: number | string;
+    /**
+     * The `padding` is the minimum space between the panel and the viewport.
+     */
+    padding: number | string;
+};
+export type DropdownItem = Record<string, any> & {
+    id: string;
+    divider?: boolean;
+};
+export type DropdownProps = {
+    /**
+     * Dropdown menu trigger button
+     */
+    triggerButton: ReactNode;
+    /**
+     * Dropdown menu item container class
+     */
+    itemsContainerClass?: string;
+    /**
+     * Controls animation of dropdown menu
+     * @default true
+     */
+    transition?: boolean;
+    /**
+     * Controls placement of the dropdown menu
+     * @default "bottom start"
+     */
+    anchor?: false | AnchorTo | Partial<BaseAnchorProps & {
+        /**
+         * The `to` value defines which side of the trigger the panel should be placed on and its
+         * alignment.
+         */
+        to: AnchorTo;
+    }>;
+    /**
+     * List of dropdown menu items
+     */
+    items: DropdownItem[];
+    /**
+     * Renderer function that returns react element to render dropdown item
+     * @param item DropdownItem
+     * @returns ReactNode
+     */
+    renderItem: (item: DropdownItem, options: {
+        className: string;
+    }) => ReactNode;
+};
+export declare const Dropdown: React.FC<DropdownProps>;
+export {};

package/dist/types/components/EmptyState/index.d.ts

@@ -0,0 +1,8 @@
+import React, { type ReactNode } from 'react';
+export interface EmptyStateProps {
+    title: string;
+    description?: string;
+    action?: ReactNode;
+    className?: string;
+}
+export declare const EmptyState: React.FC<EmptyStateProps>;

package/dist/types/components/HeadingText/index.d.ts

@@ -0,0 +1,12 @@
+import React, { type ReactNode } from 'react';
+export interface HeadingTextProps {
+    children: ReactNode;
+    className?: string;
+}
+export declare const HeadingText: {
+    Title: React.FC<HeadingTextProps>;
+    SubTitle: React.FC<HeadingTextProps>;
+    SubTitle2: React.FC<HeadingTextProps>;
+    SubTitle3: React.FC<HeadingTextProps>;
+    SubTitle4: React.FC<HeadingTextProps>;
+};

package/dist/types/components/Input/index.d.ts

@@ -0,0 +1,13 @@
+import React, { type InputHTMLAttributes, type ReactNode } from 'react';
+import { type InputCustomProps } from '../common-type';
+export interface InputProps extends InputHTMLAttributes<HTMLInputElement>, InputCustomProps {
+    /**
+     * Space for right icon
+     */
+    rightGroup?: ReactNode;
+    /**
+     * Space for left icon
+     */
+    leftGroup?: ReactNode;
+}
+export declare const Input: React.FC<InputProps>;

package/dist/types/components/Label/index.d.ts

@@ -0,0 +1,5 @@
+import React, { type LabelHTMLAttributes } from 'react';
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+}
+export declare const Label: React.FC<LabelProps>;
+export {};

package/dist/types/components/Loader/index.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import './loader.css';
+export type LoaderSize = 'xs' | 'sm' | 'md' | 'lg';
+interface LoaderProps {
+    size?: LoaderSize;
+    className?: string;
+}
+export declare const Loader: React.FC<LoaderProps>;
+export {};

package/dist/types/components/Pagination/Pagination.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+export interface TPagination {
+    /**
+     * Defines current page number
+     */
+    page: number;
+    /**
+     * Defines page limit
+     */
+    limit: number;
+    /**
+     * Defines totol items in the list to be paginated.
+     */
+    total: number;
+}
+export type PaginationProps = TPagination & {
+    /**
+     * Pagination component classname
+     */
+    className?: string;
+    /**
+     * Handler for page change
+     * @param pagination Partial<TPagination>
+     * @returns void
+     */
+    onChange: (pagination: Partial<TPagination>) => void;
+    /**
+     * Whether to show ellipsis for large page numbers
+     * @default true
+     */
+    ellipsis?: boolean;
+};
+export declare const Pagination: React.FC<PaginationProps>;

package/dist/types/components/Pagination/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Pagination';
+export * from './usePagination';

package/dist/types/components/Pagination/usePagination.d.ts

@@ -0,0 +1,7 @@
+export declare const DOTS = "...";
+export type UsePaginationProps = {
+    totalPages: number;
+    currentPage: number;
+    siblingCount?: number;
+};
+export declare const usePagination: ({ totalPages, currentPage, siblingCount, }: UsePaginationProps) => (number | string)[];

package/dist/types/components/PasswordInput/index.d.ts

@@ -0,0 +1,6 @@
+import { type InputProps } from '../Input';
+export interface PasswordInputProps extends Omit<InputProps, 'rightGroup'> {
+}
+export declare const PASSWORD_TYPE = "password";
+export declare const PASSWORD_PLACEHOLDER = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+export declare const PasswordInput: React.FC<PasswordInputProps>;

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

@@ -0,0 +1,7 @@
+import React, { type InputHTMLAttributes } from 'react';
+import { type InputCustomProps } from '../common-type';
+export interface RadioButtonProps extends InputHTMLAttributes<HTMLInputElement>, InputCustomProps {
+    type?: 'radio';
+    wrapperClass?: string;
+}
+export declare const RadioButton: React.FC<RadioButtonProps>;

package/dist/types/components/RadioButtonGroup/index.d.ts

@@ -0,0 +1,19 @@
+import React, { type ChangeEvent, type ReactNode } from 'react';
+type RadionButtonGroupItem = {
+    label: string;
+    value: any;
+};
+export interface RadioButtonGroupProps {
+    name: string;
+    label?: ReactNode;
+    labelClass?: string;
+    labelWrapperClass?: string;
+    labelHint?: ReactNode;
+    containerClass?: string;
+    value?: any;
+    options: string[] | RadionButtonGroupItem[];
+    row?: boolean;
+    onChange?: (e: ChangeEvent<HTMLInputElement>) => void;
+}
+export declare const RadioButtonGroup: React.FC<RadioButtonGroupProps>;
+export {};

package/dist/types/components/RadioSwtich/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { type RadioGroupProps } from '@headlessui/react';
+export type RadioSwitchItem = string | {
+    label: string;
+    value: string;
+    description?: string;
+};
+export type RadioSwitchProps = RadioGroupProps & {
+    label?: string;
+    selected: string;
+    onChange: (value: string) => void;
+    items: RadioSwitchItem[];
+};
+export declare const RadioSwitch: React.FC<RadioSwitchProps>;

package/dist/types/components/RangeInput/index.d.ts

@@ -0,0 +1,10 @@
+import React, { type InputHTMLAttributes } from 'react';
+import { type InputCustomProps } from '../common-type';
+export type RangeValue = {
+    min: any;
+    max: any;
+};
+export interface RangeInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value'>, InputCustomProps {
+    value?: RangeValue;
+}
+export declare const RangeInput: React.FC<RangeInputProps>;

package/dist/types/components/SelectBox/index.d.ts

@@ -0,0 +1,40 @@
+import React, { type ReactNode } from 'react';
+export type SelectOption = {
+    value: string;
+    label?: string;
+    disabled?: boolean;
+    [key: string]: any;
+};
+type Selected = SelectOption | string;
+interface SelectBoxProps {
+    options: SelectOption[] | string[];
+    selected?: Selected | Selected[] | null;
+    labelKey?: string;
+    valueKey?: string;
+    id?: string;
+    name?: string;
+    label?: string;
+    labelWrapperClass?: string;
+    labelClass?: string;
+    labelHint?: string;
+    onChange?: (value: any) => void;
+    disabled?: boolean;
+    containerClass?: string;
+    placeholder?: string;
+    dropdownContainerClass?: string;
+    multiple?: boolean;
+    maxSelection?: number;
+    immediate?: boolean;
+    showErrorMessage?: boolean;
+    error?: string | ReactNode;
+    async?: boolean;
+    onSearch?: (query: string) => Promise<void>;
+    searchable?: boolean;
+    required?: boolean;
+    allowAdd?: boolean;
+    addNewText?: string;
+    onAdd?: (value: string) => void;
+    allowClear?: boolean;
+}
+export declare const SelectBox: React.FC<SelectBoxProps>;
+export {};

package/dist/types/components/Table/index.d.ts

@@ -0,0 +1,48 @@
+import React, { type HTMLAttributes, type MouseEventHandler, type ReactNode, type TdHTMLAttributes, type ThHTMLAttributes } from 'react';
+interface TableProps {
+    layout?: 'fixed' | 'auto';
+    wrapperClass?: string;
+    className?: string;
+    children: ReactNode;
+}
+interface TableHeadProps {
+    className?: string;
+    children: ReactNode;
+    onSort?: MouseEventHandler<HTMLElement>;
+}
+interface TableBodyProps {
+    className?: string;
+    loading?: boolean;
+    children: ReactNode;
+    colSize: number;
+    rowSize?: number;
+}
+interface TableFootProps {
+    children: ReactNode;
+}
+interface EmptyTableRow {
+    colSpan?: number;
+    children: ReactNode;
+}
+interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    className?: string;
+    children: ReactNode;
+    align?: 'left' | 'center' | 'right';
+}
+interface TableRowProps extends ThHTMLAttributes<HTMLTableRowElement> {
+    hoverable?: boolean;
+}
+interface TableHeaderCellProps extends HTMLAttributes<HTMLTableCellElement> {
+    className?: string;
+    children: ReactNode;
+    align?: 'left' | 'center' | 'right';
+}
+export declare const Table: React.FC<TableProps>;
+export declare const TabelHead: React.FC<TableHeadProps>;
+export declare const TabelBody: React.FC<TableBodyProps>;
+export declare const TabelFoot: React.FC<TableFootProps>;
+export declare const TableRow: React.FC<TableRowProps>;
+export declare const TableCell: React.FC<TableCellProps>;
+export declare const TableHeaderCell: React.FC<TableHeaderCellProps>;
+export declare const EmptyTableRow: React.FC<EmptyTableRow>;
+export {};

package/dist/types/components/Tabs/index.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const Tabs: React.FC;

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

@@ -0,0 +1,12 @@
+import React, { type HTMLAttributes, type JSX, type JSXElementConstructor } from 'react';
+export type TagVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'error';
+export interface TagProps extends HTMLAttributes<HTMLElement> {
+    as?: keyof JSX.IntrinsicElements | JSXElementConstructor<any>;
+    text: string;
+    onClose?: () => void;
+    variant?: TagVariant;
+}
+export type VariantMap = {
+    [k in TagVariant]: string;
+};
+export declare const Tag: React.FC<TagProps>;

package/dist/types/components/TextContent/index.d.ts

@@ -0,0 +1,10 @@
+import React, { type HTMLAttributes, type JSX, type JSXElementConstructor } from 'react';
+export interface TextContentProps extends HTMLAttributes<HTMLSpanElement> {
+    xsmall?: boolean;
+    small?: boolean;
+    strong?: boolean;
+    muted?: boolean;
+    error?: boolean;
+    as?: keyof JSX.IntrinsicElements | JSXElementConstructor<any>;
+}
+export declare const TextContent: React.FC<TextContentProps>;

package/dist/types/components/Textarea/index.d.ts

@@ -0,0 +1,7 @@
+import React, { type TextareaHTMLAttributes, type ReactNode } from 'react';
+import { type InputCustomProps } from '../common-type';
+export interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement>, InputCustomProps {
+    rightGroup?: ReactNode | null;
+    leftGroup?: ReactNode | null;
+}
+export declare const Textarea: React.FC<TextareaProps>;

package/dist/types/components/Toast/Toast.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface ToastProps {
+    id?: number;
+    message: string;
+    type: 'success' | 'error' | 'info' | 'warning';
+    onClose: () => void;
+}
+declare const Toast: React.FC<ToastProps>;
+export default Toast;

package/dist/types/components/Toast/ToastProvider.d.ts

@@ -0,0 +1,16 @@
+import React, { type ReactNode } from 'react';
+type ToastType = 'success' | 'error' | 'info' | 'warning';
+interface ToastOptions {
+    type?: ToastType;
+    duration?: number;
+    autoClose?: boolean;
+}
+interface ToastContextType {
+    showToast: (message: string, options?: ToastOptions) => void;
+    closeToast: (id: number) => void;
+}
+export declare const useToast: () => ToastContextType;
+export declare const ToastProvider: React.FC<{
+    children: ReactNode;
+}>;
+export {};

package/dist/types/components/Toast/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ToastProvider';
+export * from './Toast';

package/dist/types/components/common-type.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+export interface InputCustomProps {
+    /**
+     * Input field label
+     */
+    label?: string | ReactNode;
+    /**
+     * Any label hint for the input field
+     */
+    labelHint?: string | ReactNode;
+    /**
+     * Label classes
+     */
+    labelClass?: string;
+    /**
+     * Input field container class
+     */
+    containerClass?: string;
+    /**
+     * Input label wrapper class
+     */
+    labelWrapperClass?: string;
+    /**
+     * Input field error
+     */
+    error?: string | ReactNode;
+    /**
+     * Controls weather to show error message or not.
+     */
+    showErrorMessage?: boolean;
+}

package/dist/types/components/hooks/use-debounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: <T>(value: T, delay: number) => T;