@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/renderer/components/st-pagination/st-pagination.component.mjs

@@ -0,0 +1,87 @@
+import { Component, Input } from '@angular/core';
+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 class StPaginationComponent {
+    constructor() {
+        this.position = 'bottom';
+        this.paginationState = {
+            currentPage: 0,
+            pageSize: 25,
+            totalItems: 0,
+            totalPages: 0
+        };
+    }
+    ngOnInit() {
+        if (!this.tableState) {
+            throw new Error('tableState is required for st-pagination component');
+        }
+        if (!this.tableConfig) {
+            throw new Error('tableConfig is required for st-pagination component');
+        }
+        // Initialize with current state
+        this.paginationState = this.tableState.getPagination();
+        // Subscribe to pagination changes
+        this.paginationSubscription = this.tableState.paginationChange$
+            .subscribe(state => {
+            this.paginationState = state;
+        });
+    }
+    ngOnDestroy() {
+        this.paginationSubscription?.unsubscribe();
+    }
+    /**
+     * Get current page display (1-indexed for nile-pagination)
+     */
+    getCurrentPageDisplay() {
+        return this.paginationState.currentPage + 1;
+    }
+    /**
+     * Get variant from config
+     */
+    getVariant() {
+        return this.tableConfig.pagination?.variant || 'fluid';
+    }
+    /**
+     * Get page size options array for nile-pagination
+     */
+    getPageSizeOptions() {
+        return this.tableConfig.pagination?.pageSizeOptions || [10, 25, 50, 100];
+    }
+    /**
+     * Handle page change from nile-pagination
+     * @param event Custom event from nile-pagination with 1-indexed page number
+     */
+    onPageChange(event) {
+        const newPage = event.detail;
+        if (typeof newPage === 'number') {
+            // Convert from 1-indexed to 0-indexed
+            this.tableState.setPage(newPage - 1);
+        }
+    }
+    /**
+     * Handle page size change from nile-pagination
+     * @param event Custom event from nile-pagination with new page size
+     */
+    onPageSizeChange(event) {
+        const newPageSize = event.detail;
+        if (typeof newPageSize === 'number') {
+            this.tableState.setPageSize(newPageSize);
+        }
+    }
+}
+StPaginationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StPaginationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StPaginationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: StPaginationComponent, selector: "st-pagination", inputs: { tableState: "tableState", tableConfig: "tableConfig", position: "position" }, ngImport: i0, template: "<nile-pagination\n  [totalItems]=\"paginationState.totalItems\"\n  [currentPage]=\"getCurrentPageDisplay()\"\n  [pageSize]=\"paginationState.pageSize\"\n  [variant]=\"getVariant()\"\n  [pageSizeOptions]=\"getPageSizeOptions()\"\n  (pageChange)=\"onPageChange($event)\"\n  (pageSizeChange)=\"onPageSizeChange($event)\">\n</nile-pagination>\n", styles: [":host{display:block;width:100%}nile-pagination{display:block;width:100%}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StPaginationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'st-pagination', template: "<nile-pagination\n  [totalItems]=\"paginationState.totalItems\"\n  [currentPage]=\"getCurrentPageDisplay()\"\n  [pageSize]=\"paginationState.pageSize\"\n  [variant]=\"getVariant()\"\n  [pageSizeOptions]=\"getPageSizeOptions()\"\n  (pageChange)=\"onPageChange($event)\"\n  (pageSizeChange)=\"onPageSizeChange($event)\">\n</nile-pagination>\n", styles: [":host{display:block;width:100%}nile-pagination{display:block;width:100%}\n"] }]
+        }], propDecorators: { tableState: [{
+                type: Input
+            }], tableConfig: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/renderer/components/st-row-actions-dropdown/st-row-actions-dropdown.component.mjs

@@ -0,0 +1,167 @@
+import { Component, Input, Output, EventEmitter, HostListener, ChangeDetectionStrategy } from '@angular/core';
+import { TableZIndex } from '../../models/z-index.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class StRowActionsDropdownComponent {
+    constructor() {
+        /**
+         * Whether the dropdown is open
+         */
+        this.isOpen = false;
+        /**
+         * Position of the dropdown (x, y coordinates)
+         */
+        this.position = { x: 0, y: 0 };
+        /**
+         * Context containing row data, index, and actions
+         */
+        this.context = null;
+        /**
+         * Emitted when an action is clicked
+         */
+        this.actionClicked = new EventEmitter();
+        /**
+         * Emitted when the dropdown should close
+         */
+        this.closed = new EventEmitter();
+        /**
+         * Visible actions (filtered by hidden property)
+         */
+        this.visibleActions = [];
+        /**
+         * Dropdown positioning style
+         */
+        this.dropdownStyle = {};
+    }
+    ngOnChanges(changes) {
+        if (changes['context'] || changes['isOpen']) {
+            this.updateVisibleActions();
+        }
+        if (changes['position'] || changes['isOpen']) {
+            this.updateDropdownPosition();
+        }
+    }
+    /**
+     * Update visible actions based on hidden property
+     */
+    updateVisibleActions() {
+        if (!this.context) {
+            this.visibleActions = [];
+            return;
+        }
+        this.visibleActions = this.context.actions.filter(action => {
+            if (typeof action.hidden === 'function') {
+                return !action.hidden(this.context.rowData, this.context.rowIndex);
+            }
+            return !action.hidden;
+        });
+    }
+    /**
+     * Update dropdown position based on available viewport space
+     */
+    updateDropdownPosition() {
+        if (!this.isOpen) {
+            this.dropdownStyle = {};
+            return;
+        }
+        const DROPDOWN_WIDTH = 200; // Approximate width
+        const DROPDOWN_HEIGHT = this.visibleActions.length * 40 + 16; // Approximate height
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        let left = this.position.x;
+        let top = this.position.y;
+        // Check if dropdown would overflow right edge
+        if (left + DROPDOWN_WIDTH > viewportWidth) {
+            left = viewportWidth - DROPDOWN_WIDTH - 10;
+        }
+        // Check if dropdown would overflow bottom edge
+        if (top + DROPDOWN_HEIGHT > viewportHeight) {
+            // Position above the trigger
+            top = this.position.y - DROPDOWN_HEIGHT;
+        }
+        // Ensure dropdown doesn't go off-screen on the left
+        if (left < 10) {
+            left = 10;
+        }
+        // Ensure dropdown doesn't go off-screen on the top
+        if (top < 10) {
+            top = 10;
+        }
+        this.dropdownStyle = {
+            position: 'fixed',
+            left: `${left}px`,
+            top: `${top}px`,
+            zIndex: TableZIndex.ROW_ACTIONS_DROPDOWN
+        };
+    }
+    /**
+     * Handle action click
+     */
+    onActionClick(action) {
+        if (!this.context)
+            return;
+        // Check if action is disabled
+        if (this.isActionDisabled(action)) {
+            return;
+        }
+        const event = {
+            action,
+            rowData: this.context.rowData,
+            rowIndex: this.context.rowIndex
+        };
+        this.actionClicked.emit(event);
+    }
+    /**
+     * Check if an action is disabled
+     */
+    isActionDisabled(action) {
+        if (!this.context)
+            return true;
+        if (typeof action.disabled === 'function') {
+            return action.disabled(this.context.rowData, this.context.rowIndex);
+        }
+        return !!action.disabled;
+    }
+    /**
+     * Handle overlay click (close dropdown)
+     */
+    onOverlayClick() {
+        this.closed.emit();
+    }
+    /**
+     * Handle ESC key press
+     */
+    onEscapeKey(event) {
+        if (this.isOpen) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.closed.emit();
+        }
+    }
+    /**
+     * Prevent dropdown click from closing
+     */
+    onDropdownClick(event) {
+        event.stopPropagation();
+    }
+}
+StRowActionsDropdownComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StRowActionsDropdownComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StRowActionsDropdownComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: StRowActionsDropdownComponent, selector: "st-row-actions-dropdown", inputs: { isOpen: "isOpen", position: "position", context: "context" }, outputs: { actionClicked: "actionClicked", closed: "closed" }, host: { listeners: { "document:keydown.escape": "onEscapeKey($event)" } }, usesOnChanges: true, ngImport: i0, template: "<div class=\"dropdown-container\" *ngIf=\"isOpen && context\">\n  <!-- Backdrop -->\n  <div class=\"dropdown-overlay\" (click)=\"closed.emit()\"></div>\n  \n  <!-- Dropdown menu -->\n  <div class=\"dropdown-menu\" [ngStyle]=\"dropdownStyle\">\n    <nile-menu *ngIf=\"isOpen\" class=\"dropdown-menu\" [style.left.px]=\"dropdownStyle.left\" [style.top.px]=\"dropdownStyle.top\">\n      <ng-container *ngFor=\"let action of visibleActions\">\n        <nile-menu-item [class.disabled]=\"isActionDisabled(action)\" (click)=\"onActionClick(action)\" class=\"action-label\">\n          <nile-icon  *ngIf=\"action.icon\" size=\"14\" slot=\"prefix\" [name]=\"action.icon\"></nile-icon>\n          {{ action.label }}\n        </nile-menu-item>\n      </ng-container>\n    \n      <nile-menu-item *ngIf=\"visibleActions.length === 0\">No actions available</nile-menu-item>\n    </nile-menu>\n    </div>\n\n  </div>\n", styles: [".dropdown-container{position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:9998}.dropdown-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background-color:#0000004d;pointer-events:auto;z-index:9998}.dropdown-menu{position:fixed;background-color:#fff;box-shadow:0 5px 15px #0000004d,0 0 0 1px #0000001a;overflow:hidden;pointer-events:auto;z-index:9999}.action-icon{display:flex;align-items:center;justify-content:center;font-size:16px;width:20px;flex-shrink:0}.action-label{flex:1;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.dropdown-empty{padding:16px;text-align:center;color:#a0aec0;font-size:14px;font-style:italic}nile-menu{height:fit-content}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StRowActionsDropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'st-row-actions-dropdown', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"dropdown-container\" *ngIf=\"isOpen && context\">\n  <!-- Backdrop -->\n  <div class=\"dropdown-overlay\" (click)=\"closed.emit()\"></div>\n  \n  <!-- Dropdown menu -->\n  <div class=\"dropdown-menu\" [ngStyle]=\"dropdownStyle\">\n    <nile-menu *ngIf=\"isOpen\" class=\"dropdown-menu\" [style.left.px]=\"dropdownStyle.left\" [style.top.px]=\"dropdownStyle.top\">\n      <ng-container *ngFor=\"let action of visibleActions\">\n        <nile-menu-item [class.disabled]=\"isActionDisabled(action)\" (click)=\"onActionClick(action)\" class=\"action-label\">\n          <nile-icon  *ngIf=\"action.icon\" size=\"14\" slot=\"prefix\" [name]=\"action.icon\"></nile-icon>\n          {{ action.label }}\n        </nile-menu-item>\n      </ng-container>\n    \n      <nile-menu-item *ngIf=\"visibleActions.length === 0\">No actions available</nile-menu-item>\n    </nile-menu>\n    </div>\n\n  </div>\n", styles: [".dropdown-container{position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:9998}.dropdown-overlay{position:fixed;top:0;left:0;width:100%;height:100%;background-color:#0000004d;pointer-events:auto;z-index:9998}.dropdown-menu{position:fixed;background-color:#fff;box-shadow:0 5px 15px #0000004d,0 0 0 1px #0000001a;overflow:hidden;pointer-events:auto;z-index:9999}.action-icon{display:flex;align-items:center;justify-content:center;font-size:16px;width:20px;flex-shrink:0}.action-label{flex:1;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.dropdown-empty{padding:16px;text-align:center;color:#a0aec0;font-size:14px;font-style:italic}nile-menu{height:fit-content}\n"] }]
+        }], propDecorators: { isOpen: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], actionClicked: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }], onEscapeKey: [{
+                type: HostListener,
+                args: ['document:keydown.escape', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st-row-actions-dropdown.component.js","sourceRoot":"","sources":["../../../../../../../projects/smart-table/src/lib/renderer/components/st-row-actions-dropdown/st-row-actions-dropdown.component.ts","../../../../../../../projects/smart-table/src/lib/renderer/components/st-row-actions-dropdown/st-row-actions-dropdown.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, HostListener, OnChanges, SimpleChanges, ChangeDetectionStrategy } from '@angular/core';\nimport { RowAction, RowActionContext, RowActionEvent } from '../../../models/row-action.interface';\nimport { TableZIndex } from '../../models/z-index.enum';\n\n@Component({\n  selector: 'st-row-actions-dropdown',\n  templateUrl: './st-row-actions-dropdown.component.html',\n  styleUrls: ['./st-row-actions-dropdown.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class StRowActionsDropdownComponent implements OnChanges {\n  /**\n   * Whether the dropdown is open\n   */\n  @Input() isOpen: boolean = false;\n  \n  /**\n   * Position of the dropdown (x, y coordinates)\n   */\n  @Input() position: { x: number; y: number } = { x: 0, y: 0 };\n  \n  /**\n   * Context containing row data, index, and actions\n   */\n  @Input() context: RowActionContext | null = null;\n  \n  /**\n   * Emitted when an action is clicked\n   */\n  @Output() actionClicked = new EventEmitter<RowActionEvent>();\n  \n  /**\n   * Emitted when the dropdown should close\n   */\n  @Output() closed = new EventEmitter<void>();\n  \n  /**\n   * Visible actions (filtered by hidden property)\n   */\n  visibleActions: RowAction[] = [];\n  \n  /**\n   * Dropdown positioning style\n   */\n  dropdownStyle: any = {};\n  \n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['context'] || changes['isOpen']) {\n      this.updateVisibleActions();\n    }\n    \n    if (changes['position'] || changes['isOpen']) {\n      this.updateDropdownPosition();\n    }\n  }\n  \n  /**\n   * Update visible actions based on hidden property\n   */\n  private updateVisibleActions(): void {\n    if (!this.context) {\n      this.visibleActions = [];\n      return;\n    }\n    \n    this.visibleActions = this.context.actions.filter(action => {\n      if (typeof action.hidden === 'function') {\n        return !action.hidden(this.context!.rowData, this.context!.rowIndex);\n      }\n      return !action.hidden;\n    });\n  }\n  \n  /**\n   * Update dropdown position based on available viewport space\n   */\n  private updateDropdownPosition(): void {\n    if (!this.isOpen) {\n      this.dropdownStyle = {};\n      return;\n    }\n    \n    const DROPDOWN_WIDTH = 200; // Approximate width\n    const DROPDOWN_HEIGHT = this.visibleActions.length * 40 + 16; // Approximate height\n    \n    const viewportWidth = window.innerWidth;\n    const viewportHeight = window.innerHeight;\n    \n    let left = this.position.x;\n    let top = this.position.y;\n    \n    // Check if dropdown would overflow right edge\n    if (left + DROPDOWN_WIDTH > viewportWidth) {\n      left = viewportWidth - DROPDOWN_WIDTH - 10;\n    }\n    \n    // Check if dropdown would overflow bottom edge\n    if (top + DROPDOWN_HEIGHT > viewportHeight) {\n      // Position above the trigger\n      top = this.position.y - DROPDOWN_HEIGHT;\n    }\n    \n    // Ensure dropdown doesn't go off-screen on the left\n    if (left < 10) {\n      left = 10;\n    }\n    \n    // Ensure dropdown doesn't go off-screen on the top\n    if (top < 10) {\n      top = 10;\n    }\n    \n    this.dropdownStyle = {\n      position: 'fixed',\n      left: `${left}px`,\n      top: `${top}px`,\n      zIndex: TableZIndex.ROW_ACTIONS_DROPDOWN\n    };\n  }\n  \n  /**\n   * Handle action click\n   */\n  onActionClick(action: RowAction): void {\n    if (!this.context) return;\n    \n    // Check if action is disabled\n    if (this.isActionDisabled(action)) {\n      return;\n    }\n    \n    const event: RowActionEvent = {\n      action,\n      rowData: this.context.rowData,\n      rowIndex: this.context.rowIndex\n    };\n    \n    this.actionClicked.emit(event);\n  }\n  \n  /**\n   * Check if an action is disabled\n   */\n  isActionDisabled(action: RowAction): boolean {\n    if (!this.context) return true;\n    \n    if (typeof action.disabled === 'function') {\n      return action.disabled(this.context.rowData, this.context.rowIndex);\n    }\n    return !!action.disabled;\n  }\n  \n  /**\n   * Handle overlay click (close dropdown)\n   */\n  onOverlayClick(): void {\n    this.closed.emit();\n  }\n  \n  /**\n   * Handle ESC key press\n   */\n  @HostListener('document:keydown.escape', ['$event'])\n  onEscapeKey(event: Event): void {\n    if (this.isOpen) {\n      event.preventDefault();\n      event.stopPropagation();\n      this.closed.emit();\n    }\n  }\n  \n  /**\n   * Prevent dropdown click from closing\n   */\n  onDropdownClick(event: Event): void {\n    event.stopPropagation();\n  }\n}\n","<div class=\"dropdown-container\" *ngIf=\"isOpen && context\">\n  <!-- Backdrop -->\n  <div class=\"dropdown-overlay\" (click)=\"closed.emit()\"></div>\n  \n  <!-- Dropdown menu -->\n  <div class=\"dropdown-menu\" [ngStyle]=\"dropdownStyle\">\n    <nile-menu *ngIf=\"isOpen\" class=\"dropdown-menu\" [style.left.px]=\"dropdownStyle.left\" [style.top.px]=\"dropdownStyle.top\">\n      <ng-container *ngFor=\"let action of visibleActions\">\n        <nile-menu-item [class.disabled]=\"isActionDisabled(action)\" (click)=\"onActionClick(action)\" class=\"action-label\">\n          <nile-icon  *ngIf=\"action.icon\" size=\"14\" slot=\"prefix\" [name]=\"action.icon\"></nile-icon>\n          {{ action.label }}\n        </nile-menu-item>\n      </ng-container>\n    \n      <nile-menu-item *ngIf=\"visibleActions.length === 0\">No actions available</nile-menu-item>\n    </nile-menu>\n    </div>\n\n  </div>\n"]}

package/esm2020/lib/renderer/components/st-sheet/st-sheet.component.mjs

@@ -0,0 +1,165 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { SheetState } from '../../models/sheet-state.class';
+import * as i0 from "@angular/core";
+import * as i1 from "../st-sheet-actions/st-sheet-actions.component";
+import * as i2 from "../st-table/st-table.component";
+import * as i3 from "@angular/common";
+export class StSheetComponent {
+    constructor() {
+        /**
+         * Table data (sync)
+         */
+        this.data = [];
+        /**
+         * Emitted when sheet action is clicked
+         */
+        this.sheetActionClicked = new EventEmitter();
+        /**
+         * Emitted when sheet state changes
+         */
+        this.stateChange = new EventEmitter();
+        /**
+         * Emitted when a cell value changes
+         */
+        this.cellChange = new EventEmitter();
+        /**
+         * Emitted when table state changes (pagination, sorting, filtering)
+         */
+        this.tableStateChange = new EventEmitter();
+        /**
+         * Emitted when data changes (via Observable)
+         */
+        this.dataChange = new EventEmitter();
+        /**
+         * Visible actions (filtered by hidden property)
+         */
+        this.visibleActions = [];
+        this.activeTab = '1';
+    }
+    ngOnInit() {
+        this.initializeState();
+        this.updateVisibleActions();
+    }
+    ngOnChanges(changes) {
+        if (changes['config']) {
+            if (!this.state && this.config) {
+                this.initializeState();
+            }
+            this.updateVisibleActions();
+        }
+    }
+    /**
+     * Initialize sheet state
+     */
+    initializeState() {
+        if (!this.state && this.config) {
+            this.internalState = new SheetState({
+                id: this.config.id,
+                name: this.config.name
+            }, this.config.tableConfig.columns, {
+                initialPage: this.config.tableConfig.initialState?.page,
+                pageSize: this.config.tableConfig.pagination?.pageSize
+            });
+            // Update last accessed
+            this.internalState.updateLastAccessed();
+        }
+    }
+    /**
+     * Get active state (external or internal)
+     */
+    get activeState() {
+        return this.state || this.internalState;
+    }
+    /**
+     * Handle sheet action click
+     */
+    onActionClick(event) {
+        this.sheetActionClicked.emit(event);
+        // Emit state change after action
+        if (this.activeState) {
+            this.stateChange.emit(this.activeState.getSnapshot());
+        }
+    }
+    /**
+     * Handle cell value change from table
+     */
+    onCellChange(event) {
+        this.cellChange.emit(event);
+        // Update last modified timestamp
+        if (this.activeState) {
+            this.stateChange.emit(this.activeState.getSnapshot());
+        }
+    }
+    /**
+     * Handle table state change (pagination, sorting, filtering)
+     */
+    onTableStateChange(event) {
+        this.tableStateChange.emit(event);
+        // Emit sheet state change
+        if (this.activeState) {
+            this.stateChange.emit(this.activeState.getSnapshot());
+        }
+    }
+    /**
+     * Handle data change from table (via Observable)
+     */
+    onDataChange(event) {
+        this.dataChange.emit(event);
+        // Emit sheet state change
+        if (this.activeState) {
+            this.stateChange.emit(this.activeState.getSnapshot());
+        }
+    }
+    /**
+     * Update visible actions based on hidden property
+     */
+    updateVisibleActions() {
+        if (!this.config?.actions) {
+            this.visibleActions = [];
+            return;
+        }
+        this.visibleActions = this.config.actions.filter(action => {
+            if (typeof action.hidden === 'function') {
+                return !action.hidden();
+            }
+            return !action.hidden;
+        });
+    }
+    /**
+     * Check if header should be shown
+     */
+    get showHeader() {
+        return this.config?.display?.showHeader !== false;
+    }
+    /**
+     * Get header variant class
+     */
+    get headerVariant() {
+        return this.config?.display?.headerVariant || 'default';
+    }
+}
+StSheetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StSheetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StSheetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: StSheetComponent, selector: "st-sheet", inputs: { config: "config", data: "data", data$: "data$", state: "state" }, outputs: { sheetActionClicked: "sheetActionClicked", stateChange: "stateChange", cellChange: "cellChange", tableStateChange: "tableStateChange", dataChange: "dataChange" }, usesOnChanges: true, ngImport: i0, template: "  \n<nile-tab-group>\n  <nile-tab slot=\"nav\" panel=\"general\" [class.active]=\"activeTab === '1'\" (click)=\"activeTab = '1'\">\n    <div class=\"sheet-header\">\n      {{activeState?.name$ | async | titlecase}}\n      <st-sheet-actions \n        *ngIf=\"visibleActions.length > 0\"\n        [actions]=\"visibleActions\" \n        [sheetId]=\"config.id\"\n        (actionClicked)=\"onActionClick($event)\">\n      </st-sheet-actions>\n    </div>\n  </nile-tab>\n  <nile-tab-panel name=\"general\">\n    <st-table \n      *ngIf=\"config && activeState\"\n      [tableConfig]=\"config.tableConfig\"\n      [data]=\"data\"\n      [data$]=\"data$\"\n      [tableState]=\"activeState.tableState\"\n      (cellChange)=\"onCellChange($event)\"\n      (stateChange)=\"onTableStateChange($event)\"\n      (dataChange)=\"onDataChange($event)\">\n  </st-table>\n  </nile-tab-panel>\n</nile-tab-group>\n\n\n", styles: [":host{display:block;width:100%;height:100%}.sheet-container{display:flex;flex-direction:column;width:100%;height:100%}.sheet-header{display:flex;align-items:center;font-family:Colfax;color:#000}.sheet-table-wrapper{flex:1;overflow:auto;position:relative}nile-tab-group::part(nav){background-color:#fafafa}nile-tab-group::part(active-tab-indicator-path){background:none}nile-tab-group::part(active-tab-indicator){border-bottom:none}nile-tab-group::part(tabs){gap:0}nile-tab-group nile-tab{border:1px solid #e0e0e0;border-top-left-radius:6px;border-top-right-radius:6px}nile-tab-group nile-tab::part(base){padding-left:.5rem;padding-top:.5rem;padding-bottom:.5rem;border-bottom-left-radius:0;border-bottom-right-radius:0}nile-tab-group nile-tab.active{background-color:#fff}nile-tab-group nile-tab-panel::part(base){padding:0;max-height:30rem}\n"], components: [{ type: i1.StSheetActionsComponent, selector: "st-sheet-actions", inputs: ["actions", "sheetId"], outputs: ["actionClicked"] }, { type: i2.StTableComponent, selector: "st-table", inputs: ["tableConfig", "data", "data$", "tableState", "enableSorting", "enableFiltering", "validateConfig"], outputs: ["stateChange", "dataChange", "cellEdit", "cellSave", "cellCancel", "cellChange", "columnResized", "columnMoved", "configValidationErrors", "columnAdded", "rowAction", "validationStateChange"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "titlecase": i3.TitleCasePipe, "async": i3.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StSheetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'st-sheet', template: "  \n<nile-tab-group>\n  <nile-tab slot=\"nav\" panel=\"general\" [class.active]=\"activeTab === '1'\" (click)=\"activeTab = '1'\">\n    <div class=\"sheet-header\">\n      {{activeState?.name$ | async | titlecase}}\n      <st-sheet-actions \n        *ngIf=\"visibleActions.length > 0\"\n        [actions]=\"visibleActions\" \n        [sheetId]=\"config.id\"\n        (actionClicked)=\"onActionClick($event)\">\n      </st-sheet-actions>\n    </div>\n  </nile-tab>\n  <nile-tab-panel name=\"general\">\n    <st-table \n      *ngIf=\"config && activeState\"\n      [tableConfig]=\"config.tableConfig\"\n      [data]=\"data\"\n      [data$]=\"data$\"\n      [tableState]=\"activeState.tableState\"\n      (cellChange)=\"onCellChange($event)\"\n      (stateChange)=\"onTableStateChange($event)\"\n      (dataChange)=\"onDataChange($event)\">\n  </st-table>\n  </nile-tab-panel>\n</nile-tab-group>\n\n\n", styles: [":host{display:block;width:100%;height:100%}.sheet-container{display:flex;flex-direction:column;width:100%;height:100%}.sheet-header{display:flex;align-items:center;font-family:Colfax;color:#000}.sheet-table-wrapper{flex:1;overflow:auto;position:relative}nile-tab-group::part(nav){background-color:#fafafa}nile-tab-group::part(active-tab-indicator-path){background:none}nile-tab-group::part(active-tab-indicator){border-bottom:none}nile-tab-group::part(tabs){gap:0}nile-tab-group nile-tab{border:1px solid #e0e0e0;border-top-left-radius:6px;border-top-right-radius:6px}nile-tab-group nile-tab::part(base){padding-left:.5rem;padding-top:.5rem;padding-bottom:.5rem;border-bottom-left-radius:0;border-bottom-right-radius:0}nile-tab-group nile-tab.active{background-color:#fff}nile-tab-group nile-tab-panel::part(base){padding:0;max-height:30rem}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { config: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], data$: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], sheetActionClicked: [{
+                type: Output
+            }], stateChange: [{
+                type: Output
+            }], cellChange: [{
+                type: Output
+            }], tableStateChange: [{
+                type: Output
+            }], dataChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st-sheet.component.js","sourceRoot":"","sources":["../../../../../../../projects/smart-table/src/lib/renderer/components/st-sheet/st-sheet.component.ts","../../../../../../../projects/smart-table/src/lib/renderer/components/st-sheet/st-sheet.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  OnInit,\n  OnChanges,\n  SimpleChanges\n} from '@angular/core';\nimport { Observable, BehaviorSubject } from 'rxjs';\nimport { SheetConfig } from '../../../models/sheet-config.interface';\nimport { SheetAction, SheetActionEvent } from '../../../models/sheet-action.interface';\nimport { SheetState } from '../../models/sheet-state.class';\nimport { SheetStateSnapshot } from '../../models/sheet-state.interface';\nimport { CellChangeEvent } from '../../../models/cell-types';\nimport { TableStateChangeEvent, DataChangeEvent } from '../../models/table-types';\n\n@Component({\n  selector: 'st-sheet',\n  templateUrl: './st-sheet.component.html',\n  styleUrls: ['./st-sheet.component.scss'],\n})\nexport class StSheetComponent implements OnInit, OnChanges {\n  /**\n   * Sheet configuration\n   */\n  @Input() config!: SheetConfig;\n\n  /**\n   * Table data (sync)\n   */\n  @Input() data: any[] = [];\n  \n  /**\n   * Table data (async) - Observable or BehaviorSubject\n   */\n  @Input() data$?: Observable<any[]> | BehaviorSubject<any[]>;\n\n  /**\n   * Optional external state management\n   * If not provided, component will create its own state\n   */\n  @Input() state?: SheetState;\n\n  /**\n   * Emitted when sheet action is clicked\n   */\n  @Output() sheetActionClicked = new EventEmitter<SheetActionEvent>();\n\n  /**\n   * Emitted when sheet state changes\n   */\n  @Output() stateChange = new EventEmitter<SheetStateSnapshot>();\n\n  /**\n   * Emitted when a cell value changes\n   */\n  @Output() cellChange = new EventEmitter<CellChangeEvent>();\n\n  /**\n   * Emitted when table state changes (pagination, sorting, filtering)\n   */\n  @Output() tableStateChange = new EventEmitter<TableStateChangeEvent>();\n  \n  /**\n   * Emitted when data changes (via Observable)\n   */\n  @Output() dataChange = new EventEmitter<DataChangeEvent>();\n\n  /**\n   * Internal state instance\n   */\n  internalState?: SheetState;\n\n  /**\n   * Visible actions (filtered by hidden property)\n   */\n  visibleActions: SheetAction[] = [];\n  activeTab: string = '1';\n\n  constructor() {}\n\n  ngOnInit(): void {\n    this.initializeState();\n    this.updateVisibleActions();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['config']) {\n      if (!this.state && this.config) {\n        this.initializeState();\n      }\n      this.updateVisibleActions();\n    }\n  }\n\n  /**\n   * Initialize sheet state\n   */\n  private initializeState(): void {\n    if (!this.state && this.config) {\n      this.internalState = new SheetState(\n        {\n          id: this.config.id,\n          name: this.config.name\n        },\n        this.config.tableConfig.columns,\n        {\n          initialPage: this.config.tableConfig.initialState?.page,\n          pageSize: this.config.tableConfig.pagination?.pageSize\n        }\n      );\n\n      // Update last accessed\n      this.internalState.updateLastAccessed();\n    }\n  }\n\n  /**\n   * Get active state (external or internal)\n   */\n  get activeState(): SheetState | undefined {\n    return this.state || this.internalState;\n  }\n\n  /**\n   * Handle sheet action click\n   */\n  onActionClick(event: SheetActionEvent): void {\n    this.sheetActionClicked.emit(event);\n    \n    // Emit state change after action\n    if (this.activeState) {\n      this.stateChange.emit(this.activeState.getSnapshot());\n    }\n  }\n\n  /**\n   * Handle cell value change from table\n   */\n  onCellChange(event: CellChangeEvent): void {\n    this.cellChange.emit(event);\n    \n    // Update last modified timestamp\n    if (this.activeState) {\n      this.stateChange.emit(this.activeState.getSnapshot());\n    }\n  }\n\n  /**\n   * Handle table state change (pagination, sorting, filtering)\n   */\n  onTableStateChange(event: TableStateChangeEvent): void {\n    this.tableStateChange.emit(event);\n    \n    // Emit sheet state change\n    if (this.activeState) {\n      this.stateChange.emit(this.activeState.getSnapshot());\n    }\n  }\n  \n  /**\n   * Handle data change from table (via Observable)\n   */\n  onDataChange(event: DataChangeEvent): void {\n    this.dataChange.emit(event);\n    \n    // Emit sheet state change\n    if (this.activeState) {\n      this.stateChange.emit(this.activeState.getSnapshot());\n    }\n  }\n\n  /**\n   * Update visible actions based on hidden property\n   */\n  private updateVisibleActions(): void {\n    if (!this.config?.actions) {\n      this.visibleActions = [];\n      return;\n    }\n\n    this.visibleActions = this.config.actions.filter(action => {\n      if (typeof action.hidden === 'function') {\n        return !action.hidden();\n      }\n      return !action.hidden;\n    });\n  }\n\n  /**\n   * Check if header should be shown\n   */\n  get showHeader(): boolean {\n    return this.config?.display?.showHeader !== false;\n  }\n\n  /**\n   * Get header variant class\n   */\n  get headerVariant(): string {\n    return this.config?.display?.headerVariant || 'default';\n  }\n}\n\n","  \n<nile-tab-group>\n  <nile-tab slot=\"nav\" panel=\"general\" [class.active]=\"activeTab === '1'\" (click)=\"activeTab = '1'\">\n    <div class=\"sheet-header\">\n      {{activeState?.name$ | async | titlecase}}\n      <st-sheet-actions \n        *ngIf=\"visibleActions.length > 0\"\n        [actions]=\"visibleActions\" \n        [sheetId]=\"config.id\"\n        (actionClicked)=\"onActionClick($event)\">\n      </st-sheet-actions>\n    </div>\n  </nile-tab>\n  <nile-tab-panel name=\"general\">\n    <st-table \n      *ngIf=\"config && activeState\"\n      [tableConfig]=\"config.tableConfig\"\n      [data]=\"data\"\n      [data$]=\"data$\"\n      [tableState]=\"activeState.tableState\"\n      (cellChange)=\"onCellChange($event)\"\n      (stateChange)=\"onTableStateChange($event)\"\n      (dataChange)=\"onDataChange($event)\">\n  </st-table>\n  </nile-tab-panel>\n</nile-tab-group>\n\n\n"]}

package/esm2020/lib/renderer/components/st-sheet-actions/st-sheet-actions.component.mjs

@@ -0,0 +1,112 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class StSheetActionsComponent {
+    constructor() {
+        /**
+         * Array of sheet actions
+         */
+        this.actions = [];
+        /**
+         * Emitted when an action is clicked
+         */
+        this.actionClicked = new EventEmitter();
+        /**
+         * Whether the dropdown is open
+         */
+        this.isOpen = false;
+        /**
+         * Visible actions (filtered by hidden property)
+         */
+        this.visibleActions = [];
+        /**
+         * Dropdown positioning style
+         */
+        this.dropdownStyle = {};
+    }
+    ngOnInit() {
+        this.updateVisibleActions();
+    }
+    ngOnChanges() {
+        this.updateVisibleActions();
+    }
+    /**
+     * Toggle dropdown menu
+     */
+    toggleMenu(event) {
+        event.stopPropagation();
+        this.isOpen = !this.isOpen;
+        if (this.isOpen) {
+            this.updateDropdownPosition(event);
+        }
+    }
+    /**
+     * Close dropdown menu
+     */
+    closeMenu() {
+        this.isOpen = false;
+    }
+    /**
+     * Handle action click
+     */
+    onActionClick(action, event) {
+        event.stopPropagation();
+        if (this.isActionDisabled(action)) {
+            return;
+        }
+        // Emit event
+        this.actionClicked.emit({
+            action,
+            sheetId: this.sheetId
+        });
+        // Execute action callback if provided
+        if (action.action) {
+            action.action(this.sheetId);
+        }
+        this.closeMenu();
+    }
+    /**
+     * Check if action is disabled
+     */
+    isActionDisabled(action) {
+        if (typeof action.disabled === 'function') {
+            return action.disabled();
+        }
+        return action.disabled || false;
+    }
+    /**
+     * Update visible actions based on hidden property
+     */
+    updateVisibleActions() {
+        this.visibleActions = this.actions.filter(action => {
+            if (typeof action.hidden === 'function') {
+                return !action.hidden();
+            }
+            return !action.hidden;
+        });
+    }
+    /**
+     * Update dropdown position based on trigger button
+     */
+    updateDropdownPosition(event) {
+        const target = event.currentTarget;
+        const rect = target.getBoundingClientRect();
+        this.dropdownStyle = {
+            top: `${rect.bottom + 4}px`,
+            right: `${window.innerWidth - rect.right}px`
+        };
+    }
+}
+StSheetActionsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StSheetActionsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+StSheetActionsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: StSheetActionsComponent, selector: "st-sheet-actions", inputs: { actions: "actions", sheetId: "sheetId" }, outputs: { actionClicked: "actionClicked" }, usesOnChanges: true, ngImport: i0, template: "<button \n  class=\"sheet-actions-button\"\n  (click)=\"toggleMenu($event)\"\n  type=\"button\"\n  title=\"Sheet Actions\"\n  aria-label=\"Sheet actions menu\"\n  [class.active]=\"isOpen\"\n  *ngIf=\"visibleActions.length > 0\">\n  <nile-icon name=\"arrowdown\" size=\"14\"></nile-icon>\n</button>\n\n<!-- Dropdown container -->\n<div class=\"dropdown-container\" *ngIf=\"isOpen\">\n  <!-- Backdrop -->\n  <div class=\"dropdown-backdrop\" (click)=\"closeMenu()\"></div>\n  \n  <!-- Dropdown menu -->\n  <div class=\"dropdown-menu\" [ngStyle]=\"dropdownStyle\">\n    <nile-menu>\n      <nile-menu-item \n        *ngFor=\"let action of visibleActions\"\n        [class.disabled]=\"isActionDisabled(action)\"\n        (click)=\"onActionClick(action, $event)\">\n        <nile-icon *ngIf=\"action.icon\" size=\"14\" slot=\"prefix\" [name]=\"action.icon\"></nile-icon>\n        {{ action.label }}\n      </nile-menu-item>\n      \n      <nile-menu-item *ngIf=\"visibleActions.length === 0\">\n        No actions available\n      </nile-menu-item>\n    </nile-menu>\n  </div>\n</div>\n\n", styles: [":host{display:inline-block}.sheet-actions-button{display:flex;align-items:center;justify-content:center;width:2rem;padding:0;background:transparent;border:none;border-radius:4px;cursor:pointer;transition:background-color .2s ease;color:var(--nile-color-neutral-600)}.sheet-actions-button nile-icon{font-size:16px}.dropdown-container{position:fixed;top:0;left:0;width:100%;height:100%;z-index:1000;pointer-events:none}.dropdown-container>*{pointer-events:auto}.dropdown-backdrop{position:fixed;top:0;left:0;width:100%;height:100%;background:transparent;z-index:1000}.dropdown-menu{position:absolute;min-width:200px;background:white;border-radius:8px;box-shadow:0 4px 12px #00000026;z-index:1001;overflow:hidden}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StSheetActionsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'st-sheet-actions', template: "<button \n  class=\"sheet-actions-button\"\n  (click)=\"toggleMenu($event)\"\n  type=\"button\"\n  title=\"Sheet Actions\"\n  aria-label=\"Sheet actions menu\"\n  [class.active]=\"isOpen\"\n  *ngIf=\"visibleActions.length > 0\">\n  <nile-icon name=\"arrowdown\" size=\"14\"></nile-icon>\n</button>\n\n<!-- Dropdown container -->\n<div class=\"dropdown-container\" *ngIf=\"isOpen\">\n  <!-- Backdrop -->\n  <div class=\"dropdown-backdrop\" (click)=\"closeMenu()\"></div>\n  \n  <!-- Dropdown menu -->\n  <div class=\"dropdown-menu\" [ngStyle]=\"dropdownStyle\">\n    <nile-menu>\n      <nile-menu-item \n        *ngFor=\"let action of visibleActions\"\n        [class.disabled]=\"isActionDisabled(action)\"\n        (click)=\"onActionClick(action, $event)\">\n        <nile-icon *ngIf=\"action.icon\" size=\"14\" slot=\"prefix\" [name]=\"action.icon\"></nile-icon>\n        {{ action.label }}\n      </nile-menu-item>\n      \n      <nile-menu-item *ngIf=\"visibleActions.length === 0\">\n        No actions available\n      </nile-menu-item>\n    </nile-menu>\n  </div>\n</div>\n\n", styles: [":host{display:inline-block}.sheet-actions-button{display:flex;align-items:center;justify-content:center;width:2rem;padding:0;background:transparent;border:none;border-radius:4px;cursor:pointer;transition:background-color .2s ease;color:var(--nile-color-neutral-600)}.sheet-actions-button nile-icon{font-size:16px}.dropdown-container{position:fixed;top:0;left:0;width:100%;height:100%;z-index:1000;pointer-events:none}.dropdown-container>*{pointer-events:auto}.dropdown-backdrop{position:fixed;top:0;left:0;width:100%;height:100%;background:transparent;z-index:1000}.dropdown-menu{position:absolute;min-width:200px;background:white;border-radius:8px;box-shadow:0 4px 12px #00000026;z-index:1001;overflow:hidden}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { actions: [{
+                type: Input
+            }], sheetId: [{
+                type: Input
+            }], actionClicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"st-sheet-actions.component.js","sourceRoot":"","sources":["../../../../../../../projects/smart-table/src/lib/renderer/components/st-sheet-actions/st-sheet-actions.component.ts","../../../../../../../projects/smart-table/src/lib/renderer/components/st-sheet-actions/st-sheet-actions.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAqB,MAAM,eAAe,CAAC;;;AAQ1F,MAAM,OAAO,uBAAuB;IA+BlC;QA9BA;;WAEG;QACM,YAAO,GAAkB,EAAE,CAAC;QAOrC;;WAEG;QACO,kBAAa,GAAG,IAAI,YAAY,EAAoB,CAAC;QAE/D;;WAEG;QACH,WAAM,GAAG,KAAK,CAAC;QAEf;;WAEG;QACH,mBAAc,GAAkB,EAAE,CAAC;QAEnC;;WAEG;QACH,kBAAa,GAAQ,EAAE,CAAC;IAET,CAAC;IAEhB,QAAQ;QACN,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,KAAiB;QAC1B,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC;QAE3B,IAAI,IAAI,CAAC,MAAM,EAAE;YACf,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;SACpC;IAEH,CAAC;IAED;;OAEG;IACH,SAAS;QACP,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,MAAmB,EAAE,KAAY;QAC7C,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE;YACjC,OAAO;SACR;QAED,aAAa;QACb,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;YACtB,MAAM;YACN,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC,CAAC;QAEH,sCAAsC;QACtC,IAAI,MAAM,CAAC,MAAM,EAAE;YACjB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SAC7B;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,MAAmB;QAClC,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,UAAU,EAAE;YACzC,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;SAC1B;QACD,OAAO,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC;IAClC,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;YACjD,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE;gBACvC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;aACzB;YACD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,sBAAsB,CAAC,KAAiB;QAC9C,MAAM,MAAM,GAAG,KAAK,CAAC,aAA4B,CAAC;QAClD,MAAM,IAAI,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;QAE5C,IAAI,CAAC,aAAa,GAAG;YACnB,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI;YAC3B,KAAK,EAAE,GAAG,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,IAAI;SAC7C,CAAC;IACJ,CAAC;;oHAtHU,uBAAuB;wGAAvB,uBAAuB,8KCRpC,2jCAkCA;2FD1Ba,uBAAuB;kBALnC,SAAS;+BACE,kBAAkB;0EAQnB,OAAO;sBAAf,KAAK;gBAKG,OAAO;sBAAf,KAAK;gBAKI,aAAa;sBAAtB,MAAM","sourcesContent":["import { Component, Input, Output, EventEmitter, ChangeDetectorRef } from '@angular/core';\nimport { SheetAction, SheetActionEvent } from '../../../models/sheet-action.interface';\n\n@Component({  \n  selector: 'st-sheet-actions',\n  templateUrl: './st-sheet-actions.component.html',\n  styleUrls: ['./st-sheet-actions.component.scss'],\n})\nexport class StSheetActionsComponent {\n  /**\n   * Array of sheet actions\n   */\n  @Input() actions: SheetAction[] = [];\n\n  /**\n   * Sheet ID for context\n   */\n  @Input() sheetId!: string;\n\n  /**\n   * Emitted when an action is clicked\n   */\n  @Output() actionClicked = new EventEmitter<SheetActionEvent>();\n\n  /**\n   * Whether the dropdown is open\n   */\n  isOpen = false;\n\n  /**\n   * Visible actions (filtered by hidden property)\n   */\n  visibleActions: SheetAction[] = [];\n\n  /**\n   * Dropdown positioning style\n   */\n  dropdownStyle: any = {};\n\n  constructor() {}\n\n  ngOnInit(): void {\n    this.updateVisibleActions();\n  }\n\n  ngOnChanges(): void {\n    this.updateVisibleActions();\n  }\n\n  /**\n   * Toggle dropdown menu\n   */\n  toggleMenu(event: MouseEvent): void {\n    event.stopPropagation();\n    this.isOpen = !this.isOpen;\n\n    if (this.isOpen) {\n      this.updateDropdownPosition(event);\n    }\n\n  }\n\n  /**\n   * Close dropdown menu\n   */\n  closeMenu(): void {\n    this.isOpen = false;\n  }\n\n  /**\n   * Handle action click\n   */\n  onActionClick(action: SheetAction, event: Event): void {\n    event.stopPropagation();\n\n    if (this.isActionDisabled(action)) {\n      return;\n    }\n\n    // Emit event\n    this.actionClicked.emit({\n      action,\n      sheetId: this.sheetId\n    });\n\n    // Execute action callback if provided\n    if (action.action) {\n      action.action(this.sheetId);\n    }\n\n    this.closeMenu();\n  }\n\n  /**\n   * Check if action is disabled\n   */\n  isActionDisabled(action: SheetAction): boolean {\n    if (typeof action.disabled === 'function') {\n      return action.disabled();\n    }\n    return action.disabled || false;\n  }\n\n  /**\n   * Update visible actions based on hidden property\n   */\n  private updateVisibleActions(): void {\n    this.visibleActions = this.actions.filter(action => {\n      if (typeof action.hidden === 'function') {\n        return !action.hidden();\n      }\n      return !action.hidden;\n    });\n  }\n\n  /**\n   * Update dropdown position based on trigger button\n   */\n  private updateDropdownPosition(event: MouseEvent): void {\n    const target = event.currentTarget as HTMLElement;\n    const rect = target.getBoundingClientRect();\n\n    this.dropdownStyle = {\n      top: `${rect.bottom + 4}px`,\n      right: `${window.innerWidth - rect.right}px`\n    };\n  }\n}\n\n","<button \n  class=\"sheet-actions-button\"\n  (click)=\"toggleMenu($event)\"\n  type=\"button\"\n  title=\"Sheet Actions\"\n  aria-label=\"Sheet actions menu\"\n  [class.active]=\"isOpen\"\n  *ngIf=\"visibleActions.length > 0\">\n  <nile-icon name=\"arrowdown\" size=\"14\"></nile-icon>\n</button>\n\n<!-- Dropdown container -->\n<div class=\"dropdown-container\" *ngIf=\"isOpen\">\n  <!-- Backdrop -->\n  <div class=\"dropdown-backdrop\" (click)=\"closeMenu()\"></div>\n  \n  <!-- Dropdown menu -->\n  <div class=\"dropdown-menu\" [ngStyle]=\"dropdownStyle\">\n    <nile-menu>\n      <nile-menu-item \n        *ngFor=\"let action of visibleActions\"\n        [class.disabled]=\"isActionDisabled(action)\"\n        (click)=\"onActionClick(action, $event)\">\n        <nile-icon *ngIf=\"action.icon\" size=\"14\" slot=\"prefix\" [name]=\"action.icon\"></nile-icon>\n        {{ action.label }}\n      </nile-menu-item>\n      \n      <nile-menu-item *ngIf=\"visibleActions.length === 0\">\n        No actions available\n      </nile-menu-item>\n    </nile-menu>\n  </div>\n</div>\n\n"]}