zaravand-ui 1.0.2 → 1.0.3

package/dist/components/Table/Table.interface.d.ts

@@ -0,0 +1,142 @@
+import type * as React from "react";
+import type { SelectProps } from "../Select/Select.interface";
+export type TableFieldType = 'text' | 'number' | 'textarea' | 'select' | 'checkbox' | 'radio' | 'date';
+type TableFieldValueByType = {
+    text: string;
+    number: number;
+    textarea: string;
+    select: string;
+    checkbox: boolean;
+    radio: string;
+    date: Date | string;
+};
+export type TableFieldValue = TableFieldValueByType[TableFieldType];
+export type DynamicTableRow = Record<string, TableFieldValue | null | undefined>;
+export type TableRowId = string | number;
+export type TablePagingMode = 'pagination' | 'infinite';
+export type TablePaginationToken = number | 'ellipsis-start' | 'ellipsis-end';
+export type TableMutationHookResult = boolean | void | Promise<boolean | void>;
+export type TableRowActionInput = {
+    row: DynamicTableRow;
+    rowIndex: number;
+    rowId?: TableRowId;
+};
+export type TableAddRowHandler = () => void | Promise<void>;
+export type TableEditRowHandler = (input: TableRowActionInput) => void | Promise<void>;
+export type TableDeleteRowHandler = (input: TableRowActionInput) => void | Promise<void>;
+export type TableAction = {
+    icon: React.ReactNode;
+    onClick: (input: TableRowActionInput) => void | Promise<void>;
+    tooltip: string;
+};
+export type TableCellSelectChangeHandlerInput = {
+    row: DynamicTableRow;
+    previousRow: DynamicTableRow;
+    rowIndex: number;
+    rowId?: TableRowId;
+    columnKey: string;
+    value: string;
+};
+export type TableCellSelectChangeHandler = (input: TableCellSelectChangeHandlerInput) => TableMutationHookResult;
+export type TableColumnViewType = "text" | "select";
+type TableBaseSelectOptions = NonNullable<SelectProps["options"]>;
+export type TableSelectOption = TableBaseSelectOptions[number];
+export type TableSelectOptionsSource = NonNullable<SelectProps["remoteOptions"]>;
+export type TableSchemaColumn = {
+    key: string;
+    label: string;
+    placeholder?: string;
+    displayPlaceholder?: string;
+    /**
+     * When true for checkbox fields, value must be `true` on submit.
+     */
+    mustBeChecked?: boolean;
+    view: boolean;
+    viewType?: TableColumnViewType;
+    type: TableFieldType;
+    options?: TableSelectOption[];
+    optionsSource?: TableSelectOptionsSource;
+};
+export type TableSchemaPagination = {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    /**
+     * Used for remote paging. `mode` indicates whether page change happened in
+     * regular pagination or infinite mode.
+     */
+    onPageChange?: (page: number, mode?: TablePagingMode) => void;
+    onSearchChange?: (search: string) => void;
+    /**
+     * Optional load-more callback for remote infinite mode.
+     * When used, parent should append next page rows to current `data` instead
+     * of replacing them.
+     */
+    onLoadMore?: (nextPage: number) => void | Promise<void>;
+};
+export type TableSchema = {
+    columns: TableSchemaColumn[];
+    searchable?: boolean;
+    pagination?: TableSchemaPagination;
+};
+export type TableVisibleRow = {
+    row: DynamicTableRow;
+    rowIndex: number;
+    rowId?: TableRowId;
+};
+export type TableRowIdResolver = (row: DynamicTableRow, index: number) => TableRowId;
+export interface TableProps {
+    className?: string;
+    children?: React.ReactNode;
+    containerClassName?: string;
+    loading?: boolean;
+    isMutating?: boolean;
+    stickyHeaderOnScroll?: boolean;
+    maxVisibleRowsBeforeScroll?: number;
+    schema: TableSchema;
+    data: DynamicTableRow[];
+    setData: React.Dispatch<React.SetStateAction<DynamicTableRow[]>>;
+    onAdd?: TableAddRowHandler;
+    onEdit?: TableEditRowHandler;
+    onDelete?: TableDeleteRowHandler;
+    actions?: TableAction[];
+    onCellSelectChange?: TableCellSelectChangeHandler;
+    getRowId?: TableRowIdResolver;
+    showNumberRow?: boolean;
+}
+type TableSectionProps = {
+    className?: string;
+    children?: React.ReactNode;
+};
+export type TableHeaderProps = TableSectionProps;
+export type TableBodyProps = TableSectionProps;
+export type TableFooterProps = TableSectionProps;
+export type TableRowState = 'selected';
+export type TableRowProps = TableSectionProps & {
+    state?: TableRowState;
+    slot?: 'table-row' | 'table-loading-row';
+};
+type TableCellElementProps = {
+    className?: string;
+    children?: React.ReactNode;
+};
+export type TableHeadProps = TableCellElementProps;
+export type TableCellProps = TableCellElementProps;
+export type TablePaginationControlsProps = {
+    shouldRenderInfiniteMode: boolean;
+    shouldShowInfiniteLoadingStatus: boolean;
+    shouldShowInfiniteReadyStatus: boolean;
+    shouldShowInfiniteCompletedStatus: boolean;
+    shouldRenderPagination: boolean;
+    loading: boolean;
+    isRowActionBusy: boolean;
+    currentPage: number;
+    totalPages: number;
+    onPageChange: (nextPage: number) => void;
+};
+export type TableEmptyStateProps = {
+    colSpan: number;
+    showSearchInput: boolean;
+    normalizedSearchTerm: string;
+};
+export {};

package/dist/components/Table/Table.utils.d.ts

@@ -0,0 +1,11 @@
+import type { DynamicTableRow, TablePaginationToken, TableRowId, TableRowIdResolver, TableSchemaColumn } from './Table.interface';
+export declare function resolveLoadingRowsCount(pageSize: number | undefined, dataLength: number): number;
+export declare function resolveLoadingCellSkeletonClassName(column: TableSchemaColumn, rowIndex: number): string;
+export declare function buildPaginationTokens(currentPage: number, totalPages: number): TablePaginationToken[];
+export declare function isEmptyCellValue(value: unknown): boolean;
+export declare function resolveDateValue(value: unknown): Date | null;
+export declare function resolvePlaceholder(column: TableSchemaColumn): string;
+export declare function formatCellValue(value: unknown, column: TableSchemaColumn): string;
+export declare function resolveSafeRowId(row: DynamicTableRow, index: number, getRowId?: TableRowIdResolver): TableRowId | undefined;
+export declare function findRowIndexByIdentifier(rows: DynamicTableRow[], targetRowIndex: number, targetRowId: TableRowId | undefined, getRowId?: TableRowIdResolver): number;
+export declare function replaceRowByIdentifier(rows: DynamicTableRow[], targetRowIndex: number, targetRowId: TableRowId | undefined, getRowId: TableRowIdResolver | undefined, nextRow: DynamicTableRow): DynamicTableRow[];

package/dist/components/Table/Table.variant.d.ts

@@ -0,0 +1,11 @@
+export declare const tableContainerVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const tableVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const ticketContainerVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const ticketControlsVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const ticketTableShellVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const tableHeaderVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const tableBodyVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const tableFooterVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const tableRowVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const tableHeadVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export declare const tableCellVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;

package/dist/components/Table/TableEmptyState.d.ts

@@ -0,0 +1,2 @@
+import type { TableEmptyStateProps } from './Table.interface';
+export default function TableEmptyState({ colSpan, showSearchInput, normalizedSearchTerm, }: TableEmptyStateProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Table/TablePaginationControls.d.ts

@@ -0,0 +1,2 @@
+import type { TablePaginationControlsProps } from "./Table.interface";
+export default function TablePaginationControls({ shouldRenderInfiniteMode, shouldShowInfiniteLoadingStatus, shouldShowInfiniteReadyStatus, shouldShowInfiniteCompletedStatus, shouldRenderPagination, loading, isRowActionBusy, currentPage, totalPages, onPageChange, }: TablePaginationControlsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Table/hooks/useTablePagination.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import type { TablePagingMode, TableSchemaPagination, TableVisibleRow } from '../Table.interface';
+type UseTablePaginationInput = {
+    hasChildren: boolean;
+    filteredRows: TableVisibleRow[];
+    paginationConfig?: TableSchemaPagination;
+    loading: boolean;
+    isRowActionBusy: boolean;
+    searchKey: string;
+    maxVisibleRowsBeforeScroll?: number;
+};
+type UseTablePaginationResult = {
+    pagingMode: TablePagingMode;
+    currentPage: number;
+    totalPages: number;
+    resolvedPageSize: number;
+    visibleRows: TableVisibleRow[];
+    paginationTokens: Array<number | 'ellipsis-start' | 'ellipsis-end'>;
+    canGoToPreviousPage: boolean;
+    canGoToNextPage: boolean;
+    canUsePaging: boolean;
+    showPagingModeToggle: boolean;
+    shouldRenderPagination: boolean;
+    shouldRenderInfiniteMode: boolean;
+    canLoadMoreInInfiniteMode: boolean;
+    shouldUseRemotePaging: boolean;
+    shouldUseScrollableRows: boolean;
+    tableScrollViewportRef: React.RefObject<HTMLDivElement | null>;
+    infiniteScrollSentinelRef: React.RefObject<HTMLDivElement | null>;
+    tableScrollViewportStyle: React.CSSProperties | undefined;
+    handlePageChange: (nextPage: number) => void;
+    handlePagingModeToggle: () => void;
+    handleTableScrollViewport: (event: React.UIEvent<HTMLDivElement>) => void;
+    isInfiniteRequestPending: boolean;
+};
+export declare function useTablePagination({ hasChildren, filteredRows, paginationConfig, loading, isRowActionBusy, searchKey, maxVisibleRowsBeforeScroll, }: UseTablePaginationInput): UseTablePaginationResult;
+export {};

package/dist/components/Table/hooks/useTableSearch.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { DynamicTableRow, TableRowIdResolver, TableSchemaColumn, TableVisibleRow } from '../Table.interface';
+type UseTableSearchInput = {
+    data: DynamicTableRow[];
+    visibleColumns: TableSchemaColumn[];
+    showSearchInput: boolean;
+    hasRemoteSearchHandler: boolean;
+    onSearchChange?: (search: string) => void;
+    getRowId?: TableRowIdResolver;
+};
+type UseTableSearchResult = {
+    searchTerm: string;
+    normalizedSearchTerm: string;
+    filteredRows: TableVisibleRow[];
+    handleSearchInputChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+};
+export declare function useTableSearch({ data, visibleColumns, showSearchInput, hasRemoteSearchHandler, onSearchChange, getRowId, }: UseTableSearchInput): UseTableSearchResult;
+export {};

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

@@ -0,0 +1,3 @@
+import type { TextareaProps } from "./Textarea.interface";
+declare function Textarea({ className, resize, title, required, placeholder, onChange, onBlur, onFocus, onInvalid, id, name, disabled, readOnly, autoComplete, rows, maxLength, "aria-label": ariaLabel, value, defaultValue, }: TextareaProps): import("react/jsx-runtime").JSX.Element;
+export default Textarea;

package/dist/components/Textarea/Textarea.interface.d.ts

@@ -0,0 +1,23 @@
+import type * as React from "react";
+import type { VariantProps } from "class-variance-authority";
+import { textareaVariants } from "./Textarea.variant";
+export interface TextareaProps extends VariantProps<typeof textareaVariants> {
+    title?: string;
+    required?: boolean;
+    placeholder?: string;
+    id?: string;
+    name?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    autoComplete?: string;
+    rows?: number;
+    maxLength?: number;
+    className?: string;
+    value?: string | number | readonly string[];
+    defaultValue?: string | number | readonly string[];
+    "aria-label"?: string;
+    onChange?: React.ChangeEventHandler<HTMLTextAreaElement>;
+    onBlur?: React.FocusEventHandler<HTMLTextAreaElement>;
+    onFocus?: React.FocusEventHandler<HTMLTextAreaElement>;
+    onInvalid?: React.FormEventHandler<HTMLTextAreaElement>;
+}

package/dist/components/Textarea/Textarea.variant.d.ts

@@ -0,0 +1,4 @@
+declare const textareaVariants: (props?: ({
+    resize?: "none" | "y" | "both" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export { textareaVariants };

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as ToastPrimitive from "@radix-ui/react-toast";
+import type { ToastProps } from "./Toast.interface";
+type ToastProviderProps = React.ComponentProps<typeof ToastPrimitive.Provider>;
+declare function ToastProvider(props: ToastProviderProps): import("react/jsx-runtime").JSX.Element;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare function Toast({ className, variant, ...props }: ToastProps): import("react/jsx-runtime").JSX.Element;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitive.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ToastAction, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport, };
+export default Toast;

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

@@ -0,0 +1,6 @@
+import type * as React from "react";
+import type { VariantProps } from "class-variance-authority";
+import type * as ToastPrimitive from "@radix-ui/react-toast";
+import { toastVariants } from "./Toast.variant";
+export interface ToastProps extends React.ComponentProps<typeof ToastPrimitive.Root>, VariantProps<typeof toastVariants> {
+}

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

@@ -0,0 +1,9 @@
+declare const toastViewportVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const toastVariants: (props?: ({
+    variant?: "success" | "warning" | "default" | "error" | "info" | "destructive" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const toastActionVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const toastCloseVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const toastTitleVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const toastDescriptionVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export { toastActionVariants, toastCloseVariants, toastDescriptionVariants, toastTitleVariants, toastVariants, toastViewportVariants, };

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

@@ -0,0 +1,2 @@
+declare function ToastHost(): import("react/jsx-runtime").JSX.Element;
+export default ToastHost;

package/dist/components/Toast/function/showToast.d.ts

@@ -0,0 +1,17 @@
+export type ToastType = "info" | "warning" | "error" | "success" | "succes";
+export type ShowToastInput = {
+    title: string;
+    message: string;
+    duration?: number | null;
+    type: ToastType;
+};
+export type ToastPayload = Omit<ShowToastInput, "type" | "duration"> & {
+    duration: number;
+    isPersistent: boolean;
+    type: Exclude<ToastType, "succes">;
+};
+type ToastListener = (payload: ToastPayload) => void;
+export declare const PERSISTENT_DURATION = 2147483647;
+export declare function subscribeToast(listener: ToastListener): () => void;
+export declare function showToast({ title, message, duration, type }: ShowToastInput): void;
+export {};

package/dist/components/Toast/function/toastVisual.d.ts

@@ -0,0 +1,10 @@
+import type { LucideIcon } from "lucide-react";
+import type { ToastPayload } from "./showToast";
+type ToastVariant = ToastPayload["type"];
+type ToastVisualConfig = {
+    Icon: LucideIcon;
+    iconClassName: string;
+    progressClassName: string;
+};
+export declare function getToastVisual(type: ToastVariant): ToastVisualConfig;
+export {};

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

@@ -0,0 +1,3 @@
+import type { TooltipProps } from "./Tooltip.interface";
+declare function Tooltip({ text, trigger, position, className, disabled, sideOffset, delayDuration, skipDelayDuration, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+export default Tooltip;

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

@@ -0,0 +1,13 @@
+import type * as React from "react";
+import type * as TooltipPrimitive from "@radix-ui/react-tooltip";
+export interface TooltipProps extends Omit<React.ComponentProps<typeof TooltipPrimitive.Root>, "children"> {
+    text: React.ReactNode;
+    trigger: React.ReactNode;
+    position?: "top" | "right" | "bottom" | "left";
+    className?: string;
+    disabled?: boolean;
+    sideOffset?: number;
+    delayDuration?: number;
+    skipDelayDuration?: number;
+    children?: never;
+}

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

@@ -0,0 +1,2 @@
+declare const tooltipContentVariants: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+export { tooltipContentVariants };

package/dist/components/shared/fieldStyles.d.ts

@@ -0,0 +1,3 @@
+declare const fieldInteractionClassName: string;
+declare const fieldExpandedInteractionClassName: string;
+export { fieldExpandedInteractionClassName, fieldInteractionClassName };