@quan-erp/shared-ui 1.0.0

package/README.md

@@ -0,0 +1,90 @@
+# Quan ERP Shared UI Library
+
+The visual core and design system for the Quan ERP ecosystem. Built on top of **React**, **Tailwind CSS**, and **Radix UI**, this library provides a suite of 60+ atomic and complex components designed for high-performance, accessible, and consistent enterprise applications.
+
+---
+
+## 🎨 Design Foundation
+
+The library follows a modern, clean, and highly customizable design language.
+
+### Tailwind Integration
+The system relies on a central `index.css` that defines CSS variables for theming:
+-   **Brand Colors**: Primary, secondary, and accent palettes.
+-   **Semantic Tokens**: Success, Warning, Destructive, and Info states.
+-   **Dark Mode**: Native support for dark themes using Tailwind's `dark:` variant and CSS variable swapping.
+
+### Typography & Spacing
+A rigorous scale for typography and spacing ensures a premium look and feel across all modular plugins.
+
+---
+
+## 🏗️ Component Catalog
+
+### 1. Atomic UI (The Building Blocks)
+A comprehensive set of low-level components based on **Shadcn UI**:
+-   **Inputs**: `Input`, `Select`, `Checkbox`, `RadioGroup`, `Switch`, `Slider`.
+-   **Actions**: `Button`, `DropdownMenu`, `ContextMenu`, `Toggle`.
+-   **Display**: `Badge`, `Avatar`, `Separator`, `Skeleton`, `Kbd`.
+-   **Data Storage**: `Table`, `Card`, `Accordion`, `Tabs`.
+
+### 2. Advanced UI (Complex Systems)
+-   **Charts**: Pre-configured **Recharts** wrappers for analytical dashboards.
+-   **Rich Text Editor**: A block-based editor (`editor-00`) with support for custom nodes and plugins.
+-   **Data Pickers**: `Calendar`, `TimePicker`, `InputOTP`.
+-   **Navigation**: `NavigationMenu`, `Breadcrumb`, `Pagination`.
+
+---
+
+## 🛣️ Layout & ERP Patterns
+
+Standardized layouts ensure a consistent user experience regardless of which plugin provides the page content.
+
+### `Page` System
+All workspace views should be wrapped in the `Page` component:
+```tsx
+import { Page, PageTitle, PageContent } from '@quan-erp/shared-ui';
+
+export const MyPluginPage = () => (
+    <Page>
+        <PageTitle title="User Management" />
+        <PageContent>
+            {/* Your content here */}
+        </PageContent>
+    </Page>
+);
+```
+
+### Dashboard & Sidebar
+-   **`Dashboard`**: A flexible grid layout for creating responsive, widget-based summaries.
+-   **`Sidebar`**: The primary navigation hub for the ERP shell.
+
+---
+
+## 💬 Interactions & Feedback
+
+Standardized mechanisms for user communication and confirmation.
+
+-   **`ConfirmDialog`**: A promise-based wrapper for simple OK/Cancel flows.
+-   **`ResponsiveDialog`**: A dialog that automatically transforms into a drawer on mobile devices.
+-   **`Sonner`**: High-performance toast notifications for non-blocking feedback.
+
+---
+
+## 🛡️ Protective Components
+
+### `ProtectedPage`
+A specialized wrapper that handles Role-Based Access Control (RBAC) and authentication checks. It ensures that the wrapped content is only rendered if the user meets the required permissions defined in the core.
+
+---
+
+## 📜 Development Guidelines
+
+1.  **Use Variants**: Leverage the `cva` (Class Variance Authority) patterns in components like `Button` and `Badge` to maintain style consistency.
+- **Accessibility**: All components are built with Radix UI primitives, ensuring ARIA compliance by default.
+3.  **Responsiveness**: Use the built-in `ResponsiveDialog` and `Safearea` components to ensure cross-device compatibility (especially for mobile/Capacitor).
+
+---
+
+> [!TIP]
+> Refer to the `index.css` to see the full list of available utility classes and theme tokens.

package/dist/common/common.d.ts

@@ -0,0 +1,2 @@
+export declare const BUILTIN_PLUGIN_NAME = "builtin";
+//# sourceMappingURL=common.d.ts.map

package/dist/components/blocks/editor-00/editor.d.ts

@@ -0,0 +1,8 @@
+import { EditorState, SerializedEditorState } from 'lexical';
+export declare function Editor({ editorState, editorSerializedState, onChange, onSerializedChange, }: {
+    editorState?: EditorState;
+    editorSerializedState?: SerializedEditorState;
+    onChange?: (editorState: EditorState) => void;
+    onSerializedChange?: (editorSerializedState: SerializedEditorState) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=editor.d.ts.map

package/dist/components/blocks/editor-00/nodes.d.ts

@@ -0,0 +1,3 @@
+import { Klass, LexicalNode, LexicalNodeReplacement } from 'lexical';
+export declare const nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;
+//# sourceMappingURL=nodes.d.ts.map

package/dist/components/blocks/editor-00/plugins.d.ts

@@ -0,0 +1,2 @@
+export declare function Plugins(): import("react").JSX.Element;
+//# sourceMappingURL=plugins.d.ts.map

package/dist/components/custom/confirm-dialog.d.ts

@@ -0,0 +1,15 @@
+type ConfirmOptions = {
+    title?: string;
+    description?: string;
+    confirmText?: string;
+    cancelText?: string;
+    variant?: "default" | "destructive";
+};
+export declare function ConfirmDialog({ options, open, onClose, onConfirm }: {
+    options: ConfirmOptions;
+    open: boolean;
+    onConfirm: () => void;
+    onClose: (value: boolean) => void;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=confirm-dialog.d.ts.map

package/dist/components/custom/dashboard.d.ts

@@ -0,0 +1,22 @@
+import { ApiPermission } from '@quan-erp/shared-types';
+import { ReactNode } from 'react';
+export type DashboardItemProps = {
+    id?: string;
+    colSpan?: number;
+    rowSpan?: number;
+    children: ReactNode;
+    rootMargin?: string;
+    threshold?: number;
+    once?: boolean;
+    className?: string;
+    wapperClassName?: string;
+    innerWapperClassName?: string;
+    pluginName?: string;
+    icon?: ReactNode;
+    label?: ReactNode;
+    titleClassName?: string;
+    notAllowedView?: ReactNode;
+    requiredApis?: ApiPermission[];
+};
+export declare function DashboardItem({ id, colSpan, rowSpan, children, rootMargin, threshold, once, className, wapperClassName, pluginName, titleClassName, icon, label, requiredApis }: DashboardItemProps): import("react").JSX.Element;
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/components/custom/data-table/cursor-based-pagination.d.ts

@@ -0,0 +1,9 @@
+import { PaginationViaIndex } from './types';
+interface CursorPaginationProps {
+    pagination: PaginationViaIndex;
+    onPageChange: (cursor: string | number | null, isBefore: boolean) => void;
+    className?: string;
+}
+export declare function CursorBasedPagination({ pagination, onPageChange, className, }: CursorPaginationProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=cursor-based-pagination.d.ts.map

package/dist/components/custom/data-table/data-table-bulk-action-menu.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface BulkActionMenuProps {
+    selectedCount: number;
+    onClear: () => void;
+    bulkActionMenu?: React.ReactNode;
+}
+export declare function DataTableBulkActionMenu({ selectedCount, bulkActionMenu, onClear, }: BulkActionMenuProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=data-table-bulk-action-menu.d.ts.map

package/dist/components/custom/data-table/data-table-bulk-export.d.ts

@@ -0,0 +1,8 @@
+type DataTableBulkExportButtonProps = {
+    selectedData: unknown[];
+    tableName: string;
+    label: string;
+};
+export declare function DataTableBulkExportButton({ selectedData, tableName, label, }: DataTableBulkExportButtonProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=data-table-bulk-export.d.ts.map

package/dist/components/custom/data-table/data-table-column-header.d.ts

@@ -0,0 +1,9 @@
+import { Column } from '@tanstack/react-table';
+import { default as React } from 'react';
+interface DataTableColumnHeaderProps<TData, TValue> extends React.HTMLAttributes<HTMLDivElement> {
+    column: Column<TData, TValue>;
+    title: string;
+}
+export declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): React.JSX.Element;
+export {};
+//# sourceMappingURL=data-table-column-header.d.ts.map

package/dist/components/custom/data-table/data-table-grid.d.ts

@@ -0,0 +1,21 @@
+import { Row, RowSelectionState, Table as TanstackTable } from '@tanstack/react-table';
+import { DataTableGroupByConfig } from './data-table-group-by.types';
+import * as React from "react";
+export type DataTableFooterItem = {
+    colIndex?: number;
+    valueColumnKey: string;
+    render: React.ReactNode;
+};
+export declare function DataTableGrid({ table, rows, rowSelection, columnCount, onRowClickFn, footerData, noResultsLabel, groupBy, layoutKey, firstRowData, }: {
+    table: TanstackTable<unknown>;
+    rows: Row<unknown>[];
+    rowSelection: RowSelectionState;
+    columnCount: number;
+    onRowClickFn?: (row: unknown) => void;
+    footerData?: DataTableFooterItem[];
+    firstRowData?: DataTableFooterItem[];
+    noResultsLabel?: string;
+    groupBy?: DataTableGroupByConfig<unknown>;
+    layoutKey: string;
+}): React.JSX.Element;
+//# sourceMappingURL=data-table-grid.d.ts.map

package/dist/components/custom/data-table/data-table-group-by.types.d.ts

@@ -0,0 +1,11 @@
+import { Row } from '@tanstack/react-table';
+import type * as React from "react";
+export type DataTableGroupByConfig<TData> = {
+    /** Stable key used to bucket rows (e.g. ISO date string). */
+    getGroupKey: (row: TData) => string;
+    /** Optional label for the group header. Defaults to the group key. */
+    formatGroupLabel?: (groupKey: string, rows: Row<TData>[]) => React.ReactNode;
+    /** Optional summary shown beside the group label (e.g. count + total). */
+    renderGroupSummary?: (groupKey: string, rows: Row<TData>[]) => React.ReactNode;
+};
+//# sourceMappingURL=data-table-group-by.types.d.ts.map

package/dist/components/custom/data-table/data-table-helper.d.ts

@@ -0,0 +1,2 @@
+export declare function formatCamelCaseString(inputString: string): string;
+//# sourceMappingURL=data-table-helper.d.ts.map

package/dist/components/custom/data-table/data-table-list-view.d.ts

@@ -0,0 +1,13 @@
+import { Row, RowSelectionState } from '@tanstack/react-table';
+import { DataTableGroupByConfig } from './data-table-group-by.types';
+import * as React from "react";
+export declare function DataTableListView({ rows, rowSelection, onRowClickFn, layoutKey, groupBy, firstRowData, footerData, }: {
+    rows: Row<unknown>[];
+    rowSelection: RowSelectionState;
+    onRowClickFn?: (row: unknown) => void;
+    layoutKey: string;
+    groupBy?: DataTableGroupByConfig<unknown>;
+    firstRowData?: React.ReactNode;
+    footerData?: React.ReactNode;
+}): React.JSX.Element;
+//# sourceMappingURL=data-table-list-view.d.ts.map

package/dist/components/custom/data-table/data-table-page-size.d.ts

@@ -0,0 +1,11 @@
+export declare const DATA_TABLE_PAGE_SIZE_OPTIONS: readonly [20, 30, 40, 50, 60, 70, 80, 90, 100];
+export declare const DEFAULT_DATA_TABLE_PAGE_SIZE = 50;
+export declare const INFINITE_FETCH_PAGE_SIZE = 100;
+/** Keeps table/card scroll inside the datatable so sticky headers and infinite scroll work. */
+export declare const DATA_TABLE_BODY_MAX_HEIGHT_CLASS = "max-h-[min(100%,calc(100dvh-5rem))] lg:max-h-[min(100%,calc(100dvh-13rem))]";
+export type DataTableRowsPerPage = number | "infinite";
+export declare function getDataTablePageSizeStorageKey(tableName: string): string;
+export declare function parseDataTableRowsPerPage(raw: string | null): DataTableRowsPerPage | null;
+export declare function resolveDataTableQueryPageSize(sizeParam: string | null, fallback?: number): number;
+export declare function isDataTableInfiniteFromStorage(tableName: string): boolean;
+//# sourceMappingURL=data-table-page-size.d.ts.map

package/dist/components/custom/data-table/data-table-pagination.d.ts

@@ -0,0 +1,9 @@
+import { Pagination as PaginationType } from './types';
+interface DataTablePaginationProps {
+    pagination: PaginationType;
+    onPageChange: (page: number) => void;
+    className?: string;
+}
+export declare function DataTablePagination({ pagination, onPageChange, className, }: DataTablePaginationProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=data-table-pagination.d.ts.map

package/dist/components/custom/data-table/data-table-toolbar.d.ts

@@ -0,0 +1,26 @@
+import { Table, VisibilityState } from '@tanstack/react-table';
+import { default as React } from 'react';
+interface DataTableToolbarProps<TData> {
+    table: Table<TData>;
+    btnList?: React.ReactNode[];
+    itemCountText: string;
+    title: string;
+    viewMode: "table" | "list";
+    pinnedColumnIds: string[];
+    icon: React.ReactNode;
+    headerComponent?: React.ReactNode;
+    searchComponent?: React.ReactNode;
+    setViewMode: React.Dispatch<React.SetStateAction<"table" | "list">>;
+    setPinnedColumnIds: React.Dispatch<React.SetStateAction<string[]>>;
+    columnVisibility: VisibilityState;
+    setColumnVisibility: React.Dispatch<React.SetStateAction<VisibilityState>>;
+    disableViewSettingsLabel?: boolean;
+    leftActionComponent?: React.ReactNode;
+    isModal?: boolean;
+}
+export declare function DataTableToolbar<TData>({ table, btnList, title, viewMode, itemCountText, pinnedColumnIds, searchComponent, icon, headerComponent, setViewMode, setPinnedColumnIds, columnVisibility, setColumnVisibility, isVisible, // New prop to control visibility
+disableViewSettingsLabel, leftActionComponent, isModal, }: DataTableToolbarProps<TData> & {
+    isVisible?: boolean;
+}): React.JSX.Element;
+export {};
+//# sourceMappingURL=data-table-toolbar.d.ts.map

package/dist/components/custom/data-table/data-table-util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Exports an array of objects to a CSV file.
+ * @param data - The array of objects (selected users)
+ * @param filename - The name of the file to be downloaded
+ */
+export declare function exportToCSV(data: any[], filename?: string): void;
+//# sourceMappingURL=data-table-util.d.ts.map

package/dist/components/custom/data-table/data-table-view-fallback.d.ts

@@ -0,0 +1,2 @@
+export declare function DataTableViewFallback(): import("react").JSX.Element;
+//# sourceMappingURL=data-table-view-fallback.d.ts.map

package/dist/components/custom/data-table/data-table-view-options.d.ts

@@ -0,0 +1,17 @@
+import { Table, VisibilityState } from '@tanstack/react-table';
+import { default as React } from 'react';
+import { DataTableViewMode } from './data-table-view-preferences';
+interface DataTableViewOptionsProps<TData> {
+    table: Table<TData>;
+    pluginName?: string;
+    columnVisibility: VisibilityState;
+    setColumnVisibility: React.Dispatch<React.SetStateAction<VisibilityState>>;
+    viewMode: DataTableViewMode;
+    setViewMode: (mode: DataTableViewMode) => void;
+    pinnedColumnIds: string[];
+    setPinnedColumnIds: React.Dispatch<React.SetStateAction<string[]>>;
+    disableViewSettingsLabel?: boolean;
+}
+export declare function DataTableViewOptions<TData>({ table, pluginName, columnVisibility, setColumnVisibility, viewMode, pinnedColumnIds, setViewMode, setPinnedColumnIds, disableViewSettingsLabel, }: DataTableViewOptionsProps<TData>): React.JSX.Element;
+export {};
+//# sourceMappingURL=data-table-view-options.d.ts.map

package/dist/components/custom/data-table/data-table-view-preferences.d.ts

@@ -0,0 +1,22 @@
+import { VisibilityState } from '@tanstack/react-table';
+import { DataTableViewPreferencesPersist } from './data-table-view-preferences.storage';
+import * as React from "react";
+export type DataTableViewMode = "table" | "list";
+export type { DataTableViewPreferencesPersist };
+type UseDataTableViewPreferencesArgs = {
+    tableName: string;
+    isMobile: boolean;
+    getMobileDefaults?: () => VisibilityState;
+    /** Where to persist view prefs. Default: `"indexedDB"`. Use `"localStorage"` for sync storage. */
+    persist?: DataTableViewPreferencesPersist;
+};
+export declare function getDataTableViewPreferencesStorageKey(tableName: string): string;
+export declare function useDataTableViewPreferences({ tableName, isMobile, getMobileDefaults, persist, }: UseDataTableViewPreferencesArgs): {
+    columnVisibility: VisibilityState;
+    setColumnVisibility: React.Dispatch<React.SetStateAction<VisibilityState>>;
+    viewMode: DataTableViewMode;
+    setViewMode: React.Dispatch<React.SetStateAction<DataTableViewMode>>;
+    pinnedColumnIds: string[];
+    setPinnedColumnIds: React.Dispatch<React.SetStateAction<string[]>>;
+};
+//# sourceMappingURL=data-table-view-preferences.d.ts.map

package/dist/components/custom/data-table/data-table-view-preferences.storage.d.ts

@@ -0,0 +1,15 @@
+import { VisibilityState } from '@tanstack/react-table';
+import { DataTableViewMode } from './data-table-view-preferences';
+export type DataTableViewPreferencesPersist = "localStorage" | "indexedDB" | false;
+export type StoredViewPreferences = {
+    pinnedColumnIds: string[];
+    columnVisibility: VisibilityState;
+    viewMode: DataTableViewMode;
+};
+export declare function serializeViewPreferences(prefs: StoredViewPreferences): string;
+export declare function parseViewPreferences(raw: string): StoredViewPreferences | null;
+export declare function loadViewPreferences(storageKey: string, persist: DataTableViewPreferencesPersist): Promise<StoredViewPreferences | null>;
+export declare function saveViewPreferences(storageKey: string, persist: DataTableViewPreferencesPersist, prefs: StoredViewPreferences): Promise<void>;
+export declare function buildColumnLayoutKey(columnVisibility: VisibilityState, pinnedColumnIds: string[], viewMode: DataTableViewMode, hideableColumnIds?: string[]): string;
+export declare function setColumnVisibleInState(prev: VisibilityState, columnId: string, visible: boolean): VisibilityState;
+//# sourceMappingURL=data-table-view-preferences.storage.d.ts.map

package/dist/components/custom/data-table/data-table-wrapper.d.ts

@@ -0,0 +1,51 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { DataTableFooterItem } from './data-table-grid';
+import { DataTableGroupByConfig } from './data-table-group-by.types';
+import { DataTableRowsPerPage } from './data-table-page-size';
+import { DataTableViewPreferencesPersist } from './data-table-view-preferences.storage';
+import { DataTablePaginationMode, DataTablePaginationState } from './use-data-table-page-size';
+import { Pagination, PaginationViaIndex } from './types';
+declare function DataTableWrapper<TData, TValue>({ title, pluginName, isLoading, error, refetch, isRefetching, totalItems, data, paginationComponent, columns, btnList, onRowClickFn, disableToolbar, loadingMessage, emptyStateAction, emptyStateDescription, emptyStateTitle, tableName, searchComponent, icon, renderBulkActions, headerComponent, disableViewSettingsLabel, leftActionComponent, isModal, footerData, groupBy, isInfinitePagination, pageSize, pagination, cursorPagination, paginationMode, onPageSizeChange, onPaginationChange, viewPreferencesPersist, itemCountText, maxHeightClass, firstRowData, firstRowCardView, footerCardView, }: {
+    title: string;
+    pluginName?: string;
+    isLoading: boolean;
+    error?: any;
+    refetch?: () => void | Promise<unknown>;
+    isRefetching?: boolean;
+    data: any;
+    totalItems: number;
+    paginationComponent: React.ReactNode;
+    columns: ColumnDef<TData, TValue>[];
+    btnList: React.ReactNode[];
+    disableToolbar?: boolean;
+    onRowClickFn: (data: TData) => void;
+    loadingMessage?: string;
+    emptyStateTitle?: string;
+    emptyStateDescription?: string;
+    emptyStateAction?: React.ReactNode;
+    tableName: string;
+    icon: React.ReactNode;
+    headerComponent?: React.ReactNode;
+    searchComponent?: React.ReactNode;
+    renderBulkActions?: (selectedData: TData[]) => React.ReactNode;
+    disableViewSettingsLabel?: boolean;
+    leftActionComponent?: React.ReactNode;
+    isModal?: boolean;
+    footerData?: DataTableFooterItem[];
+    groupBy?: DataTableGroupByConfig<TData>;
+    isInfinitePagination?: boolean;
+    pageSize?: number;
+    pagination?: Pagination;
+    cursorPagination?: PaginationViaIndex;
+    paginationMode?: DataTablePaginationMode;
+    onPageSizeChange?: (pageSize: DataTableRowsPerPage) => void;
+    onPaginationChange?: (state: DataTablePaginationState) => void;
+    viewPreferencesPersist?: DataTableViewPreferencesPersist;
+    itemCountText: string;
+    maxHeightClass?: string;
+    firstRowData?: DataTableFooterItem[];
+    firstRowCardView?: React.ReactNode;
+    footerCardView?: React.ReactNode;
+}): import("react").JSX.Element;
+export default DataTableWrapper;
+//# sourceMappingURL=data-table-wrapper.d.ts.map

package/dist/components/custom/data-table/data-table.d.ts

@@ -0,0 +1,47 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { DataTableFooterItem } from './data-table-grid';
+import { DataTableGroupByConfig } from './data-table-group-by.types';
+import { DataTableRowsPerPage } from './data-table-page-size';
+import { DataTableViewPreferencesPersist } from './data-table-view-preferences.storage';
+import * as React from "react";
+interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    btnList?: React.ReactNode[];
+    disableToolbar?: boolean;
+    onRowClickFn?: (row: TData) => void;
+    totalItems: number;
+    title: string;
+    tableName: string;
+    icon: React.ReactNode;
+    headerComponent?: React.ReactNode;
+    searchComponent?: React.ReactNode;
+    renderBulkActions?: (selectedData: TData[]) => React.ReactNode;
+    disableDefaultBulkExport?: boolean;
+    disableViewSettingsLabel?: boolean;
+    leftActionComponent?: React.ReactNode;
+    paginationComponent?: React.ReactNode;
+    isModal?: boolean;
+    dataTableClassName?: string;
+    emptyStateTitle?: string;
+    emptyStateDescription?: string;
+    emptyStateAction?: React.ReactNode;
+    refetch?: () => void | Promise<unknown>;
+    footerData?: DataTableFooterItem[];
+    groupBy?: DataTableGroupByConfig<TData>;
+    isInfinitePagination?: boolean;
+    pageSize?: number;
+    onPageSizeChange?: (pageSize: DataTableRowsPerPage) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    isLoadingMore?: boolean;
+    viewPreferencesPersist?: DataTableViewPreferencesPersist;
+    itemCountText: string;
+    maxHeightClass?: string;
+    firstRowData?: DataTableFooterItem[];
+    firstRowCardView?: React.ReactNode;
+    footerCardView?: React.ReactNode;
+}
+export declare function DataTable<TData, TValue>({ columns, data, btnList, disableToolbar, onRowClickFn, totalItems, title, tableName, searchComponent, icon, headerComponent, renderBulkActions, disableDefaultBulkExport, disableViewSettingsLabel, leftActionComponent, paginationComponent, isModal, dataTableClassName, emptyStateAction, emptyStateDescription, emptyStateTitle, refetch, footerData, groupBy, isInfinitePagination, pageSize, onPageSizeChange, onLoadMore, hasMore, isLoadingMore, viewPreferencesPersist, itemCountText, maxHeightClass, firstRowData, firstRowCardView, footerCardView, }: DataTableProps<TData, TValue>): React.JSX.Element;
+export {};
+//# sourceMappingURL=data-table.d.ts.map

package/dist/components/custom/data-table/export.d.ts

@@ -0,0 +1,22 @@
+export * from './cursor-based-pagination';
+export * from './data-table-bulk-action-menu';
+export * from './data-table-bulk-export';
+export * from './data-table-column-header';
+export * from './data-table-grid';
+export * from './data-table-group-by.types';
+export * from './data-table-helper';
+export * from './data-table-list-view';
+export * from './data-table-page-size';
+export * from './data-table-pagination';
+export * from './data-table-toolbar';
+export * from './data-table-util';
+export * from './data-table-view-fallback';
+export * from './data-table-view-options';
+export * from './data-table-view-preferences.storage';
+export * from './data-table-view-preferences';
+export * from './data-table-wrapper';
+export * from './data-table';
+export * from './types';
+export * from './use-data-table-page-size';
+export * from './group-table-rows';
+//# sourceMappingURL=export.d.ts.map

package/dist/components/custom/data-table/group-table-rows.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '@tanstack/react-table';
+export declare function groupTableRowsBy<TData>(rows: Row<TData>[], getGroupKey: (row: TData) => string): [string, Row<TData>[]][];
+//# sourceMappingURL=group-table-rows.d.ts.map

package/dist/components/custom/data-table/types.d.ts

@@ -0,0 +1,17 @@
+export type PaginationViaIndex = {
+    nextCursor: string | number | null;
+    previousCursor: string | number | null;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    pageSize: number;
+    totalItems: number;
+};
+export type Pagination = {
+    currentPage: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/components/custom/data-table/use-data-table-page-size.d.ts

@@ -0,0 +1,41 @@
+import { Pagination, PaginationViaIndex } from '../../types';
+import { DataTableRowsPerPage } from './data-table-page-size';
+export type DataTablePaginationMode = "offset" | "cursor";
+export type DataTablePaginationState = {
+    pageSize: number;
+    page: number;
+    after: string;
+    before: string;
+    isInfinite: boolean;
+};
+type UseDataTablePageSizeArgs<TData> = {
+    tableName: string;
+    data: TData[];
+    totalItems?: number;
+    enabled?: boolean;
+    defaultPageSize?: number;
+    pagination?: Pagination;
+    cursorPagination?: PaginationViaIndex;
+    paginationMode?: DataTablePaginationMode;
+    forceInfinite?: boolean;
+    onPageSizeChange?: (pageSize: DataTableRowsPerPage) => void;
+    onPaginationChange?: (state: DataTablePaginationState) => void;
+};
+export declare function useDataTablePageSize<TData>({ tableName, data, totalItems, enabled, defaultPageSize, pagination, cursorPagination, paginationMode, forceInfinite, onPageSizeChange, onPaginationChange, }: UseDataTablePageSizeArgs<TData>): {
+    rowsPerPage: DataTableRowsPerPage;
+    pageSize: number;
+    isInfinitePagination: boolean;
+    tableData: TData[];
+    handlePageSizeChange: (next: DataTableRowsPerPage) => void;
+    loadMore: () => void;
+    hasMore: any;
+    paginationState: {
+        pageSize: number;
+        page: number;
+        after: string;
+        before: string;
+        isInfinite: boolean;
+    };
+};
+export {};
+//# sourceMappingURL=use-data-table-page-size.d.ts.map

package/dist/components/custom/document-title.d.ts

@@ -0,0 +1,4 @@
+export declare function DocumentTitle({ children }: {
+    children: string;
+}): null;
+//# sourceMappingURL=document-title.d.ts.map

package/dist/components/custom/empty-screen.d.ts

@@ -0,0 +1,8 @@
+export declare const EmptyState: ({ title, description, action, className, pluginName }: {
+    title?: string;
+    description?: string;
+    action?: React.ReactNode;
+    className?: string;
+    pluginName?: string;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=empty-screen.d.ts.map

package/dist/components/custom/error-screen.d.ts

@@ -0,0 +1,9 @@
+export declare const ErrorState: ({ title, error, onRetry, retryText, className, pluginName, }: {
+    title?: string;
+    error?: string | any;
+    onRetry?: () => void;
+    retryText?: string;
+    className?: string;
+    pluginName?: string;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=error-screen.d.ts.map

package/dist/components/custom/floating-action-btn.d.ts

@@ -0,0 +1,39 @@
+import { default as React, CSSProperties, ReactNode } from 'react';
+import { HandType } from '@quan-erp/shared-frontend-core';
+type FABChild = React.ReactElement<typeof FloatingButton> | React.ReactElement<typeof FloatingContainer>;
+export declare function FloatingActionButton({ expandable, onOpenVibrate, adaptivePosition, ...props }: {
+    pluginName?: string;
+    className?: string;
+    expandClassName?: string;
+    style?: CSSProperties;
+    open?: boolean;
+    onOpenChange?: (value: boolean) => void;
+    onOpenVibrate?: boolean;
+    colSpan?: number;
+    rowSpan?: number;
+    children: FABChild | FABChild[];
+    opacity?: number;
+    disabled?: boolean;
+    mobileBackActionCleanupDelay?: number;
+    expandable?: boolean;
+    adaptivePosition?: boolean;
+    adaptivePositionDelay?: number;
+    adaptivePositionClassName?: (hand: HandType) => string;
+}): React.JSX.Element;
+export declare function FloatingButton({ children, onClick }: {
+    children?: ReactNode;
+    onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+}): React.JSX.Element;
+export declare namespace FloatingButton {
+    var typeTag: string;
+}
+export declare function FloatingContainer({ children, className, style, }: {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}): React.JSX.Element;
+export declare namespace FloatingContainer {
+    var typeTag: string;
+}
+export {};
+//# sourceMappingURL=floating-action-btn.d.ts.map