@nuraly/lumenui 0.1.0 → 0.2.2

package/dist/src/components/table/controllers/base.controller.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { ReactiveControllerHost } from 'lit';
+import { TableBaseController, TableHost, ErrorHandler } from '../interfaces/index.js';
+import { BaseComponentController } from '@nuralyui/common/controllers';
+/**
+ * Abstract base controller class that implements common functionality
+ * for all table component controllers
+ */
+export declare abstract class BaseTableController extends BaseComponentController<TableHost & ReactiveControllerHost> implements TableBaseController, ErrorHandler {
+}
+//# sourceMappingURL=base.controller.d.ts.map

package/dist/src/components/table/controllers/base.controller.js

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseComponentController } from '@nuralyui/common/controllers';
+/**
+ * Abstract base controller class that implements common functionality
+ * for all table component controllers
+ */
+export class BaseTableController extends BaseComponentController {
+}
+//# sourceMappingURL=base.controller.js.map

package/dist/src/components/table/controllers/filter.controller.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseTableController } from './base.controller.js';
+/**
+ * Filter controller manages search/filter logic
+ */
+export declare class TableFilterController extends BaseTableController {
+    /**
+     * Handle search/filter input
+     */
+    handleSearch(searchValue: string): void;
+    /**
+     * Clear search/filter
+     */
+    clearSearch(): void;
+    /**
+     * Check if search is active
+     */
+    isSearchActive(): boolean;
+    /**
+     * Get filtered row count
+     */
+    getFilteredCount(): number;
+    /**
+     * Apply column filter
+     */
+    applyColumnFilter(columnKey: string, filterValue: string | number): void;
+    /**
+     * Clear specific column filter
+     */
+    clearColumnFilter(columnKey: string): void;
+    /**
+     * Clear all column filters
+     */
+    clearAllColumnFilters(): void;
+    /**
+     * Toggle filter dropdown for a column
+     */
+    toggleColumnFilterDropdown(columnKey: string | null): void;
+    /**
+     * Filter rows based on active column filters and global search
+     */
+    private filterRows;
+}
+//# sourceMappingURL=filter.controller.d.ts.map

package/dist/src/components/table/controllers/filter.controller.js

@@ -0,0 +1,152 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseTableController } from './base.controller.js';
+/**
+ * Filter controller manages search/filter logic
+ */
+export class TableFilterController extends BaseTableController {
+    /**
+     * Handle search/filter input
+     */
+    handleSearch(searchValue) {
+        try {
+            if (searchValue.trim().length > 0) {
+                this.host.activeSearch = true;
+                this.host.rowsCopy = this.host.rows.filter((rowValue) => {
+                    return Object.values(rowValue).some((attributeValue) => {
+                        const stringValue = JSON.stringify(attributeValue);
+                        return stringValue.includes(searchValue);
+                    });
+                });
+                this.dispatchEvent(new CustomEvent('onSearch', {
+                    bubbles: true,
+                    composed: true,
+                    detail: { value: this.host.rowsCopy }
+                }));
+            }
+            else {
+                this.clearSearch();
+            }
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'handleSearch');
+        }
+    }
+    /**
+     * Clear search/filter
+     */
+    clearSearch() {
+        try {
+            this.host.activeSearch = false;
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'clearSearch');
+        }
+    }
+    /**
+     * Check if search is active
+     */
+    isSearchActive() {
+        return this.host.activeSearch;
+    }
+    /**
+     * Get filtered row count
+     */
+    getFilteredCount() {
+        return this.host.rowsCopy.length;
+    }
+    /**
+     * Apply column filter
+     */
+    applyColumnFilter(columnKey, filterValue) {
+        try {
+            if (filterValue === '' || filterValue === null || filterValue === undefined) {
+                this.host.columnFilters.delete(columnKey);
+            }
+            else {
+                this.host.columnFilters.set(columnKey, filterValue);
+            }
+            this.filterRows();
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'applyColumnFilter');
+        }
+    }
+    /**
+     * Clear specific column filter
+     */
+    clearColumnFilter(columnKey) {
+        try {
+            this.host.columnFilters.delete(columnKey);
+            this.filterRows();
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'clearColumnFilter');
+        }
+    }
+    /**
+     * Clear all column filters
+     */
+    clearAllColumnFilters() {
+        try {
+            this.host.columnFilters.clear();
+            this.filterRows();
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'clearAllColumnFilters');
+        }
+    }
+    /**
+     * Toggle filter dropdown for a column
+     */
+    toggleColumnFilterDropdown(columnKey) {
+        try {
+            this.host.activeFilterColumn = this.host.activeFilterColumn === columnKey ? null : columnKey;
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'toggleColumnFilterDropdown');
+        }
+    }
+    /**
+     * Filter rows based on active column filters and global search
+     */
+    filterRows() {
+        var _a;
+        let filteredRows = [...this.host.rows];
+        // Apply column filters
+        if (this.host.columnFilters.size > 0) {
+            filteredRows = filteredRows.filter((row) => {
+                return Array.from(this.host.columnFilters.entries()).every(([columnKey, filterValue]) => {
+                    const cellValue = row[columnKey];
+                    if (cellValue === null || cellValue === undefined) {
+                        return false;
+                    }
+                    const cellString = String(cellValue).toLowerCase();
+                    const filterString = String(filterValue).toLowerCase();
+                    return cellString.includes(filterString);
+                });
+            });
+        }
+        // Apply global search if active
+        if (this.host.activeSearch && this.host.filterValue) {
+            filteredRows = filteredRows.filter((row) => {
+                return Object.values(row).some((value) => {
+                    const stringValue = JSON.stringify(value).toLowerCase();
+                    return stringValue.includes(this.host.filterValue.toLowerCase());
+                });
+            });
+        }
+        this.host.rowsCopy = filteredRows;
+        this.host.activeSearch = this.host.columnFilters.size > 0 || (((_a = this.host.filterValue) === null || _a === void 0 ? void 0 : _a.length) > 0);
+    }
+}
+//# sourceMappingURL=filter.controller.js.map

package/dist/src/components/table/controllers/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+export { BaseTableController } from './base.controller.js';
+export { TableSelectionController } from './selection.controller.js';
+export { TablePaginationController } from './pagination.controller.js';
+export { TableSortController } from './sort.controller.js';
+export { TableFilterController } from './filter.controller.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/table/controllers/index.js

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+export { BaseTableController } from './base.controller.js';
+export { TableSelectionController } from './selection.controller.js';
+export { TablePaginationController } from './pagination.controller.js';
+export { TableSortController } from './sort.controller.js';
+export { TableFilterController } from './filter.controller.js';
+//# sourceMappingURL=index.js.map

package/dist/src/components/table/controllers/pagination.controller.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseTableController } from './base.controller.js';
+/**
+ * Pagination controller manages page state and navigation
+ */
+export declare class TablePaginationController extends BaseTableController {
+    /**
+     * Initialize or reset pagination state
+     */
+    initPagination(): void;
+    /**
+     * Handle items per page change event
+     */
+    handleItemPerPageChange(selectedItemPerPage: number): void;
+    /**
+     * Handle page navigation event
+     */
+    handlePageChange(page: number): void;
+    /**
+     * Get total number of pages
+     */
+    getTotalPages(): number;
+    /**
+     * Check if next page is available
+     */
+    hasNextPage(): boolean;
+    /**
+     * Check if previous page is available
+     */
+    hasPreviousPage(): boolean;
+}
+//# sourceMappingURL=pagination.controller.d.ts.map

package/dist/src/components/table/controllers/pagination.controller.js

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseTableController } from './base.controller.js';
+/**
+ * Pagination controller manages page state and navigation
+ */
+export class TablePaginationController extends BaseTableController {
+    /**
+     * Initialize or reset pagination state
+     */
+    initPagination() {
+        try {
+            if (this.host.serverSide) {
+                // Server-side: displayedRows is set directly from rows
+                this.host.displayedRows = [...this.host.rows];
+                this.host.currentPage = this.host.rows.length > 0 ? 1 : 0;
+            }
+            else {
+                // Client-side: slice from rowsCopy
+                this.host.displayedRows = this.host.rowsCopy.slice(0, this.host.selectedItemPerPage);
+                this.host.currentPage = this.host.rowsCopy.length > 0 ? 1 : 0;
+            }
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'initPagination');
+        }
+    }
+    /**
+     * Handle items per page change event
+     */
+    handleItemPerPageChange(selectedItemPerPage) {
+        try {
+            this.host.selectedItemPerPage = selectedItemPerPage;
+            this.host.currentPage = 1; // Reset to first page
+            if (this.host.serverSide) {
+                // Emit event for server-side consumers to refetch
+                this.dispatchEvent(new CustomEvent('onPaginate', {
+                    bubbles: true,
+                    composed: true,
+                    detail: {
+                        page: 1,
+                        limit: selectedItemPerPage,
+                        offset: 0
+                    }
+                }));
+                this.requestUpdate();
+            }
+            else {
+                this.initPagination();
+            }
+        }
+        catch (error) {
+            this.handleError(error, 'handleItemPerPageChange');
+        }
+    }
+    /**
+     * Handle page navigation event
+     */
+    handlePageChange(page) {
+        try {
+            this.host.currentPage = page;
+            const startIndex = (page - 1) * this.host.selectedItemPerPage;
+            const endIndex = startIndex + this.host.selectedItemPerPage;
+            // Only slice client-side when not in server-side mode
+            if (!this.host.serverSide) {
+                this.host.displayedRows = this.host.rowsCopy.slice(startIndex, endIndex);
+            }
+            // Emit enhanced event with pagination info for server-side consumers
+            this.dispatchEvent(new CustomEvent('onPaginate', {
+                bubbles: true,
+                composed: true,
+                detail: {
+                    page: this.host.currentPage,
+                    limit: this.host.selectedItemPerPage,
+                    offset: startIndex
+                }
+            }));
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'handlePageChange');
+        }
+    }
+    /**
+     * Get total number of pages
+     */
+    getTotalPages() {
+        const total = this.host.serverSide
+            ? this.host.totalCount
+            : this.host.rowsCopy.length;
+        return Math.ceil(total / this.host.selectedItemPerPage);
+    }
+    /**
+     * Check if next page is available
+     */
+    hasNextPage() {
+        return this.host.currentPage < this.getTotalPages();
+    }
+    /**
+     * Check if previous page is available
+     */
+    hasPreviousPage() {
+        return this.host.currentPage > 1;
+    }
+}
+//# sourceMappingURL=pagination.controller.js.map

package/dist/src/components/table/controllers/selection.controller.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseTableController } from './base.controller.js';
+/**
+ * Selection controller manages row selection state and logic
+ */
+export declare class TableSelectionController extends BaseTableController {
+    /**
+     * Initialize selection state array based on rows length
+     */
+    initSelection(): void;
+    /**
+     * Handle check all rows event (only for current page)
+     */
+    handleCheckAll(isEveryItemChecked: boolean): void;
+    /**
+     * Handle check single row event
+     */
+    handleCheckOne(index: number, value: boolean): void;
+    /**
+     * Handle select single row event (radio button mode)
+     */
+    handleSelectOne(index: number): void;
+    /**
+     * Handle cancel selection action
+     */
+    cancelSelection(): void;
+    /**
+     * Check if any items are selected
+     */
+    hasSelection(): boolean;
+    /**
+     * Get count of selected items
+     */
+    getSelectedCount(): number;
+}
+//# sourceMappingURL=selection.controller.d.ts.map

package/dist/src/components/table/controllers/selection.controller.js

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseTableController } from './base.controller.js';
+/**
+ * Selection controller manages row selection state and logic
+ */
+export class TableSelectionController extends BaseTableController {
+    /**
+     * Initialize selection state array based on rows length
+     */
+    initSelection() {
+        if (this.host.selectionMode) {
+            this.host.selectedItems = new Array(this.host.rows.length).fill(false);
+        }
+    }
+    /**
+     * Handle check all rows event (only for current page)
+     */
+    handleCheckAll(isEveryItemChecked) {
+        try {
+            // Calculate the range for current page
+            const startIndex = (this.host.currentPage - 1) * this.host.selectedItemPerPage;
+            const endIndex = Math.min(startIndex + this.host.selectedItemPerPage, this.host.selectedItems.length);
+            // Create a copy of the selection array
+            const newSelection = [...this.host.selectedItems];
+            // Toggle only the items on the current page
+            for (let i = startIndex; i < endIndex; i++) {
+                newSelection[i] = !isEveryItemChecked;
+            }
+            this.host.selectedItems = newSelection;
+            const selectedRows = this.host.rowsCopy.filter((_, i) => this.host.selectedItems[i]);
+            this.dispatchEvent(new CustomEvent('onSelect', {
+                bubbles: true,
+                composed: true,
+                detail: { value: selectedRows }
+            }));
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'handleCheckAll');
+        }
+    }
+    /**
+     * Handle check single row event
+     */
+    handleCheckOne(index, value) {
+        try {
+            const actualIndex = index + (this.host.currentPage - 1) * this.host.selectedItemPerPage;
+            this.host.selectedItems[actualIndex] = value;
+            this.host.selectedItems = [...this.host.selectedItems];
+            const selectedRows = this.host.rowsCopy.filter((_, i) => this.host.selectedItems[i]);
+            this.dispatchEvent(new CustomEvent('nr-select', {
+                bubbles: true,
+                composed: true,
+                detail: { value: selectedRows }
+            }));
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'handleCheckOne');
+        }
+    }
+    /**
+     * Handle select single row event (radio button mode)
+     */
+    handleSelectOne(index) {
+        try {
+            const previousSelected = this.host.selectedItems.findIndex((isSelected) => isSelected);
+            if (previousSelected > -1) {
+                this.host.selectedItems[previousSelected] = false;
+            }
+            const actualIndex = index + (this.host.currentPage - 1) * this.host.selectedItemPerPage;
+            this.host.selectedItems[actualIndex] = true;
+            this.host.selectedItems = [...this.host.selectedItems];
+            const selectedRows = this.host.rowsCopy.filter((_, i) => this.host.selectedItems[i]);
+            this.dispatchEvent(new CustomEvent('nr-select', {
+                bubbles: true,
+                composed: true,
+                detail: { value: selectedRows }
+            }));
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'handleSelectOne');
+        }
+    }
+    /**
+     * Handle cancel selection action
+     */
+    cancelSelection() {
+        try {
+            this.host.selectedItems = this.host.selectedItems.map(() => false);
+            this.dispatchEvent(new CustomEvent('nr-select', {
+                bubbles: true,
+                composed: true,
+                detail: { value: [] }
+            }));
+            this.requestUpdate();
+        }
+        catch (error) {
+            this.handleError(error, 'cancelSelection');
+        }
+    }
+    /**
+     * Check if any items are selected
+     */
+    hasSelection() {
+        return this.host.selectedItems.some((isSelected) => isSelected);
+    }
+    /**
+     * Get count of selected items
+     */
+    getSelectedCount() {
+        return this.host.selectedItems.filter((isSelected) => isSelected).length;
+    }
+}
+//# sourceMappingURL=selection.controller.js.map

package/dist/src/components/table/controllers/sort.controller.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+import { BaseTableController } from './base.controller.js';
+/**
+ * Sort controller manages column sorting logic
+ */
+export declare class TableSortController extends BaseTableController {
+    /**
+     * Handle column sort order change
+     */
+    handleSortOrderChange(index: number): void;
+    /**
+     * Sort rows based on current sort attribute
+     */
+    sort(): void;
+    /**
+     * Reset sort to original row order
+     */
+    resetSort(): void;
+    /**
+     * Check if sorting is active
+     */
+    isSortActive(): boolean;
+    /**
+     * Check if sort order is default
+     */
+    isSortDefault(): boolean;
+}
+//# sourceMappingURL=sort.controller.d.ts.map