@aquera/ngx-smart-table 0.0.2-alpha

package/lib/renderer/components/st-column-filter/st-column-filter.component.d.ts

@@ -0,0 +1,139 @@
+import { EventEmitter, OnInit, ElementRef, AfterViewInit, OnChanges, SimpleChanges } from '@angular/core';
+import { ColumnConfig } from '../../../models/column-config.interface';
+import { TableState } from '../../models/table-state.class';
+import { FilterOperator } from '../../models/table-types';
+import * as i0 from "@angular/core";
+/**
+ * Filter context for the popover component
+ */
+export interface FilterContext {
+    column: ColumnConfig<any>;
+    tableState?: TableState;
+    columnIndex: number;
+    isFirstColumn: boolean;
+    isLastColumn: boolean;
+}
+/**
+ * Filter popup component for per-column filtering
+ * Uses Nile components for consistent UI
+ * Designed as a shared component with context input
+ */
+export declare class StColumnFilterComponent implements OnInit, AfterViewInit, OnChanges {
+    filterAnchor?: ElementRef<HTMLElement>;
+    column: ColumnConfig<any>;
+    tableState?: TableState;
+    columnIndex: number;
+    isFirstColumn: boolean;
+    isLastColumn: boolean;
+    set isOpen(value: boolean);
+    get isOpen(): boolean;
+    private _isOpen;
+    closed: EventEmitter<void>;
+    filterApplied: EventEmitter<{
+        operator: FilterOperator;
+        value: any;
+    }>;
+    filterCleared: EventEmitter<void>;
+    selectedOperator: FilterOperator;
+    filterValue: any;
+    selectedValues: any[];
+    availableOperators: {
+        value: FilterOperator;
+        label: string;
+    }[];
+    inputType: 'text' | 'number' | 'date' | 'checkbox' | 'select' | 'multiselect';
+    dropdownOptions: {
+        label: string;
+        value: any;
+    }[];
+    /**
+     * Get filter context for external use
+     */
+    get context(): FilterContext;
+    /**
+     * Set filter context (allows using component as context-driven)
+     */
+    set filterContext(context: FilterContext | null);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Initialize filter state from column config
+     */
+    private initializeFilterState;
+    /**
+     * Determine which input type to render based on priority
+     */
+    private determineInputType;
+    /**
+     * Check if column has valid filter options configuration
+     */
+    private hasValidFilterOptions;
+    /**
+     * Process dropdown options using the handler
+     */
+    private processDropdownOptions;
+    /**
+     * Set available operators based on input type
+     */
+    private setAvailableOperators;
+    /**
+     * Open the filter popup
+     */
+    open(): void;
+    /**
+     * Close the filter popup
+     */
+    close(): void;
+    /**
+     * Handle popover hide event from nile-popover
+     */
+    onPopoverHide(): void;
+    /**
+     * Handle operator change from nile-select
+     */
+    onOperatorChange(event: Event): void;
+    /**
+     * Handle value input from nile-input
+     */
+    onValueInput(event: Event): void;
+    /**
+     * Handle checkbox change from nile-checkbox
+     */
+    onCheckboxChange(event: Event): void;
+    /**
+     * Handle select change from nile-select
+     */
+    onSelectChange(event: Event): void;
+    /**
+     * Handle multiselect checkbox change
+     */
+    onMultiselectCheckboxChange(event: Event, value: any): void;
+    /**
+     * Apply the filter
+     */
+    onApply(): void;
+    /**
+     * Clear the filter
+     */
+    onClear(): void;
+    /**
+     * Handle multiselect change (kept for backward compatibility)
+     * @deprecated Use onMultiselectCheckboxChange instead
+     */
+    onMultiselectChange(value: any, event: Event): void;
+    /**
+     * Check if a value is selected in multiselect
+     */
+    isValueSelected(value: any): boolean;
+    /**
+     * Get column display name
+     */
+    getColumnName(): string;
+    /**
+     * Determine if filter should align to the left (for first few columns)
+     */
+    shouldAlignLeft(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StColumnFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StColumnFilterComponent, "st-column-filter", never, { "column": "column"; "tableState": "tableState"; "columnIndex": "columnIndex"; "isFirstColumn": "isFirstColumn"; "isLastColumn": "isLastColumn"; "isOpen": "isOpen"; "filterContext": "filterContext"; }, { "closed": "closed"; "filterApplied": "filterApplied"; "filterCleared": "filterCleared"; }, never, never>;
+}

package/lib/renderer/components/st-column-menu/st-column-menu.component.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ColumnAction, ColumnActionContext, ColumnActionEvent } from '../../../models/column-action.interface';
+import { StColumnFilterComponent } from '../st-column-filter/st-column-filter.component';
+import * as i0 from "@angular/core";
+export declare class StColumnMenuDropdownComponent implements OnChanges {
+    /**
+     * Whether the dropdown is open
+     */
+    isOpen: boolean;
+    /**
+     * Position of the dropdown (x, y coordinates)
+     */
+    position: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Context containing column data, index, and actions
+     */
+    context: ColumnActionContext | null;
+    /**
+     * Emitted when an action is clicked
+     */
+    actionClicked: EventEmitter<ColumnActionEvent>;
+    /**
+     * Emitted when the dropdown should close
+     */
+    closed: EventEmitter<void>;
+    filterPopup?: StColumnFilterComponent;
+    /**
+     * Visible actions (filtered by hidden property)
+     */
+    visibleActions: ColumnAction[];
+    /**
+     * Dropdown positioning style
+     */
+    dropdownStyle: any;
+    isFilterOpen: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Update visible actions based on hidden property
+     */
+    private updateVisibleActions;
+    /**
+     * Check if an action is currently active (for checkmarks)
+     */
+    isActionActive(action: ColumnAction): boolean;
+    /**
+     * Determine if divider should be shown after an action
+     * Groups built-in actions: [sort group] | [filter] | [pin group] | [move group] | [custom]
+     */
+    shouldShowDividerAfter(action: ColumnAction, index: number, isLast: boolean): boolean;
+    /**
+     * Update dropdown position based on available viewport space
+     */
+    private updateDropdownPosition;
+    /**
+     * Check if an action is disabled
+     */
+    isActionDisabled(action: ColumnAction): boolean;
+    /**
+     * Handle action click
+     */
+    onActionClick(action: ColumnAction): void;
+    /**
+     * Close dropdown when clicking backdrop
+     */
+    onBackdropClick(event: MouseEvent): void;
+    onFilterClosed(): void;
+    onFilterApplied(event: {
+        operator: any;
+        value: any;
+    }): void;
+    onFilterCleared(): void;
+    /**
+     * Determine if menu should align to the left (for first few columns)
+     */
+    shouldAlignLeft(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StColumnMenuDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StColumnMenuDropdownComponent, "st-column-menu-dropdown", never, { "isOpen": "isOpen"; "position": "position"; "context": "context"; }, { "actionClicked": "actionClicked"; "closed": "closed"; }, never, never>;
+}

package/lib/renderer/components/st-column-visibility/st-column-visibility.component.d.ts

@@ -0,0 +1,44 @@
+import { OnInit, OnChanges, SimpleChanges, OnDestroy } from '@angular/core';
+import { TableState } from '../../models/table-state.class';
+import * as i0 from "@angular/core";
+export declare class StColumnVisibilityComponent implements OnInit, OnChanges, OnDestroy {
+    tableState: TableState;
+    isOpen: boolean;
+    columnsVisibility: {
+        key: string;
+        header: string;
+        visible: boolean;
+        hideable: boolean;
+    }[];
+    private stateSubscription?;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Update columns visibility list from current table state
+     */
+    private updateColumnsVisibility;
+    /**
+     * Subscribe to table state changes
+     */
+    private subscribeToStateChanges;
+    ngOnDestroy(): void;
+    toggleMenu(event: Event): void;
+    closeMenu(): void;
+    getColumnsVisibility(): {
+        key: string;
+        header: string;
+        visible: boolean;
+        hideable: boolean;
+    }[];
+    isColumnHideable(column: {
+        key: string;
+        header: string;
+        visible: boolean;
+        hideable: boolean;
+    }): boolean;
+    onToggleColumn(columnKey: string, event: Event): void;
+    isColumnVisible(columnKey: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StColumnVisibilityComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StColumnVisibilityComponent, "st-column-visibility", never, { "tableState": "tableState"; }, {}, never, never>;
+}

package/lib/renderer/components/st-header/st-header.component.d.ts

@@ -0,0 +1,93 @@
+/**
+ * st-header Component
+ * Encapsulates column-specific logic including sorting and filtering
+ */
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { ColumnConfig } from '../../../models/column-config.interface';
+import { TableState } from '../../models/table-state.class';
+import { SortDirection, ColumnSortEvent, ColumnFilterEvent, ColumnMoveEvent } from '../../models/table-types';
+import * as i0 from "@angular/core";
+export declare class StHeaderComponent implements OnDestroy {
+    /**
+     * Column configuration - contains all column metadata and state
+     */
+    column: ColumnConfig<any>;
+    /**
+     * Column index in the visible columns array
+     */
+    columnIndex: number;
+    /**
+     * Whether this is the first column
+     */
+    isFirstColumn: boolean;
+    /**
+     * Whether this is the last column
+     */
+    isLastColumn: boolean;
+    /**
+     * Optional TableState reference for integrated sorting/filtering
+     */
+    tableState?: TableState;
+    /**
+     * Whether sorting is enabled globally
+     */
+    enableSorting: boolean;
+    /**
+     * Whether filtering is enabled globally
+     */
+    enableFiltering: boolean;
+    /**
+     * Emits column sort event when sort is toggled
+     */
+    sortToggle: EventEmitter<ColumnSortEvent>;
+    /**
+     * Emits filter changes (future feature)
+     */
+    filterChange: EventEmitter<ColumnFilterEvent>;
+    /**
+     * Emits when column is moved left or right
+     */
+    columnMoved: EventEmitter<ColumnMoveEvent>;
+    /**
+     * Emits when column menu button is clicked
+     */
+    menuClick: EventEmitter<MouseEvent>;
+    /**
+     * Cleanup on destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handle column menu button click
+     */
+    onMenuClick(event: MouseEvent): void;
+    /**
+     * Check if column menu should be shown
+     */
+    isMenuEnabled(): boolean;
+    /**
+     * Check if column is sortable
+     */
+    isSortable(): boolean;
+    /**
+     * Get current sort direction
+     */
+    getSortDirection(): SortDirection;
+    /**
+     * Check if column is currently sorted
+     */
+    isSorted(): boolean;
+    /**
+     * Get ARIA sort attribute for accessibility
+     */
+    getAriaSort(): string | null;
+    /**
+     * Handle move left action
+     */
+    onMoveLeft(): void;
+    /**
+     * Handle move right action
+     */
+    onMoveRight(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StHeaderComponent, "st-header", never, { "column": "column"; "columnIndex": "columnIndex"; "isFirstColumn": "isFirstColumn"; "isLastColumn": "isLastColumn"; "tableState": "tableState"; "enableSorting": "enableSorting"; "enableFiltering": "enableFiltering"; }, { "sortToggle": "sortToggle"; "filterChange": "filterChange"; "columnMoved": "columnMoved"; "menuClick": "menuClick"; }, never, never>;
+}

package/lib/renderer/components/st-pagination/st-pagination.component.d.ts

@@ -0,0 +1,42 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { TableState } from '../../models/table-state.class';
+import { TableConfig } from '../../../models/table-config.interface';
+import { PaginationState } from '../../models/table-types';
+import * as i0 from "@angular/core";
+/**
+ * Pagination component that wraps nile-pagination web component
+ * Handles conversion between internal 0-indexed pages and nile-pagination's 1-indexed pages
+ */
+export declare class StPaginationComponent implements OnInit, OnDestroy {
+    tableState: TableState;
+    tableConfig: TableConfig;
+    position: 'top' | 'bottom';
+    paginationState: PaginationState;
+    private paginationSubscription?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Get current page display (1-indexed for nile-pagination)
+     */
+    getCurrentPageDisplay(): number;
+    /**
+     * Get variant from config
+     */
+    getVariant(): string;
+    /**
+     * Get page size options array for nile-pagination
+     */
+    getPageSizeOptions(): number[];
+    /**
+     * Handle page change from nile-pagination
+     * @param event Custom event from nile-pagination with 1-indexed page number
+     */
+    onPageChange(event: any): void;
+    /**
+     * Handle page size change from nile-pagination
+     * @param event Custom event from nile-pagination with new page size
+     */
+    onPageSizeChange(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StPaginationComponent, "st-pagination", never, { "tableState": "tableState"; "tableConfig": "tableConfig"; "position": "position"; }, {}, never, never>;
+}

package/lib/renderer/components/st-row-actions-dropdown/st-row-actions-dropdown.component.d.ts

@@ -0,0 +1,67 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { RowAction, RowActionContext, RowActionEvent } from '../../../models/row-action.interface';
+import * as i0 from "@angular/core";
+export declare class StRowActionsDropdownComponent implements OnChanges {
+    /**
+     * Whether the dropdown is open
+     */
+    isOpen: boolean;
+    /**
+     * Position of the dropdown (x, y coordinates)
+     */
+    position: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Context containing row data, index, and actions
+     */
+    context: RowActionContext | null;
+    /**
+     * Emitted when an action is clicked
+     */
+    actionClicked: EventEmitter<RowActionEvent>;
+    /**
+     * Emitted when the dropdown should close
+     */
+    closed: EventEmitter<void>;
+    /**
+     * Visible actions (filtered by hidden property)
+     */
+    visibleActions: RowAction[];
+    /**
+     * Dropdown positioning style
+     */
+    dropdownStyle: any;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Update visible actions based on hidden property
+     */
+    private updateVisibleActions;
+    /**
+     * Update dropdown position based on available viewport space
+     */
+    private updateDropdownPosition;
+    /**
+     * Handle action click
+     */
+    onActionClick(action: RowAction): void;
+    /**
+     * Check if an action is disabled
+     */
+    isActionDisabled(action: RowAction): boolean;
+    /**
+     * Handle overlay click (close dropdown)
+     */
+    onOverlayClick(): void;
+    /**
+     * Handle ESC key press
+     */
+    onEscapeKey(event: Event): void;
+    /**
+     * Prevent dropdown click from closing
+     */
+    onDropdownClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StRowActionsDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StRowActionsDropdownComponent, "st-row-actions-dropdown", never, { "isOpen": "isOpen"; "position": "position"; "context": "context"; }, { "actionClicked": "actionClicked"; "closed": "closed"; }, never, never>;
+}

package/lib/renderer/components/st-sheet/st-sheet.component.d.ts

@@ -0,0 +1,98 @@
+import { EventEmitter, OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { SheetConfig } from '../../../models/sheet-config.interface';
+import { SheetAction, SheetActionEvent } from '../../../models/sheet-action.interface';
+import { SheetState } from '../../models/sheet-state.class';
+import { SheetStateSnapshot } from '../../models/sheet-state.interface';
+import { CellChangeEvent } from '../../../models/cell-types';
+import { TableStateChangeEvent, DataChangeEvent } from '../../models/table-types';
+import * as i0 from "@angular/core";
+export declare class StSheetComponent implements OnInit, OnChanges {
+    /**
+     * Sheet configuration
+     */
+    config: SheetConfig;
+    /**
+     * Table data (sync)
+     */
+    data: any[];
+    /**
+     * Table data (async) - Observable or BehaviorSubject
+     */
+    data$?: Observable<any[]> | BehaviorSubject<any[]>;
+    /**
+     * Optional external state management
+     * If not provided, component will create its own state
+     */
+    state?: SheetState;
+    /**
+     * Emitted when sheet action is clicked
+     */
+    sheetActionClicked: EventEmitter<SheetActionEvent>;
+    /**
+     * Emitted when sheet state changes
+     */
+    stateChange: EventEmitter<SheetStateSnapshot>;
+    /**
+     * Emitted when a cell value changes
+     */
+    cellChange: EventEmitter<CellChangeEvent<any>>;
+    /**
+     * Emitted when table state changes (pagination, sorting, filtering)
+     */
+    tableStateChange: EventEmitter<TableStateChangeEvent>;
+    /**
+     * Emitted when data changes (via Observable)
+     */
+    dataChange: EventEmitter<DataChangeEvent>;
+    /**
+     * Internal state instance
+     */
+    internalState?: SheetState;
+    /**
+     * Visible actions (filtered by hidden property)
+     */
+    visibleActions: SheetAction[];
+    activeTab: string;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Initialize sheet state
+     */
+    private initializeState;
+    /**
+     * Get active state (external or internal)
+     */
+    get activeState(): SheetState | undefined;
+    /**
+     * Handle sheet action click
+     */
+    onActionClick(event: SheetActionEvent): void;
+    /**
+     * Handle cell value change from table
+     */
+    onCellChange(event: CellChangeEvent): void;
+    /**
+     * Handle table state change (pagination, sorting, filtering)
+     */
+    onTableStateChange(event: TableStateChangeEvent): void;
+    /**
+     * Handle data change from table (via Observable)
+     */
+    onDataChange(event: DataChangeEvent): void;
+    /**
+     * Update visible actions based on hidden property
+     */
+    private updateVisibleActions;
+    /**
+     * Check if header should be shown
+     */
+    get showHeader(): boolean;
+    /**
+     * Get header variant class
+     */
+    get headerVariant(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StSheetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StSheetComponent, "st-sheet", never, { "config": "config"; "data": "data"; "data$": "data$"; "state": "state"; }, { "sheetActionClicked": "sheetActionClicked"; "stateChange": "stateChange"; "cellChange": "cellChange"; "tableStateChange": "tableStateChange"; "dataChange": "dataChange"; }, never, never>;
+}

package/lib/renderer/components/st-sheet-actions/st-sheet-actions.component.d.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from '@angular/core';
+import { SheetAction, SheetActionEvent } from '../../../models/sheet-action.interface';
+import * as i0 from "@angular/core";
+export declare class StSheetActionsComponent {
+    /**
+     * Array of sheet actions
+     */
+    actions: SheetAction[];
+    /**
+     * Sheet ID for context
+     */
+    sheetId: string;
+    /**
+     * Emitted when an action is clicked
+     */
+    actionClicked: EventEmitter<SheetActionEvent>;
+    /**
+     * Whether the dropdown is open
+     */
+    isOpen: boolean;
+    /**
+     * Visible actions (filtered by hidden property)
+     */
+    visibleActions: SheetAction[];
+    /**
+     * Dropdown positioning style
+     */
+    dropdownStyle: any;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    /**
+     * Toggle dropdown menu
+     */
+    toggleMenu(event: MouseEvent): void;
+    /**
+     * Close dropdown menu
+     */
+    closeMenu(): void;
+    /**
+     * Handle action click
+     */
+    onActionClick(action: SheetAction, event: Event): void;
+    /**
+     * Check if action is disabled
+     */
+    isActionDisabled(action: SheetAction): boolean;
+    /**
+     * Update visible actions based on hidden property
+     */
+    private updateVisibleActions;
+    /**
+     * Update dropdown position based on trigger button
+     */
+    private updateDropdownPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StSheetActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StSheetActionsComponent, "st-sheet-actions", never, { "actions": "actions"; "sheetId": "sheetId"; }, { "actionClicked": "actionClicked"; }, never, never>;
+}