@nuraly/lumenui 0.2.1 → 0.3.2

package/dist/src/components/select/interfaces/controller-interfaces.d.ts

@@ -0,0 +1,94 @@
+import { SelectOption } from './base-controller.interface.js';
+/**
+ * Selection controller specific interfaces
+ */
+export interface SelectionControllerInterface {
+    selectedOptions: SelectOption[];
+    selectedValues: string[];
+    hasSelection: boolean;
+    canSelectMultiple: boolean;
+}
+/**
+ * Dropdown controller specific interfaces
+ */
+export interface DropdownControllerInterface {
+    isOpen: boolean;
+    position: DropdownPosition;
+    availableSpace: DropdownSpace;
+}
+/**
+ * Focus controller specific interfaces
+ */
+export interface FocusControllerInterface {
+    focusedIndex: number;
+    focusedOption: SelectOption | undefined;
+    hasFocus: boolean;
+}
+/**
+ * Validation controller specific interfaces
+ */
+export interface ValidationControllerInterface {
+    isValid: boolean;
+    validationMessage: string;
+    validationState: ValidationState;
+    hasValidation: boolean;
+}
+/**
+ * Search controller specific interfaces
+ */
+export interface SearchControllerInterface {
+    searchQuery: string;
+    filteredOptions: SelectOption[];
+    hasActiveSearch: boolean;
+    matchedCount: number;
+}
+/**
+ * Dropdown positioning types
+ */
+export interface DropdownPosition {
+    top: number;
+    left: number;
+    width: number;
+    placement: 'bottom' | 'top';
+}
+/**
+ * Available space calculation
+ */
+export interface DropdownSpace {
+    above: number;
+    below: number;
+    left: number;
+    right: number;
+}
+/**
+ * Validation state enum
+ */
+export declare enum ValidationState {
+    Valid = "valid",
+    Invalid = "invalid",
+    Pending = "pending",
+    Pristine = "pristine"
+}
+/**
+ * Event data interfaces
+ */
+export interface SelectChangeEventDetail {
+    value: string | string[];
+    selectedOptions: SelectOption[];
+    previousValue?: string | string[];
+}
+export interface SelectFocusEventDetail {
+    focusedOption: SelectOption;
+    focusedIndex: number;
+}
+export interface SelectSearchEventDetail {
+    query: string;
+    filteredOptions: SelectOption[];
+    matchCount: number;
+}
+export interface SelectValidationEventDetail {
+    isValid: boolean;
+    validationMessage: string;
+    validationState: ValidationState;
+}
+//# sourceMappingURL=controller-interfaces.d.ts.map

package/dist/src/components/select/interfaces/controller-interfaces.js

@@ -0,0 +1,11 @@
+/**
+ * Validation state enum
+ */
+export var ValidationState;
+(function (ValidationState) {
+    ValidationState["Valid"] = "valid";
+    ValidationState["Invalid"] = "invalid";
+    ValidationState["Pending"] = "pending";
+    ValidationState["Pristine"] = "pristine";
+})(ValidationState || (ValidationState = {}));
+//# sourceMappingURL=controller-interfaces.js.map

package/dist/src/components/select/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-controller.interface.js';
+export * from './controller-interfaces.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/select/interfaces/index.js

@@ -0,0 +1,3 @@
+export * from './base-controller.interface.js';
+export * from './controller-interfaces.js';
+//# sourceMappingURL=index.js.map

package/dist/src/components/slider-input/utils/debounce.d.ts

@@ -0,0 +1,2 @@
+export declare function debounce(func: Function, wait?: number): (this: any, ...args: any[]) => void;
+//# sourceMappingURL=debounce.d.ts.map

package/dist/src/components/slider-input/utils/debounce.js

@@ -0,0 +1,8 @@
+export function debounce(func, wait = 100) {
+    let timeout;
+    return function (...args) {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func.apply(this, args), wait);
+    };
+}
+//# sourceMappingURL=debounce.js.map

package/dist/src/components/slider-input/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './debounce.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/components/slider-input/utils/index.js

@@ -0,0 +1,2 @@
+export * from './debounce.js';
+//# sourceMappingURL=index.js.map

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