cisse-vue-ui 0.8.4 → 0.10.0

package/dist/composables/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/composables/index.d.ts

@@ -7,3 +7,10 @@ export { useToast, type ToastOptions } from './useToast';
 export { useId, generateId, resetIdCounter, type UseIdOptions, type UseIdReturn } from './useId';
 export { useFocusTrap, type UseFocusTrapOptions, type UseFocusTrapReturn } from './useFocusTrap';
 export { useInputStyles, type InputSize, type UseInputStylesOptions, type UseInputStylesReturn } from './useInputStyles';
+export { useTableKeyboardNavigation, type UseTableKeyboardNavigationOptions, type UseTableKeyboardNavigationReturn, } from './useTableKeyboardNavigation';
+export { useColumnVisibility, type UseColumnVisibilityOptions, type UseColumnVisibilityReturn, type Column, } from './useColumnVisibility';
+export { usePagination, type UsePaginationOptions, type UsePaginationReturn, } from './usePagination';
+export { useColumnResize, type ColumnWidth, type UseColumnResizeOptions, type UseColumnResizeReturn, } from './useColumnResize';
+export { usePinnedRows, type PinPosition, type PinnedItem, type UsePinnedRowsOptions, type UsePinnedRowsReturn, } from './usePinnedRows';
+export { useEditableCell, type CellType, type CellEditEvent, type EditingCell, type UseEditableCellOptions, type UseEditableCellReturn, } from './useEditableCell';
+export { useVirtualScroll, type UseVirtualScrollOptions, type UseVirtualScrollReturn, } from './useVirtualScroll';

package/dist/composables/index.js

@@ -1,14 +1,17 @@
-import { a, b, c, u, d } from "../useToast-ina5g3mj.js";
-import { u as u2 } from "../useDarkMode-Cl5QWTlC.js";
+import { g, f, i, a, b, c, u, h, e, d, j } from "../useVirtualScroll-YeZru2Eo.js";
+import { u as u2, a as a2 } from "../usePagination-BGwbICFC.js";
 import { u as u3 } from "../useDropdown-XITCE_SM.js";
-import { g, r, u as u4 } from "../useId-xeHj7rkg.js";
+import { g as g2, r, u as u4 } from "../useId-xeHj7rkg.js";
 import { u as u5 } from "../useFocusTrap-AnlJsihM.js";
 import { u as u6 } from "../useInputStyles-BFTJdXHL.js";
 export {
-  g as generateId,
+  g2 as generateId,
   r as resetIdCounter,
+  g as useColumnResize,
+  f as useColumnVisibility,
   u2 as useDarkMode,
   u3 as useDropdown,
+  i as useEditableCell,
   a as useExportCSV,
   u5 as useFocusTrap,
   u4 as useId,
@@ -16,6 +19,10 @@ export {
   b as useModal,
   c as useModals,
   u as useNotifications,
-  d as useToast
+  a2 as usePagination,
+  h as usePinnedRows,
+  e as useTableKeyboardNavigation,
+  d as useToast,
+  j as useVirtualScroll
 };
 //# sourceMappingURL=index.js.map

package/dist/composables/useColumnResize.d.ts

@@ -0,0 +1,38 @@
+import { Ref, ComputedRef } from 'vue';
+export interface ColumnWidth {
+    name: string;
+    width: number;
+    minWidth?: number;
+    maxWidth?: number;
+}
+export interface UseColumnResizeOptions {
+    /** Initial column widths */
+    columns: ColumnWidth[] | Ref<ColumnWidth[]>;
+    /** Default minimum width for columns without explicit minWidth */
+    defaultMinWidth?: number;
+    /** Default maximum width for columns without explicit maxWidth */
+    defaultMaxWidth?: number;
+    /** LocalStorage key for persistence (optional) */
+    storageKey?: string;
+    /** Enable persistence to localStorage */
+    persist?: boolean;
+}
+export interface UseColumnResizeReturn {
+    /** Current column widths */
+    columnWidths: ComputedRef<Record<string, number>>;
+    /** Get width for a specific column */
+    getWidth: (name: string) => number;
+    /** Set width for a specific column */
+    setWidth: (name: string, width: number) => void;
+    /** Start resizing a column */
+    startResize: (name: string, event: MouseEvent | TouchEvent) => void;
+    /** Check if a column is currently being resized */
+    isResizing: ComputedRef<boolean>;
+    /** The column currently being resized */
+    resizingColumn: Ref<string | null>;
+    /** Reset all widths to initial values */
+    reset: () => void;
+    /** Reset a specific column width */
+    resetColumn: (name: string) => void;
+}
+export declare function useColumnResize(options: UseColumnResizeOptions): UseColumnResizeReturn;

package/dist/composables/useColumnResize.test.d.ts

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

package/dist/composables/useColumnVisibility.d.ts

@@ -0,0 +1,44 @@
+import { Ref, ComputedRef } from 'vue';
+export interface Column {
+    name: string;
+    label?: string;
+    hidden?: boolean;
+    [key: string]: unknown;
+}
+export interface UseColumnVisibilityOptions<T extends Column> {
+    /** Initial columns configuration */
+    columns: T[] | Ref<T[]>;
+    /** Initial hidden column names */
+    initialHidden?: string[];
+    /** Persist visibility to localStorage */
+    persist?: boolean;
+    /** Storage key for persistence */
+    storageKey?: string;
+    /** Minimum visible columns required */
+    minVisible?: number;
+}
+export interface UseColumnVisibilityReturn<T extends Column> {
+    /** All columns with current visibility state */
+    columns: ComputedRef<T[]>;
+    /** Only visible columns */
+    visibleColumns: ComputedRef<T[]>;
+    /** Set of hidden column names */
+    hiddenColumns: Ref<Set<string>>;
+    /** Check if a column is visible */
+    isVisible: (columnName: string) => boolean;
+    /** Show a column */
+    show: (columnName: string) => void;
+    /** Hide a column */
+    hide: (columnName: string) => void;
+    /** Toggle a column's visibility */
+    toggle: (columnName: string) => void;
+    /** Show all columns */
+    showAll: () => void;
+    /** Hide all columns (respects minVisible) */
+    hideAll: () => void;
+    /** Reset to initial state */
+    reset: () => void;
+    /** Set multiple columns visibility at once */
+    setVisibility: (visibility: Record<string, boolean>) => void;
+}
+export declare function useColumnVisibility<T extends Column>(options: UseColumnVisibilityOptions<T>): UseColumnVisibilityReturn<T>;

package/dist/composables/useColumnVisibility.test.d.ts

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

package/dist/composables/useEditableCell.d.ts

@@ -0,0 +1,51 @@
+import { Ref, ComputedRef } from 'vue';
+export type CellType = 'text' | 'number' | 'date' | 'boolean' | 'select';
+export interface CellEditEvent<T = unknown> {
+    /** Row item being edited */
+    item: T;
+    /** Column/field name */
+    field: string;
+    /** Original value before edit */
+    originalValue: unknown;
+    /** New value after edit */
+    newValue: unknown;
+}
+export interface EditingCell {
+    /** Row key */
+    rowKey: string;
+    /** Column/field name */
+    field: string;
+}
+export interface UseEditableCellOptions<T = unknown> {
+    /** Key field for row identification */
+    keyField?: string;
+    /** Callback when edit is confirmed */
+    onSave?: (event: CellEditEvent<T>) => void | Promise<void>;
+    /** Callback when edit is cancelled */
+    onCancel?: (event: Omit<CellEditEvent<T>, 'newValue'>) => void;
+    /** Validate value before saving (return error message or null) */
+    validate?: (event: CellEditEvent<T>) => string | null;
+}
+export interface UseEditableCellReturn<T> {
+    /** Currently editing cell (null if none) */
+    editingCell: Ref<EditingCell | null>;
+    /** Current edit value */
+    editValue: Ref<unknown>;
+    /** Validation error message */
+    error: Ref<string | null>;
+    /** Whether currently saving */
+    saving: Ref<boolean>;
+    /** Check if a specific cell is being edited */
+    isEditing: (rowKey: string, field: string) => boolean;
+    /** Start editing a cell */
+    startEdit: (item: T, field: string, currentValue: unknown) => void;
+    /** Confirm the edit and save */
+    confirmEdit: () => Promise<void>;
+    /** Cancel the edit */
+    cancelEdit: () => void;
+    /** Update the edit value */
+    updateValue: (value: unknown) => void;
+    /** Get item being edited */
+    editingItem: ComputedRef<T | null>;
+}
+export declare function useEditableCell<T>(options?: UseEditableCellOptions<T>): UseEditableCellReturn<T>;

package/dist/composables/useEditableCell.test.d.ts

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

package/dist/composables/usePagination.d.ts

@@ -0,0 +1,44 @@
+import { Ref, ComputedRef } from 'vue';
+export interface UsePaginationOptions<T> {
+    /** The full array of items to paginate */
+    items: T[] | Ref<T[]>;
+    /** Initial page size */
+    pageSize?: number;
+    /** Initial page (1-indexed) */
+    initialPage?: number;
+}
+export interface UsePaginationReturn<T> {
+    /** Current page number (1-indexed) */
+    currentPage: Ref<number>;
+    /** Current page size */
+    pageSize: Ref<number>;
+    /** Total number of pages */
+    totalPages: ComputedRef<number>;
+    /** Total number of items */
+    totalItems: ComputedRef<number>;
+    /** Items for the current page */
+    paginatedItems: ComputedRef<T[]>;
+    /** Index of the first item on current page (0-indexed) */
+    startIndex: ComputedRef<number>;
+    /** Index of the last item on current page (0-indexed) */
+    endIndex: ComputedRef<number>;
+    /** Whether there is a previous page */
+    hasPrevious: ComputedRef<boolean>;
+    /** Whether there is a next page */
+    hasNext: ComputedRef<boolean>;
+    /** Go to a specific page */
+    goToPage: (page: number) => void;
+    /** Go to the next page */
+    nextPage: () => void;
+    /** Go to the previous page */
+    previousPage: () => void;
+    /** Go to the first page */
+    firstPage: () => void;
+    /** Go to the last page */
+    lastPage: () => void;
+    /** Set page size (resets to page 1) */
+    setPageSize: (size: number) => void;
+    /** Reset to initial state */
+    reset: () => void;
+}
+export declare function usePagination<T>(options: UsePaginationOptions<T>): UsePaginationReturn<T>;

package/dist/composables/usePagination.test.d.ts

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

package/dist/composables/usePinnedRows.d.ts

@@ -0,0 +1,41 @@
+import { ComputedRef } from 'vue';
+export type PinPosition = 'top' | 'bottom';
+export interface PinnedItem<T = unknown> {
+    item: T;
+    position: PinPosition;
+}
+export interface UsePinnedRowsOptions<T> {
+    /** Key field for unique identification */
+    keyField?: string;
+    /** Initially pinned items */
+    initialPinned?: PinnedItem<T>[];
+    /** Maximum number of pinned rows at top */
+    maxPinnedTop?: number;
+    /** Maximum number of pinned rows at bottom */
+    maxPinnedBottom?: number;
+}
+export interface UsePinnedRowsReturn<T> {
+    /** Items pinned to the top */
+    pinnedTop: ComputedRef<T[]>;
+    /** Items pinned to the bottom */
+    pinnedBottom: ComputedRef<T[]>;
+    /** All pinned item keys */
+    pinnedKeys: ComputedRef<Set<string>>;
+    /** Check if an item is pinned */
+    isPinned: (item: T) => boolean;
+    /** Get pin position for an item (null if not pinned) */
+    getPinPosition: (item: T) => PinPosition | null;
+    /** Pin an item to a position */
+    pin: (item: T, position: PinPosition) => void;
+    /** Unpin an item */
+    unpin: (item: T) => void;
+    /** Toggle pin state */
+    togglePin: (item: T, position?: PinPosition) => void;
+    /** Move a pinned item to a different position */
+    movePin: (item: T, newPosition: PinPosition) => void;
+    /** Clear all pinned rows */
+    clearAll: () => void;
+    /** Clear pinned rows at a specific position */
+    clear: (position: PinPosition) => void;
+}
+export declare function usePinnedRows<T>(options?: UsePinnedRowsOptions<T>): UsePinnedRowsReturn<T>;

package/dist/composables/usePinnedRows.test.d.ts

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

package/dist/composables/useTableKeyboardNavigation.d.ts

@@ -0,0 +1,52 @@
+import { Ref } from 'vue';
+export interface UseTableKeyboardNavigationOptions {
+    /** The table element ref */
+    tableRef: Ref<HTMLElement | null>;
+    /** Number of rows in the table */
+    rowCount: Ref<number> | number;
+    /** Number of columns in the table */
+    colCount: Ref<number> | number;
+    /** Enable cell-level navigation (default: false, uses row-level) */
+    cellNavigation?: boolean;
+    /** Callback when a row is activated (Enter/Space) */
+    onRowActivate?: (rowIndex: number) => void;
+    /** Callback when a cell is activated (Enter/Space) */
+    onCellActivate?: (rowIndex: number, colIndex: number) => void;
+    /** Callback when focus changes */
+    onFocusChange?: (rowIndex: number, colIndex: number) => void;
+    /** Skip header row in navigation */
+    skipHeader?: boolean;
+    /** Enable wrap-around navigation */
+    wrap?: boolean;
+}
+export interface UseTableKeyboardNavigationReturn {
+    /** Currently focused row index */
+    focusedRow: Ref<number>;
+    /** Currently focused column index (for cell navigation) */
+    focusedCol: Ref<number>;
+    /** Whether keyboard navigation is active */
+    isActive: Ref<boolean>;
+    /** Set focus to a specific row */
+    setFocusedRow: (index: number) => void;
+    /** Set focus to a specific cell */
+    setFocusedCell: (row: number, col: number) => void;
+    /** Start keyboard navigation */
+    activate: () => void;
+    /** Stop keyboard navigation */
+    deactivate: () => void;
+    /** Get props to apply to a row for navigation */
+    getRowProps: (rowIndex: number) => {
+        tabIndex: number;
+        'aria-selected'?: boolean;
+        onFocus: () => void;
+    };
+    /** Get props to apply to a cell for navigation */
+    getCellProps: (rowIndex: number, colIndex: number) => {
+        tabIndex: number;
+        'aria-selected'?: boolean;
+        onFocus: () => void;
+    };
+    /** Handle keyboard events (attach to table) */
+    handleKeyDown: (event: KeyboardEvent) => void;
+}
+export declare function useTableKeyboardNavigation(options: UseTableKeyboardNavigationOptions): UseTableKeyboardNavigationReturn;

package/dist/composables/useTableKeyboardNavigation.test.d.ts

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

package/dist/composables/useVirtualScroll.d.ts

@@ -0,0 +1,32 @@
+import { Ref, ComputedRef } from 'vue';
+export interface UseVirtualScrollOptions<T> {
+    /** Array of items to virtualize */
+    items: T[] | Ref<T[]>;
+    /** Height of each row in pixels */
+    rowHeight: number;
+    /** Visible container height in pixels */
+    containerHeight: number;
+    /** Number of rows to render outside visible area (buffer) */
+    overscan?: number;
+}
+export interface UseVirtualScrollReturn<T> {
+    /** Items to actually render */
+    visibleItems: ComputedRef<T[]>;
+    /** Total height of all items (for scroll container) */
+    totalHeight: ComputedRef<number>;
+    /** Top offset for the visible items container */
+    offsetY: ComputedRef<number>;
+    /** Start index of visible items */
+    startIndex: ComputedRef<number>;
+    /** End index of visible items */
+    endIndex: ComputedRef<number>;
+    /** Scroll position */
+    scrollTop: Ref<number>;
+    /** Handle scroll event */
+    onScroll: (event: Event) => void;
+    /** Scroll to a specific index */
+    scrollToIndex: (index: number) => void;
+    /** Container ref to attach to scrollable element */
+    containerRef: Ref<HTMLElement | null>;
+}
+export declare function useVirtualScroll<T>(options: UseVirtualScrollOptions<T>): UseVirtualScrollReturn<T>;

package/dist/composables/useVirtualScroll.test.d.ts

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

package/dist/{index-SNefWfX0.js → index-BaWpldIJ.js}

@@ -395,8 +395,8 @@ function useBreakpoints(breakpoints, options = {}) {
 }
 export {
   _sfc_main as _,
-  useDebounceFn as a,
+  useBreakpoints as a,
   onClickOutside as o,
-  useBreakpoints as u
+  useDebounceFn as u
 };
-//# sourceMappingURL=index-SNefWfX0.js.map
+//# sourceMappingURL=index-BaWpldIJ.js.map