@ahoo-wang/fetcher-viewer 3.8.9 → 3.9.2

package/dist/table/ViewTable.d.ts

@@ -56,7 +56,7 @@ import { TableRecordType } from '../types';
  *     }
  *   ],
  *   availableFilters: [],
- *   dataSourceUrl: '/api/users',
+ *   dataUrl: '/api/users',
  *   countUrl: '/api/users/count',
  *   checkable: true
  * };

package/dist/viewer/FilterStateContext.d.ts

@@ -1,10 +1,166 @@
 import { FilterStateReducerReturn } from './useFilterStateReducer';
 import { ReactNode } from 'react';
+/**
+ * Filter State Context Type
+ *
+ * Represents the complete filter state management interface provided by the context.
+ * This includes active filters, panel visibility, query conditions, and update functions.
+ */
 export type FilterStateContext = FilterStateReducerReturn;
+/**
+ * React Context for Filter State Management
+ *
+ * Provides a centralized way to manage filter state across the viewer component tree.
+ * Components can access and modify filter state without prop drilling.
+ *
+ * @example
+ * ```tsx
+ * import { useFilterStateContext } from './FilterStateContext';
+ *
+ * function FilterButton() {
+ *   const { showFilterPanel, updateShowFilterPanel } = useFilterStateContext();
+ *
+ *   return (
+ *     <button onClick={() => updateShowFilterPanel(!showFilterPanel)}>
+ *       {showFilterPanel ? 'Hide' : 'Show'} Filters
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
 export declare const FilterStateContext: import('react').Context<FilterStateReducerReturn | undefined>;
+/**
+ * Props for the FilterStateContextProvider component.
+ *
+ * Extends the FilterStateContext interface with React children for component composition.
+ */
 export interface FilterStateContextOptions extends FilterStateContext {
+    /** Child components that will have access to the filter state context */
     children: ReactNode;
 }
+/**
+ * Filter State Context Provider Component
+ *
+ * Provides filter state management to all descendant components in the React tree.
+ * This component should wrap the parts of your application that need access to filter state.
+ *
+ * @param props - Provider configuration and child components
+ * @param props.children - Components that will have access to filter state
+ * @param props.activeFilters - Current active filter configurations
+ * @param props.showFilterPanel - Whether the filter panel is visible
+ * @param props.queryCondition - Current query condition for data filtering
+ * @param props.updateActiveFilters - Function to update active filters
+ * @param props.updateShowFilterPanel - Function to toggle filter panel visibility
+ * @param props.updateQueryCondition - Function to update query conditions
+ *
+ * @example
+ * ```tsx
+ * import { FilterStateContextProvider } from './FilterStateContext';
+ * import { useFilterState } from './useFilterStateReducer';
+ *
+ * function App() {
+ *   // Initialize filter state management
+ *   const filterState = useFilterState({
+ *     initialFilters: [],
+ *     initialCondition: {}
+ *   });
+ *
+ *   return (
+ *     <FilterStateContextProvider
+ *       activeFilters={filterState.activeFilters}
+ *       showFilterPanel={filterState.showFilterPanel}
+ *       queryCondition={filterState.queryCondition}
+ *       updateActiveFilters={filterState.updateActiveFilters}
+ *       updateShowFilterPanel={filterState.updateShowFilterPanel}
+ *       updateQueryCondition={filterState.updateQueryCondition}
+ *     >
+ *       <FilterableDataTable />
+ *       <FilterPanel />
+ *     </FilterStateContextProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Integration with Viewer component
+ * function DataViewer({ definition, dataSource }) {
+ *   const filterState = useFilterState({
+ *     initialFilters: definition.filters || [],
+ *     initialCondition: definition.condition || {}
+ *   });
+ *
+ *   return (
+ *     <FilterStateContextProvider {...filterState}>
+ *       <Viewer
+ *         definition={definition}
+ *         dataSource={dataSource}
+ *       />
+ *     </FilterStateContextProvider>
+ *   );
+ * }
+ * ```
+ */
 export declare function FilterStateContextProvider({ children, ...options }: FilterStateContextOptions): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to Access Filter State Context
+ *
+ * Provides access to the filter state context within components.
+ * Must be used within a FilterStateContextProvider component tree.
+ *
+ * @returns Filter state context with all filter management functions
+ * @throws Error if used outside of FilterStateContextProvider
+ *
+ * @example
+ * ```tsx
+ * import { useFilterStateContext } from './FilterStateContext';
+ *
+ * function FilterControls() {
+ *   const {
+ *     activeFilters,
+ *     showFilterPanel,
+ *     queryCondition,
+ *     updateActiveFilters,
+ *     updateShowFilterPanel,
+ *     updateQueryCondition
+ *   } = useFilterStateContext();
+ *
+ *   const handleAddFilter = (newFilter) => {
+ *     updateActiveFilters([...activeFilters, newFilter]);
+ *   };
+ *
+ *   const handleTogglePanel = () => {
+ *     updateShowFilterPanel(!showFilterPanel);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleTogglePanel}>
+ *         {showFilterPanel ? 'Hide' : 'Show'} Filters
+ *       </button>
+ *       <FilterList
+ *         filters={activeFilters}
+ *         onAddFilter={handleAddFilter}
+ *       />
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Error handling pattern
+ * function SafeFilterComponent() {
+ *   try {
+ *     const filterState = useFilterStateContext();
+ *     return <FilterUI {...filterState} />;
+ *   } catch (error) {
+ *     // Handle case where context is not available
+ *     console.warn('FilterStateContext not found, using defaults');
+ *     return <DefaultFilterUI />;
+ *   }
+ * }
+ * ```
+ */
 export declare function useFilterStateContext(): FilterStateContext;
 //# sourceMappingURL=FilterStateContext.d.ts.map

package/dist/viewer/FilterStateContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilterStateContext.d.ts","sourceRoot":"","sources":["../../src/viewer/FilterStateContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAiB,SAAS,EAAc,MAAM,OAAO,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;AAE1D,eAAO,MAAM,kBAAkB,+DAE9B,CAAC;AAEF,MAAM,WAAW,yBAA0B,SAAQ,kBAAkB;IACnE,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,wBAAgB,0BAA0B,CAAC,EACzC,QAAQ,EACR,GAAG,OAAO,EACX,EAAE,yBAAyB,2CAM3B;AAED,wBAAgB,qBAAqB,IAAI,kBAAkB,CAQ1D"}
+{"version":3,"file":"FilterStateContext.d.ts","sourceRoot":"","sources":["../../src/viewer/FilterStateContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EAAiB,SAAS,EAAc,MAAM,OAAO,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,+DAE9B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,yBAA0B,SAAQ,kBAAkB;IACnE,yEAAyE;IACzE,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,QAAQ,EACR,GAAG,OAAO,EACX,EAAE,yBAAyB,2CAM3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAgB,qBAAqB,IAAI,kBAAkB,CAQ1D"}

package/dist/viewer/TableStateContext.d.ts

@@ -1,12 +1,210 @@
 import { ReactNode } from 'react';
 import { UseTableStateReducerReturn } from './useTableStateReducer';
+/**
+ * Table State Context Type
+ *
+ * Represents the complete table state management interface provided by the context.
+ * Extends the table state reducer with data refresh functionality.
+ */
 export type TableStateContext = UseTableStateReducerReturn & {
+    /** Function to refresh/reload table data */
     refreshData: () => void;
 };
+/**
+ * React Context for Table State Management
+ *
+ * Provides centralized management of table-related state across the viewer component tree.
+ * Includes column configurations, table sizing, and data refresh capabilities.
+ *
+ * @example
+ * ```tsx
+ * import { useTableStateContext } from './TableStateContext';
+ *
+ * function TableControls() {
+ *   const { columns, tableSize, refreshData } = useTableStateContext();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={refreshData}>Refresh Data</button>
+ *       <span>Table Size: {tableSize}</span>
+ *       <span>Visible Columns: {columns.filter(c => c.visible).length}</span>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export declare const TableStateContext: import('react').Context<TableStateContext | undefined>;
+/**
+ * Props for the TableStateContextProvider component.
+ *
+ * Extends the TableStateContext interface with React children for component composition.
+ */
 export interface TableStateContextOptions extends TableStateContext {
+    /** Child components that will have access to the table state context */
     children: ReactNode;
 }
+/**
+ * Table State Context Provider Component
+ *
+ * Provides table state management to all descendant components in the React tree.
+ * This component should wrap the parts of your application that need access to table state.
+ *
+ * @param props - Provider configuration and child components
+ * @param props.children - Components that will have access to table state
+ * @param props.columns - Current column configurations with visibility and sizing
+ * @param props.tableSize - Current table size (small, middle, large)
+ * @param props.updateColumns - Function to update column configurations
+ * @param props.updateTableSize - Function to change table size
+ * @param props.refreshData - Function to refresh/reload table data
+ *
+ * @example
+ * ```tsx
+ * import { TableStateContextProvider } from './TableStateContext';
+ * import { useTableState } from './useTableStateReducer';
+ *
+ * function DataTable({ definition, dataSource }) {
+ *   // Initialize table state management
+ *   const tableState = useTableState({
+ *     initialColumns: definition.columns,
+ *     initialTableSize: 'middle'
+ *   });
+ *
+ *   const handleRefresh = async () => {
+ *     // Fetch fresh data from API
+ *     const newData = await fetchData();
+ *     setDataSource(newData);
+ *   };
+ *
+ *   return (
+ *     <TableStateContextProvider
+ *       columns={tableState.columns}
+ *       tableSize={tableState.tableSize}
+ *       updateColumns={tableState.updateColumns}
+ *       updateTableSize={tableState.updateTableSize}
+ *       refreshData={handleRefresh}
+ *     >
+ *       <ViewTable
+ *         viewDefinition={definition}
+ *         dataSource={dataSource}
+ *       />
+ *       <TableSettings />
+ *       <RefreshButton />
+ *     </TableStateContextProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Integration with Viewer component
+ * function DataViewer({ definition, dataSource, onRefresh }) {
+ *   const tableState = useTableState({
+ *     initialColumns: definition.columns,
+ *     initialTableSize: definition.tableSize || 'middle'
+ *   });
+ *
+ *   return (
+ *     <TableStateContextProvider
+ *       columns={tableState.columns}
+ *       tableSize={tableState.tableSize}
+ *       updateColumns={tableState.updateColumns}
+ *       updateTableSize={tableState.updateTableSize}
+ *       refreshData={onRefresh}
+ *     >
+ *       <Viewer
+ *         definition={definition}
+ *         dataSource={dataSource}
+ *       />
+ *     </TableStateContextProvider>
+ *   );
+ * }
+ * ```
+ */
 export declare function TableStateContextProvider({ children, ...options }: TableStateContextOptions): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to Access Table State Context
+ *
+ * Provides access to the table state context within components.
+ * Must be used within a TableStateContextProvider component tree.
+ *
+ * @returns Table state context with all table management functions
+ * @throws Error if used outside of TableStateContextProvider
+ *
+ * @example
+ * ```tsx
+ * import { useTableStateContext } from './TableStateContext';
+ *
+ * function ColumnVisibilityToggle({ columnId }) {
+ *   const { columns, updateColumns } = useTableStateContext();
+ *
+ *   const column = columns.find(c => c.dataIndex === columnId);
+ *   const isVisible = column?.visible ?? true;
+ *
+ *   const handleToggle = () => {
+ *     const updatedColumns = columns.map(c =>
+ *       c.dataIndex === columnId
+ *         ? { ...c, visible: !isVisible }
+ *         : c
+ *     );
+ *     updateColumns(updatedColumns);
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleToggle}>
+ *       {isVisible ? 'Hide' : 'Show'} Column
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Table size controls
+ * function TableSizeSelector() {
+ *   const { tableSize, updateTableSize } = useTableStateContext();
+ *
+ *   return (
+ *     <select
+ *       value={tableSize}
+ *       onChange={(e) => updateTableSize(e.target.value as SizeType)}
+ *     >
+ *       <option value="small">Small</option>
+ *       <option value="middle">Medium</option>
+ *       <option value="large">Large</option>
+ *     </select>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Data refresh functionality
+ * function RefreshControls() {
+ *   const { refreshData } = useTableStateContext();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={refreshData}>Refresh Data</button>
+ *       <AutoRefreshToggle />
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Error handling pattern
+ * function SafeTableComponent() {
+ *   try {
+ *     const tableState = useTableStateContext();
+ *     return <TableUI {...tableState} />;
+ *   } catch (error) {
+ *     // Handle case where context is not available
+ *     console.warn('TableStateContext not found, using defaults');
+ *     return <DefaultTable />;
+ *   }
+ * }
+ * ```
+ */
 export declare function useTableStateContext(): TableStateContext;
 //# sourceMappingURL=TableStateContext.d.ts.map

package/dist/viewer/TableStateContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TableStateContext.d.ts","sourceRoot":"","sources":["../../src/viewer/TableStateContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAAc,MAAM,OAAO,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAEpE,MAAM,MAAM,iBAAiB,GAAG,0BAA0B,GAAG;IAC3D,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,iBAAiB,wDAE7B,CAAC;AAEF,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,GAAG,OAAO,EACX,EAAE,wBAAwB,2CAM1B;AAED,wBAAgB,oBAAoB,IAAI,iBAAiB,CAQxD"}
+{"version":3,"file":"TableStateContext.d.ts","sourceRoot":"","sources":["../../src/viewer/TableStateContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAAc,MAAM,OAAO,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAEpE;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,0BAA0B,GAAG;IAC3D,4CAA4C;IAC5C,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,wDAE7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,wEAAwE;IACxE,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,GAAG,OAAO,EACX,EAAE,wBAAwB,2CAM1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoFG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CAQxD"}

package/dist/viewer/Viewer.d.ts

@@ -4,16 +4,146 @@ import { View, ViewDefinition } from './';
 import { StyleCapable, TableRecordType } from '../types';
 import { RefAttributes } from 'react';
 import { TopBarPropsCapable } from '../topbar';
+/**
+ * Ref interface for the Viewer component.
+ *
+ * Provides imperative methods to control the viewer from parent components.
+ */
 export interface ViewerRef {
+    /** Refreshes the data by re-executing the current query */
     refreshData: () => void;
 }
+/**
+ * Props for the Viewer component.
+ *
+ * The Viewer is a comprehensive data viewing component that provides:
+ * - Multiple view management with persistent configurations
+ * - Advanced filtering with editable filter panels
+ * - Table display with sorting, selection, and pagination
+ * - State management for table and filter configurations
+ * - Responsive layout with collapsible panels
+ */
 export interface ViewerProps<RecordType> extends TopBarPropsCapable<RecordType>, StyleCapable, RefAttributes<ViewerRef> {
+    /** Display name for the viewer instance */
     name: string;
+    /** Array of available views for switching between different data perspectives */
     views: View[];
+    /** Optional ID of the default view to select on initialization */
     defaultViewId?: string;
+    /** View definition containing column configurations and data source information */
     definition: ViewDefinition;
+    /** Action column configuration for table row actions */
     actionColumn: ViewTableActionColumn<TableRecordType<RecordType>>;
+    /** Additional pagination props (excluding total which is managed internally) */
     paginationProps?: Omit<PaginationProps, 'total'>;
 }
+/**
+ * Viewer Component
+ *
+ * A comprehensive data viewing component that provides a complete data management interface.
+ * It integrates views, filters, table display, and pagination into a cohesive user experience.
+ *
+ * Key features:
+ * - Multiple view management with persistent configurations
+ * - Advanced filtering with editable filter panels
+ * - Sortable, selectable table with customizable columns
+ * - Responsive layout with collapsible side panels
+ * - State management for all viewer configurations
+ * - Debounced queries for optimal performance
+ *
+ * @template RecordType - The type of data records being displayed
+ * @param props - Viewer configuration and data
+ * @param props.name - Display name for the viewer
+ * @param props.views - Available views for data perspective switching
+ * @param props.defaultViewId - Optional default view selection
+ * @param props.definition - Column and data source configuration
+ * @param props.actionColumn - Row action column configuration
+ * @param props.paginationProps - Additional pagination settings
+ * @param props.topBar - Top bar configuration and actions
+ * @param props.className - CSS class for styling
+ * @param props.style - Inline styles
+ * @param props.ref - Ref for imperative methods
+ *
+ * @example
+ * ```tsx
+ * import { Viewer } from './Viewer';
+ * import type { View, ViewDefinition } from './types';
+ *
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   email: string;
+ *   status: 'active' | 'inactive';
+ * }
+ *
+ * const userViews: View[] = [
+ *   {
+ *     id: 'all-users',
+ *     name: 'All Users',
+ *     viewType: 'PUBLIC',
+ *     viewSource: 'CUSTOM',
+ *     isDefault: true,
+ *     filters: [],
+ *     columns: [
+ *       { dataIndex: 'id', fixed: false, visible: true },
+ *       { dataIndex: 'name', fixed: false, visible: true },
+ *       { dataIndex: 'email', fixed: false, visible: true },
+ *       { dataIndex: 'status', fixed: false, visible: true }
+ *     ],
+ *     tableSize: 'middle',
+ *     condition: {},
+ *     pageSize: 20
+ *   }
+ * ];
+ *
+ * const userDefinition: ViewDefinition = {
+ *   name: 'User Management',
+ *   columns: [
+ *     {
+ *       title: 'ID',
+ *       dataIndex: 'id',
+ *       type: 'number',
+ *       primaryKey: true,
+ *       sorter: true
+ *     },
+ *     {
+ *       title: 'Name',
+ *       dataIndex: 'name',
+ *       type: 'text',
+ *       sorter: true
+ *     }
+ *   ],
+ *   availableFilters: [],
+ *   dataUrl: '/api/users',
+ *   countUrl: '/api/users/count',
+ *   checkable: true
+ * };
+ *
+ * const actionColumn: ViewTableActionColumn<User> = {
+ *   title: 'Actions',
+ *   configurable: true,
+ *   actions: (record) => ({
+ *     primaryAction: {
+ *       data: { value: 'Edit', record, index: 0 },
+ *       attributes: { onClick: () => handleEdit(record) }
+ *     }
+ *   })
+ * };
+ *
+ * function UserManagement() {
+ *   const viewerRef = useRef<ViewerRef>(null);
+ *
+ *   return (
+ *     <Viewer<User>
+ *       ref={viewerRef}
+ *       name="User Management"
+ *       views={userViews}
+ *       definition={userDefinition}
+ *       actionColumn={actionColumn}
+ *     />
+ *   );
+ * }
+ * ```
+ */
 export declare function Viewer<RecordType>(props: ViewerProps<RecordType>): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=Viewer.d.ts.map

package/dist/viewer/Viewer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Viewer.d.ts","sourceRoot":"","sources":["../../src/viewer/Viewer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAsB,eAAe,EAAS,MAAM,MAAM,CAAC;AAElE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAa,MAAM,IAAI,CAAC;AAErD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,EACL,aAAa,EAKd,MAAM,OAAO,CAAC;AAYf,OAAO,EAAU,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAWvD,MAAM,WAAW,SAAS;IACxB,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,WAAW,CAAC,UAAU,CACrC,SACE,kBAAkB,CAAC,UAAU,CAAC,EAC9B,YAAY,EACZ,aAAa,CAAC,SAAS,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,cAAc,CAAC;IAC3B,YAAY,EAAE,qBAAqB,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjE,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;CAClD;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,UAAU,CAAC,2CAsThE"}
+{"version":3,"file":"Viewer.d.ts","sourceRoot":"","sources":["../../src/viewer/Viewer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAsB,eAAe,EAAS,MAAM,MAAM,CAAC;AAElE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAa,MAAM,IAAI,CAAC;AAErD,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,EACL,aAAa,EAKd,MAAM,OAAO,CAAC;AAYf,OAAO,EAAU,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAWvD;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW,CAAC,UAAU,CACrC,SACE,kBAAkB,CAAC,UAAU,CAAC,EAC9B,YAAY,EACZ,aAAa,CAAC,SAAS,CAAC;IAC1B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,kEAAkE;IAClE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mFAAmF;IACnF,UAAU,EAAE,cAAc,CAAC;IAC3B,wDAAwD;IACxD,YAAY,EAAE,qBAAqB,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC;IACjE,gFAAgF;IAChF,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2GG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,UAAU,CAAC,2CAkUhE"}

package/dist/viewer/index.d.ts

@@ -5,5 +5,4 @@ export * from './types';
 export * from './useFilterStateReducer';
 export * from './useTableStateReducer';
 export * from './Viewer';
-export * from './ViewerSharedValueContext';
 //# sourceMappingURL=index.d.ts.map

package/dist/viewer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/viewer/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AACxB,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,UAAU,CAAC;AACzB,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/viewer/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,SAAS,CAAC;AACxB,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,UAAU,CAAC"}

package/dist/viewer/panel/ViewItem.d.ts

@@ -1,8 +1,88 @@
 import { View } from '../index';
+/**
+ * Props for the ViewItem component.
+ *
+ * @interface ViewItemProps
+ */
 export interface ViewItemProps {
+    /** The view configuration containing name, type, filters, and other metadata */
     view: View;
+    /** API endpoint URL for fetching the count of records matching this view's condition */
     countUrl: string;
+    /** Whether this view item is currently active/selected */
     active: boolean;
 }
+/**
+ * ViewItem Component
+ *
+ * A compact component that displays a view item in a list or panel. It shows the view name,
+ * a system tag for system views, and the record count (when not active). The component
+ * automatically fetches and displays the count of records that match the view's condition
+ * using a debounced query to avoid excessive API calls.
+ *
+ * @param props - The properties for configuring the view item
+ * @param props.view - The view configuration with name, type, condition, and metadata
+ * @param props.countUrl - API endpoint for fetching record count
+ * @param props.active - Whether this view is currently selected/active
+ *
+ * @example
+ * ```tsx
+ * import { ViewItem } from './ViewItem';
+ * import type { View } from '../types';
+ *
+ * const userView: View = {
+ *   id: 'user-list',
+ *   name: 'All Users',
+ *   viewType: 'PUBLIC',
+ *   viewSource: 'CUSTOM',
+ *   isDefault: true,
+ *   filters: [],
+ *   columns: [
+ *     { dataIndex: 'id', fixed: false, visible: true },
+ *     { dataIndex: 'name', fixed: false, visible: true },
+ *     { dataIndex: 'email', fixed: false, visible: true }
+ *   ],
+ *   tableSize: 'middle',
+ *   condition: { status: 'active' },
+ *   pageSize: 20,
+ *   sortId: 1
+ * };
+ *
+ * function ViewList() {
+ *   return (
+ *     <div>
+ *       <ViewItem
+ *         view={userView}
+ *         countUrl="/api/users/count"
+ *         active={false}
+ *       />
+ *       <ViewItem
+ *         view={systemView}
+ *         countUrl="/api/users/count"
+ *         active={true}
+ *       />
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // System view with special styling
+ * const systemView: View = {
+ *   id: 'system-admin',
+ *   name: 'Admin Users',
+ *   viewType: 'PUBLIC',
+ *   viewSource: 'SYSTEM', // This will show a "系统" tag
+ *   isDefault: false,
+ *   filters: [],
+ *   columns: [],
+ *   tableSize: 'middle',
+ *   condition: { role: 'admin' },
+ *   pageSize: 10,
+ *   sortId: 2
+ * };
+ * ```
+ */
 export declare function ViewItem(props: ViewItemProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=ViewItem.d.ts.map

package/dist/viewer/panel/ViewItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewItem.d.ts","sourceRoot":"","sources":["../../../src/viewer/panel/ViewItem.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAMhC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CA8B5C"}
+{"version":3,"file":"ViewItem.d.ts","sourceRoot":"","sources":["../../../src/viewer/panel/ViewItem.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAMhC;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,gFAAgF;IAChF,IAAI,EAAE,IAAI,CAAC;IACX,wFAAwF;IACxF,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,2CAqC5C"}