@aquera/ngx-smart-table 0.0.2-alpha

package/esm2020/lib/renderer/directives/st-column-resize.directive.mjs

@@ -0,0 +1,108 @@
+/**
+ * Column Resize Directive
+ * Handles column resizing when applied to th/td elements
+ */
+import { Directive, HostListener, Input, Output, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export class StColumnResizeDirective {
+    constructor(el) {
+        this.el = el;
+        /**
+         * Emits when column is resized
+         */
+        this.columnResized = new EventEmitter();
+        /**
+         * Resize state
+         */
+        this.isResizing = false;
+        this.startX = 0;
+        this.startWidth = 0;
+        /**
+         * Track mouse movement during resize
+         */
+        this.onResizeMove = (event) => {
+            if (!this.isResizing) {
+                return;
+            }
+            const deltaX = event.pageX - this.startX;
+            let newWidth = this.startWidth + deltaX;
+            // Apply constraints
+            const minWidth = this.column.minWidth ?? 50;
+            const maxWidth = this.column.maxWidth;
+            newWidth = Math.max(minWidth, newWidth);
+            if (maxWidth) {
+                newWidth = Math.min(maxWidth, newWidth);
+            }
+            // Update column width (mutate Flyweight config)
+            this.column.width = newWidth;
+            // Update element width immediately for visual feedback
+            // this.el.nativeElement.style.width = `${newWidth}px`;
+        };
+        /**
+         * End resize on mouseup
+         */
+        this.onResizeEnd = () => {
+            if (!this.isResizing) {
+                return;
+            }
+            this.isResizing = false;
+            // Emit event with old and new width
+            const resizeEvent = {
+                columnKey: this.column.key,
+                oldWidth: this.startWidth,
+                newWidth: this.column.width,
+                column: this.column
+            };
+            this.columnResized.emit(resizeEvent);
+            // Remove global listeners
+            document.removeEventListener('mousemove', this.onResizeMove);
+            document.removeEventListener('mouseup', this.onResizeEnd);
+        };
+    }
+    /**
+     * Start resize on mousedown
+     */
+    onResizeStart(event) {
+        // Check if click is on the resize handle span element
+        const target = event.target;
+        const isResizeHandle = target.classList.contains('resize-handle') ||
+            target.closest('.resize-handle') !== null;
+        if (!isResizeHandle) {
+            return;
+        }
+        if (this.column.resizable === false) {
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        this.isResizing = true;
+        this.startX = event.pageX;
+        this.startWidth = this.column.width || 100;
+        // Attach global listeners
+        document.addEventListener('mousemove', this.onResizeMove);
+        document.addEventListener('mouseup', this.onResizeEnd);
+    }
+    /**
+     * Cleanup on destroy
+     */
+    ngOnDestroy() {
+        document.removeEventListener('mousemove', this.onResizeMove);
+        document.removeEventListener('mouseup', this.onResizeEnd);
+    }
+}
+StColumnResizeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StColumnResizeDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+StColumnResizeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.4.0", type: StColumnResizeDirective, selector: "[stColumnResize]", inputs: { column: "column" }, outputs: { columnResized: "columnResized" }, host: { listeners: { "mousedown": "onResizeStart($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StColumnResizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[stColumnResize]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { column: [{
+                type: Input
+            }], columnResized: [{
+                type: Output
+            }], onResizeStart: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/renderer/directives/st-keyboard-navigation.directive.mjs

@@ -0,0 +1,73 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { NavigationKey, NavigationDirection } from '../../models/cell-types';
+import * as i0 from "@angular/core";
+/**
+ * Directive to handle keyboard navigation in table cells
+ */
+export class StKeyboardNavigationDirective {
+    onKeyDown(event) {
+        if (!this.tableState.isNavigationActive()) {
+            return;
+        }
+        const isEditing = this.tableState.isAnyCellEditing();
+        // Use NavigationKey enum for type-safe key checking
+        switch (event.key) {
+            case NavigationKey.ARROW_UP:
+            case NavigationKey.ARROW_DOWN:
+            case NavigationKey.ARROW_LEFT:
+            case NavigationKey.ARROW_RIGHT:
+                // Allow navigation when NOT editing
+                if (isEditing)
+                    return;
+                event.preventDefault();
+                const direction = this.getDirection(event.key);
+                if (direction) {
+                    this.tableState.moveFocus(direction);
+                }
+                break;
+            case NavigationKey.ENTER:
+                // Navigate down when NOT editing (Excel-like behavior)
+                if (isEditing)
+                    return; // Let cell component handle save
+                event.preventDefault();
+                this.tableState.moveFocus(NavigationDirection.DOWN);
+                break;
+            case NavigationKey.TAB:
+                // Navigate left/right when NOT editing (Excel-like behavior)
+                if (isEditing)
+                    return; // Let cell component handle save
+                event.preventDefault();
+                this.tableState.moveFocus(event.shiftKey ? NavigationDirection.LEFT : NavigationDirection.RIGHT);
+                break;
+        }
+    }
+    /**
+     * Convert navigation key to direction using enums
+     */
+    getDirection(key) {
+        const map = {
+            [NavigationKey.ARROW_UP]: NavigationDirection.UP,
+            [NavigationKey.ARROW_DOWN]: NavigationDirection.DOWN,
+            [NavigationKey.ARROW_LEFT]: NavigationDirection.LEFT,
+            [NavigationKey.ARROW_RIGHT]: NavigationDirection.RIGHT,
+            [NavigationKey.TAB]: null,
+            [NavigationKey.ENTER]: null,
+            [NavigationKey.ESCAPE]: null
+        };
+        return map[key];
+    }
+}
+StKeyboardNavigationDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StKeyboardNavigationDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+StKeyboardNavigationDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.4.0", type: StKeyboardNavigationDirective, selector: "[stKeyboardNavigation]", inputs: { tableState: "tableState" }, host: { listeners: { "keydown": "onKeyDown($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: StKeyboardNavigationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[stKeyboardNavigation]'
+                }]
+        }], propDecorators: { tableState: [{
+                type: Input
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/renderer/models/cell-state.interface.mjs

@@ -0,0 +1,66 @@
+/**
+ * Cell state interface - represents unique state per cell instance
+ * This is the "Context" in the Flyweight pattern
+ */
+import { CellLifecycleState } from '../../models/cell-types';
+/**
+ * Factory function to create initial cell state with defaults
+ */
+export function createCellState(value, overrides) {
+    return {
+        value,
+        isEditing: false,
+        isDirty: false,
+        isFocused: false,
+        previousValue: value,
+        originalValue: value,
+        lifecycleState: CellLifecycleState.DISPLAY,
+        ...overrides
+    };
+}
+/**
+ * Create a memento snapshot of cell state
+ */
+export function createMemento(state) {
+    return {
+        value: state.value,
+        isDirty: state.isDirty,
+        error: state.error,
+        metadata: state.metadata ? { ...state.metadata } : undefined,
+        timestamp: new Date()
+    };
+}
+/**
+ * Restore cell state from memento
+ */
+export function restoreFromMemento(currentState, memento) {
+    return {
+        ...currentState,
+        value: memento.value,
+        isDirty: memento.isDirty,
+        error: memento.error,
+        metadata: memento.metadata ? { ...memento.metadata } : currentState.metadata
+    };
+}
+/**
+ * Helper to check if cell is in valid state
+ */
+export function isCellValid(state) {
+    return !state.error && (!state.errors || Object.keys(state.errors).length === 0);
+}
+/**
+ * Helper to check if cell can be edited
+ */
+export function canEdit(state) {
+    return !state.isDisabled &&
+        !state.isReadonly &&
+        !state.isLoading &&
+        state.lifecycleState !== CellLifecycleState.SAVING;
+}
+/**
+ * Helper to check if cell is in display mode
+ */
+export function isDisplayMode(state) {
+    return state.lifecycleState === CellLifecycleState.DISPLAY && !state.isEditing;
+}
+//# sourceMappingURL=data:application/json;base64,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