cloud-ide-element 0.0.1 → 1.0.0

package/esm2022/lib/components/data-grid/data-grid.types.mjs

@@ -0,0 +1,37 @@
+// Data Grid Configuration Types for CideEleDataGrid Component
+// Default configurations
+export const DEFAULT_GRID_CONFIG = {
+    pagination: {
+        enabled: true,
+        pageSize: 10,
+        pageSizeOptions: [10, 25, 50, 100],
+        showQuickJump: true,
+        showPageInfo: true,
+        showRefresh: true
+    },
+    search: {
+        enabled: true,
+        placeholder: 'Search...',
+        searchableColumns: [],
+        debounceMs: 300
+    },
+    loading: {
+        useDefer: true,
+        skeletonRows: 5,
+        showOverlay: false
+    },
+    scroll: {
+        enabled: false,
+        maxHeight: '400px',
+        minHeight: '200px',
+        stickyHeader: true,
+        virtualScroll: false,
+        rowHeight: 40
+    },
+    responsive: true,
+    striped: false,
+    bordered: true,
+    compact: true,
+    fullHeight: true
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-grid.types.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-element/src/lib/components/data-grid/data-grid.types.ts"],"names":[],"mappings":"AAAA,8DAA8D;AA0K9D,yBAAyB;AACzB,MAAM,CAAC,MAAM,mBAAmB,GAA+B;IAC7D,UAAU,EAAE;QACV,OAAO,EAAE,IAAI;QACb,QAAQ,EAAE,EAAE;QACZ,eAAe,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC;QAClC,aAAa,EAAE,IAAI;QACnB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,IAAI;KAClB;IACD,MAAM,EAAE;QACN,OAAO,EAAE,IAAI;QACb,WAAW,EAAE,WAAW;QACxB,iBAAiB,EAAE,EAAE;QACrB,UAAU,EAAE,GAAG;KAChB;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,IAAI;QACd,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,KAAK;KACnB;IACD,MAAM,EAAE;QACN,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,OAAO;QAClB,SAAS,EAAE,OAAO;QAClB,YAAY,EAAE,IAAI;QAClB,aAAa,EAAE,KAAK;QACpB,SAAS,EAAE,EAAE;KACd;IACD,UAAU,EAAE,IAAI;IAChB,OAAO,EAAE,KAAK;IACd,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,IAAI;CACjB,CAAC","sourcesContent":["// Data Grid Configuration Types for CideEleDataGrid Component\n\nexport type ColumnType = 'text' | 'number' | 'date' | 'boolean' | 'status' | 'actions' | 'custom' | 'order';\nexport type ColumnWidth = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto' | string;\nexport type TextAlign = 'left' | 'center' | 'right';\n\nexport interface GridColumn {\n  key: string;\n  header: string;\n  type: ColumnType;\n  width?: ColumnWidth;\n  sortable?: boolean;\n  searchable?: boolean;\n  truncate?: boolean;\n  align?: TextAlign;\n  renderer?: string; // For custom rendering\n  valueGetter?: string; // Path to nested property (e.g., 'contact.email')\n  formatter?: GridFormatter;\n  actions?: GridAction[];\n  statusConfig?: StatusConfig;\n}\n\nexport interface GridFormatter {\n  type: 'date' | 'currency' | 'percentage' | 'custom';\n  format?: string; // Date format, currency code, etc.\n  customFunction?: string; // Name of custom formatter function\n}\n\nexport interface StatusConfig {\n  activeValue: string | number | boolean;\n  activeLabel: string;\n  inactiveLabel: string;\n  activeClass: string;\n  inactiveClass: string;\n}\n\nexport interface GridAction {\n  key: string;\n  label: string;\n  icon: string;\n  variant: 'ghost' | 'primary' | 'outline' | 'danger';\n  tooltip?: string;\n  condition?: string; // Condition to show action (e.g., 'entity.isActive')\n  onClick: string; // Function name to call\n}\n\nexport interface GridPaginationConfig {\n  enabled: boolean;\n  pageSize: number;\n  pageSizeOptions: number[];\n  showQuickJump: boolean;\n  showPageInfo: boolean;\n  showRefresh: boolean;\n}\n\nexport interface GridSearchConfig {\n  enabled: boolean;\n  placeholder: string;\n  searchableColumns: string[]; // Column keys to search in\n  debounceMs?: number;\n}\n\nexport interface GridExportConfig {\n  enabled: boolean;\n  formats: ('csv' | 'excel' | 'pdf')[];\n  filename?: string;\n}\n\nexport interface GridLoadingConfig {\n  useDefer: boolean;\n  skeletonRows: number;\n  showOverlay: boolean;\n}\n\nexport interface GridScrollConfig {\n  enabled: boolean;\n  maxHeight?: string; // e.g., '400px', '50vh', 'calc(100vh - 200px)'\n  minHeight?: string; // e.g., '200px'\n  stickyHeader?: boolean; // Keep header visible when scrolling\n  virtualScroll?: boolean; // Enable virtual scrolling for large datasets\n  rowHeight?: number; // Height of each row in pixels (for virtual scroll)\n}\n\nexport interface GridTreeConfig {\n  enabled: boolean;\n  primaryKey: string; // Primary key field name (e.g., '_id')\n  foreignKey: string; // Foreign key field name (e.g., 'syme_id_syme')\n  childrenKey?: string; // Children array field name (default: 'children')\n  levelKey?: string; // Level field name (default: 'level')\n  expandedKey?: string; // Expanded state field name (default: 'isExpanded')\n  hasChildrenKey?: string; // Has children field name (default: 'hasChildren')\n}\n\nexport interface GridDragDropConfig {\n  enabled: boolean;\n  dragHandle?: string; // CSS selector for drag handle (default: 'tr')\n  orderField?: string; // Field name for storing order (default: 'order')\n  dragClass?: string; // CSS class to apply to dragged element\n  dropClass?: string; // CSS class to apply to drop target\n}\n\nexport interface GridConfiguration<T = Record<string, unknown>> {\n  // Basic Configuration\n  id: string;\n  title?: string;\n  subtitle?: string;\n  columns: GridColumn[];\n  \n  // Data Configuration\n  data: T[];\n  trackBy?: string; // Property to track items by (default: 'id' or '_id')\n  \n  // Feature Configuration\n  pagination: GridPaginationConfig;\n  search: GridSearchConfig;\n  export?: GridExportConfig;\n  loading: GridLoadingConfig;\n  scroll?: GridScrollConfig;\n  tree?: GridTreeConfig; // Tree structure configuration\n  dragDrop?: GridDragDropConfig; // Drag and drop configuration\n  \n  // Styling Configuration\n  responsive: boolean;\n  striped?: boolean;\n  bordered?: boolean;\n  compact?: boolean;\n  fullHeight?: boolean; // Enable full height mode for empty tables\n  \n  // Event Handlers (function names)\n  onRowClick?: string;\n  onSort?: string;\n  onPageChange?: string;\n  onSearch?: string;\n  onRefresh?: string;\n  onExport?: string;\n  onRowReorder?: string; // Row reorder event handler\n  \n  // Custom Classes\n  tableClass?: string;\n  headerClass?: string;\n  rowClass?: string;\n  cellClass?: string;\n}\n\nexport interface GridState<T = Record<string, unknown>> {\n  currentPage: number;\n  pageSize: number;\n  totalItems: number;\n  totalPages: number;\n  searchQuery: string;\n  sortColumn?: string;\n  sortDirection?: 'asc' | 'desc';\n  loading: boolean;\n  isRefreshing: boolean;\n  selectedRows: T[];\n}\n\nexport interface GridEvent<T = Record<string, unknown>> {\n  type: 'rowClick' | 'sort' | 'pageChange' | 'search' | 'refresh' | 'export' | 'action' | 'rowReorder';\n  data: T | T[] | string | number | null | {\n    sourceItem: T;\n    sourceIndex: number;\n    targetItem: T;\n    targetIndex: number;\n    newOrder: T[];\n  };\n  column?: GridColumn;\n  action?: GridAction;\n}\n\n// Default configurations\nexport const DEFAULT_GRID_CONFIG: Partial<GridConfiguration> = {\n  pagination: {\n    enabled: true,\n    pageSize: 10,\n    pageSizeOptions: [10, 25, 50, 100],\n    showQuickJump: true,\n    showPageInfo: true,\n    showRefresh: true\n  },\n  search: {\n    enabled: true,\n    placeholder: 'Search...',\n    searchableColumns: [],\n    debounceMs: 300\n  },\n  loading: {\n    useDefer: true,\n    skeletonRows: 5,\n    showOverlay: false\n  },\n  scroll: {\n    enabled: false,\n    maxHeight: '400px',\n    minHeight: '200px',\n    stickyHeader: true,\n    virtualScroll: false,\n    rowHeight: 40\n  },\n  responsive: true,\n  striped: false,\n  bordered: true,\n  compact: true,\n  fullHeight: true\n};\n\n// Utility types for type safety\nexport type GridEventHandler<T = Record<string, unknown>> = (event: GridEvent<T>) => void;\nexport type GridCustomRenderer<T = Record<string, unknown>> = (value: unknown, row: T, column: GridColumn) => string;\nexport type GridCustomFormatter = (value: unknown, format?: string) => string; "]}

package/esm2022/lib/components/dropdown/dropdown.component.mjs

@@ -0,0 +1,396 @@
+import { Component, Input, Output, EventEmitter, signal, viewChild, HostListener, DestroyRef, inject } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CideIconComponent } from '../../elements/icon/icon.component';
+import { DropdownManagerService } from '../../services/dropdown-manager.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class CideEleDropdownComponent {
+    constructor() {
+        this.destroyRef = inject(DestroyRef);
+        this.dropdownManager = inject(DropdownManagerService);
+        this.dropdownId = `dropdown-${Math.random().toString(36).substr(2, 9)}`;
+        // ViewChild for container reference
+        this.dropdownContainer = viewChild.required('dropdownContainer');
+        this.dropdownMenu = viewChild('dropdownMenu');
+        this._items = [];
+        this.config = {};
+        // Outputs
+        this.itemClick = new EventEmitter();
+        this.dropdownToggle = new EventEmitter();
+        // Signals
+        this.isOpen = signal(false);
+        this.currentPosition = signal({
+            vertical: 'bottom',
+            horizontal: 'right',
+            spaceAvailable: { top: 0, bottom: 0, left: 0, right: 0 }
+        });
+    }
+    // Inputs
+    set items(value) {
+        this._items = value;
+    }
+    get items() {
+        return this._items;
+    }
+    ngOnInit() {
+        // Setup cleanup on destroy
+        this.destroyRef.onDestroy(() => {
+            this.dropdownManager.unregisterDropdown(this.dropdownId);
+        });
+    }
+    ngOnDestroy() {
+        this.dropdownManager.unregisterDropdown(this.dropdownId);
+    }
+    // Methods
+    getTriggerClasses() {
+        const baseClasses = 'tw-inline-flex tw-items-center tw-justify-center tw-w-6 tw-h-6 tw-rounded-full tw-transition-all tw-duration-150 focus:tw-outline-none focus:tw-ring-2 focus:tw-ring-offset-2 focus:tw-ring-blue-500';
+        const colorClasses = this.config?.triggerColor || 'tw-text-gray-400';
+        const hoverColorClasses = this.config?.triggerHoverColor || 'hover:tw-text-gray-600';
+        const hoverBgClasses = this.config?.triggerHoverBgColor || 'hover:tw-bg-gray-100';
+        return `${baseClasses} ${colorClasses} ${hoverColorClasses} ${hoverBgClasses}`;
+    }
+    getTriggerIconClasses() {
+        return this.config?.triggerColor || 'tw-text-gray-400';
+    }
+    getMenuClasses() {
+        const baseClasses = 'tw-absolute tw-z-50 tw-rounded-md tw-bg-white tw-shadow-lg tw-ring-1 tw-ring-black tw-ring-opacity-5 focus:tw-outline-none tw-transition-all tw-duration-150';
+        const widthClass = this.config?.menuWidth || 'tw-w-44';
+        return `${baseClasses} ${widthClass}`;
+    }
+    getMenuStyles() {
+        const position = this.currentPosition();
+        const offsetX = this.config?.offsetX || 0;
+        const offsetY = this.config?.offsetY || 4;
+        let styles = 'position: absolute; z-index: 9999;';
+        // Vertical positioning
+        if (position.vertical === 'bottom') {
+            styles += `top: calc(100% + ${offsetY}px);`;
+        }
+        else {
+            styles += `bottom: calc(100% + ${offsetY}px);`;
+        }
+        // Horizontal positioning
+        if (position.horizontal === 'right') {
+            styles += `right: ${offsetX}px;`;
+        }
+        else {
+            styles += `left: ${offsetX}px;`;
+        }
+        return styles;
+    }
+    calculatePosition() {
+        const container = this.dropdownContainer();
+        if (!container) {
+            return {
+                vertical: 'bottom',
+                horizontal: 'right',
+                spaceAvailable: { top: 0, bottom: 0, left: 0, right: 0 }
+            };
+        }
+        const rect = container.nativeElement.getBoundingClientRect();
+        const viewport = {
+            width: window.innerWidth,
+            height: window.innerHeight
+        };
+        // Calculate available space in each direction
+        const spaceAvailable = {
+            top: rect.top,
+            bottom: viewport.height - rect.bottom,
+            left: rect.left,
+            right: viewport.width - rect.right
+        };
+        // Estimated dropdown menu dimensions (adjust based on your needs)
+        const menuWidth = this.getMenuWidth();
+        const menuHeight = this.getEstimatedMenuHeight();
+        // Determine vertical position
+        let vertical = 'bottom';
+        if (this.config?.forcePosition === 'top' || this.config?.forcePosition === 'bottom') {
+            vertical = this.config.forcePosition;
+        }
+        else {
+            // Check if there's enough space below
+            if (spaceAvailable.bottom < menuHeight && spaceAvailable.top > menuHeight) {
+                vertical = 'top';
+            }
+        }
+        // Determine horizontal position  
+        let horizontal = 'right';
+        if (this.config?.forcePosition === 'left' || this.config?.forcePosition === 'right') {
+            horizontal = this.config.forcePosition;
+        }
+        else if (this.config?.menuPosition === 'left') {
+            horizontal = 'left';
+        }
+        else if (this.config?.menuPosition === 'auto') {
+            // Auto-detect best horizontal position
+            if (spaceAvailable.right < menuWidth && spaceAvailable.left > menuWidth) {
+                horizontal = 'left';
+            }
+        }
+        return {
+            vertical,
+            horizontal,
+            spaceAvailable
+        };
+    }
+    getMenuWidth() {
+        // Parse width from config or use default
+        const configWidth = this.config?.menuWidth || 'tw-w-44';
+        if (configWidth.includes('tw-w-')) {
+            const widthMap = {
+                'tw-w-32': 128, 'tw-w-36': 144, 'tw-w-40': 160,
+                'tw-w-44': 176, 'tw-w-48': 192, 'tw-w-52': 208,
+                'tw-w-56': 224, 'tw-w-60': 240, 'tw-w-64': 256
+            };
+            return widthMap[configWidth] || 176;
+        }
+        return 176; // Default width
+    }
+    getEstimatedMenuHeight() {
+        // Estimate height based on number of items
+        const itemHeight = 40; // Approximate height per item
+        const padding = 8; // Top and bottom padding
+        return (this.items.length * itemHeight) + padding;
+    }
+    toggleDropdown(event) {
+        console.log('🔵 toggleDropdown called');
+        event.stopPropagation();
+        if (!this.isOpen()) {
+            this.openDropdown();
+        }
+        else {
+            this.closeDropdown();
+        }
+    }
+    openDropdown() {
+        // Calculate position before opening
+        const newPosition = this.calculatePosition();
+        this.currentPosition.set(newPosition);
+        this.isOpen.set(true);
+        // Register with dropdown manager
+        const dropdownInstance = {
+            id: this.dropdownId,
+            close: () => this.closeDropdown(),
+            element: this.dropdownContainer().nativeElement
+        };
+        this.dropdownManager.registerDropdown(dropdownInstance);
+        console.log('🔵 Dropdown opened:', this.dropdownId);
+        console.log('🔵 Position:', this.currentPosition());
+        this.dropdownToggle.emit(true);
+    }
+    testMouseDown(item) {
+        console.log('🔵 Mouse down detected: ' + item.label);
+        // Don't close dropdown on mousedown
+    }
+    onItemClick(item, event) {
+        console.log('🔵 Dropdown onItemClick called with:', item);
+        // Simple event handling
+        event.stopPropagation();
+        if (item.disabled || item.divider) {
+            console.log('🔵 Item is disabled or divider, returning');
+            return;
+        }
+        console.log('🔵 Emitting itemClick event');
+        this.itemClick.emit(item);
+        // Close dropdown after a small delay to ensure click is processed
+        setTimeout(() => {
+            this.closeDropdown();
+        }, 50);
+    }
+    closeDropdown() {
+        console.log('🔵 closeDropdown called, setting isOpen to false');
+        this.isOpen.set(false);
+        this.dropdownManager.unregisterDropdown(this.dropdownId);
+        this.dropdownToggle.emit(false);
+    }
+    getItemClasses(item) {
+        if (item.divider) {
+            return 'tw-border-t tw-border-gray-200 tw-my-1';
+        }
+        const baseClasses = 'tw-flex tw-items-center tw-w-full tw-px-3 tw-py-2 tw-text-sm tw-transition-colors tw-duration-150';
+        if (item.disabled) {
+            return `${baseClasses} tw-text-gray-400 tw-cursor-not-allowed`;
+        }
+        const textColor = item.textColor || 'tw-text-gray-700';
+        const hoverBg = item.hoverBgColor || 'hover:tw-bg-gray-100';
+        const hoverText = item.textColor || 'hover:tw-text-gray-900';
+        return `${baseClasses} ${textColor} ${hoverBg} ${hoverText}`;
+    }
+    // Host listeners for window events (position recalculation only)
+    // Note: Click outside and escape key handling is now managed by DropdownManagerService
+    onWindowResize() {
+        if (this.isOpen()) {
+            // Recalculate position on window resize
+            const newPosition = this.calculatePosition();
+            this.currentPosition.set(newPosition);
+        }
+    }
+    onWindowScroll() {
+        if (this.isOpen()) {
+            // Recalculate position on scroll
+            const newPosition = this.calculatePosition();
+            this.currentPosition.set(newPosition);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleDropdownComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.7", type: CideEleDropdownComponent, isStandalone: true, selector: "cide-ele-dropdown", inputs: { items: "items", config: "config", triggerTemplate: "triggerTemplate", menuTemplate: "menuTemplate" }, outputs: { itemClick: "itemClick", dropdownToggle: "dropdownToggle" }, host: { listeners: { "window:resize": "onWindowResize()", "window:scroll": "onWindowScroll($event)" } }, viewQueries: [{ propertyName: "dropdownContainer", first: true, predicate: ["dropdownContainer"], descendants: true, isSignal: true }, { propertyName: "dropdownMenu", first: true, predicate: ["dropdownMenu"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    <div class="tw-relative" #dropdownContainer>
+      <!-- Trigger Button -->
+      <button 
+        type="button" 
+        class="dropdown-trigger tw-inline-flex tw-items-center tw-justify-center tw-w-6 tw-h-6 tw-rounded-full tw-text-gray-400 hover:tw-text-gray-600 hover:tw-bg-gray-100 focus:tw-outline-none focus:tw-ring-2 focus:tw-ring-offset-2 focus:tw-ring-blue-500 tw-transition-all tw-duration-150"
+        [class]="getTriggerClasses()"
+        (click)="toggleDropdown($event)"
+        [title]="config.triggerIcon === 'more_vert' ? 'More actions' : 'Options'">
+        
+                 <!-- Custom Trigger Template -->
+         @if (triggerTemplate) {
+           <ng-container *ngTemplateOutlet="triggerTemplate; context: { $implicit: isOpen() }">
+           </ng-container>
+         } @else {
+           <!-- Default Trigger -->
+           <cide-ele-icon 
+             [class]="getTriggerIconClasses()"
+             [size]="config.triggerSize || 'sm'">
+             {{ config.triggerIcon || 'more_vert' }}
+           </cide-ele-icon>
+         }
+      </button>
+      
+             <!-- Dropdown Menu -->
+       @if (isOpen()) {
+         <div 
+           #dropdownMenu
+           class="dropdown-menu tw-absolute tw-z-50 tw-bg-white tw-shadow-lg tw-border tw-border-gray-200 tw-rounded-md tw-text-black"
+           [class]="getMenuClasses()"
+           [style]="getMenuStyles()"
+           role="menu">
+        
+                 <!-- Custom Menu Template -->
+         @if (menuTemplate) {
+           <ng-container *ngTemplateOutlet="menuTemplate; context: { $implicit: items }">
+           </ng-container>
+         } @else {
+           <!-- Default Menu -->
+           <div class="tw-py-1" role="none">
+             @for (item of items; track item.id) {
+               <button 
+                 type="button"
+                 class="tw-flex tw-items-center tw-w-full tw-px-3 tw-py-2 tw-text-sm tw-text-gray-700 hover:tw-bg-gray-100 hover:tw-text-gray-900 tw-transition-colors tw-duration-150"
+                 [disabled]="item.disabled"
+                 (click)="onItemClick(item, $event)"
+                 [attr.data-item-id]="item.id">
+                 
+                 <!-- Item Icon -->
+                 @if (item.icon) {
+                   <cide-ele-icon 
+                     class="tw-w-4 tw-h-4 tw-mr-2"
+                     [class]="item.iconColor || 'tw-text-gray-400'"
+                     size="xs">
+                     {{ item.icon }}
+                   </cide-ele-icon>
+                 }
+                 
+                 <!-- Item Label -->
+                 <span [class]="item.textColor || 'tw-text-gray-700'">
+                   {{ item.label }}
+                 </span>
+               </button>
+             }
+           </div>
+                  }
+       </div>
+     }
+   `, isInline: true, styles: [".dropdown-menu{transform-origin:top right}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: CideIconComponent, selector: "cide-ele-icon", inputs: ["size", "type", "toolTip"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleDropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cide-ele-dropdown', standalone: true, imports: [CommonModule, CideIconComponent], template: `
+    <div class="tw-relative" #dropdownContainer>
+      <!-- Trigger Button -->
+      <button 
+        type="button" 
+        class="dropdown-trigger tw-inline-flex tw-items-center tw-justify-center tw-w-6 tw-h-6 tw-rounded-full tw-text-gray-400 hover:tw-text-gray-600 hover:tw-bg-gray-100 focus:tw-outline-none focus:tw-ring-2 focus:tw-ring-offset-2 focus:tw-ring-blue-500 tw-transition-all tw-duration-150"
+        [class]="getTriggerClasses()"
+        (click)="toggleDropdown($event)"
+        [title]="config.triggerIcon === 'more_vert' ? 'More actions' : 'Options'">
+        
+                 <!-- Custom Trigger Template -->
+         @if (triggerTemplate) {
+           <ng-container *ngTemplateOutlet="triggerTemplate; context: { $implicit: isOpen() }">
+           </ng-container>
+         } @else {
+           <!-- Default Trigger -->
+           <cide-ele-icon 
+             [class]="getTriggerIconClasses()"
+             [size]="config.triggerSize || 'sm'">
+             {{ config.triggerIcon || 'more_vert' }}
+           </cide-ele-icon>
+         }
+      </button>
+      
+             <!-- Dropdown Menu -->
+       @if (isOpen()) {
+         <div 
+           #dropdownMenu
+           class="dropdown-menu tw-absolute tw-z-50 tw-bg-white tw-shadow-lg tw-border tw-border-gray-200 tw-rounded-md tw-text-black"
+           [class]="getMenuClasses()"
+           [style]="getMenuStyles()"
+           role="menu">
+        
+                 <!-- Custom Menu Template -->
+         @if (menuTemplate) {
+           <ng-container *ngTemplateOutlet="menuTemplate; context: { $implicit: items }">
+           </ng-container>
+         } @else {
+           <!-- Default Menu -->
+           <div class="tw-py-1" role="none">
+             @for (item of items; track item.id) {
+               <button 
+                 type="button"
+                 class="tw-flex tw-items-center tw-w-full tw-px-3 tw-py-2 tw-text-sm tw-text-gray-700 hover:tw-bg-gray-100 hover:tw-text-gray-900 tw-transition-colors tw-duration-150"
+                 [disabled]="item.disabled"
+                 (click)="onItemClick(item, $event)"
+                 [attr.data-item-id]="item.id">
+                 
+                 <!-- Item Icon -->
+                 @if (item.icon) {
+                   <cide-ele-icon 
+                     class="tw-w-4 tw-h-4 tw-mr-2"
+                     [class]="item.iconColor || 'tw-text-gray-400'"
+                     size="xs">
+                     {{ item.icon }}
+                   </cide-ele-icon>
+                 }
+                 
+                 <!-- Item Label -->
+                 <span [class]="item.textColor || 'tw-text-gray-700'">
+                   {{ item.label }}
+                 </span>
+               </button>
+             }
+           </div>
+                  }
+       </div>
+     }
+   `, styles: [".dropdown-menu{transform-origin:top right}\n"] }]
+        }], propDecorators: { items: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], triggerTemplate: [{
+                type: Input
+            }], menuTemplate: [{
+                type: Input
+            }], itemClick: [{
+                type: Output
+            }], dropdownToggle: [{
+                type: Output
+            }], onWindowResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }], onWindowScroll: [{
+                type: HostListener,
+                args: ['window:scroll', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown.component.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-element/src/lib/components/dropdown/dropdown.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, signal, viewChild, TemplateRef, ElementRef, HostListener, DestroyRef, inject, OnInit, OnDestroy } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { CideIconComponent } from '../../elements/icon/icon.component';\nimport { DropdownManagerService, DropdownInstance } from '../../services/dropdown-manager.service';\n\nexport interface DropdownItem {\n    id: string;\n    label: string;\n    icon?: string;\n    iconColor?: string;\n    textColor?: string;\n    hoverBgColor?: string;\n    disabled?: boolean;\n    divider?: boolean;\n}\n\nexport interface DropdownConfig {\n    triggerIcon?: string;\n    triggerSize?: 'xs' | 'sm' | 'md' | 'lg';\n    triggerColor?: string;\n    triggerHoverColor?: string;\n    triggerHoverBgColor?: string;\n    menuWidth?: string;\n    menuPosition?: 'left' | 'right' | 'auto';\n    showArrow?: boolean;\n    forcePosition?: 'top' | 'bottom' | 'left' | 'right';\n    offsetX?: number;\n    offsetY?: number;\n}\n\nexport interface DropdownPosition {\n    vertical: 'top' | 'bottom';\n    horizontal: 'left' | 'right';\n    spaceAvailable: {\n        top: number;\n        bottom: number;\n        left: number;\n        right: number;\n    };\n}\n\n@Component({\n    selector: 'cide-ele-dropdown',\n    standalone: true,\n    imports: [CommonModule, CideIconComponent],\n    template: `\n    <div class=\"tw-relative\" #dropdownContainer>\n      <!-- Trigger Button -->\n      <button \n        type=\"button\" \n        class=\"dropdown-trigger tw-inline-flex tw-items-center tw-justify-center tw-w-6 tw-h-6 tw-rounded-full tw-text-gray-400 hover:tw-text-gray-600 hover:tw-bg-gray-100 focus:tw-outline-none focus:tw-ring-2 focus:tw-ring-offset-2 focus:tw-ring-blue-500 tw-transition-all tw-duration-150\"\n        [class]=\"getTriggerClasses()\"\n        (click)=\"toggleDropdown($event)\"\n        [title]=\"config.triggerIcon === 'more_vert' ? 'More actions' : 'Options'\">\n        \n                 <!-- Custom Trigger Template -->\n         @if (triggerTemplate) {\n           <ng-container *ngTemplateOutlet=\"triggerTemplate; context: { $implicit: isOpen() }\">\n           </ng-container>\n         } @else {\n           <!-- Default Trigger -->\n           <cide-ele-icon \n             [class]=\"getTriggerIconClasses()\"\n             [size]=\"config.triggerSize || 'sm'\">\n             {{ config.triggerIcon || 'more_vert' }}\n           </cide-ele-icon>\n         }\n      </button>\n      \n             <!-- Dropdown Menu -->\n       @if (isOpen()) {\n         <div \n           #dropdownMenu\n           class=\"dropdown-menu tw-absolute tw-z-50 tw-bg-white tw-shadow-lg tw-border tw-border-gray-200 tw-rounded-md tw-text-black\"\n           [class]=\"getMenuClasses()\"\n           [style]=\"getMenuStyles()\"\n           role=\"menu\">\n        \n                 <!-- Custom Menu Template -->\n         @if (menuTemplate) {\n           <ng-container *ngTemplateOutlet=\"menuTemplate; context: { $implicit: items }\">\n           </ng-container>\n         } @else {\n           <!-- Default Menu -->\n           <div class=\"tw-py-1\" role=\"none\">\n             @for (item of items; track item.id) {\n               <button \n                 type=\"button\"\n                 class=\"tw-flex tw-items-center tw-w-full tw-px-3 tw-py-2 tw-text-sm tw-text-gray-700 hover:tw-bg-gray-100 hover:tw-text-gray-900 tw-transition-colors tw-duration-150\"\n                 [disabled]=\"item.disabled\"\n                 (click)=\"onItemClick(item, $event)\"\n                 [attr.data-item-id]=\"item.id\">\n                 \n                 <!-- Item Icon -->\n                 @if (item.icon) {\n                   <cide-ele-icon \n                     class=\"tw-w-4 tw-h-4 tw-mr-2\"\n                     [class]=\"item.iconColor || 'tw-text-gray-400'\"\n                     size=\"xs\">\n                     {{ item.icon }}\n                   </cide-ele-icon>\n                 }\n                 \n                 <!-- Item Label -->\n                 <span [class]=\"item.textColor || 'tw-text-gray-700'\">\n                   {{ item.label }}\n                 </span>\n               </button>\n             }\n           </div>\n                  }\n       </div>\n     }\n   `,\n    styles: [`\n    .dropdown-menu {\n      transform-origin: top right;\n    }\n  `]\n})\nexport class CideEleDropdownComponent implements OnInit, OnDestroy {\n    private destroyRef = inject(DestroyRef);\n    private dropdownManager = inject(DropdownManagerService);\n    private dropdownId = `dropdown-${Math.random().toString(36).substr(2, 9)}`;\n\n    // ViewChild for container reference\n    dropdownContainer = viewChild.required<ElementRef>('dropdownContainer');\n    dropdownMenu = viewChild<ElementRef>('dropdownMenu');\n\n      // Inputs\n  @Input() set items(value: DropdownItem[]) {\n      this._items = value;\n  }\n    get items(): DropdownItem[] {\n        return this._items;\n    }\n    private _items: DropdownItem[] = [];\n\n    @Input() config: DropdownConfig = {};\n    @Input() triggerTemplate?: TemplateRef<{ $implicit: boolean }>;\n    @Input() menuTemplate?: TemplateRef<{ $implicit: DropdownItem[] }>;\n\n    // Outputs\n    @Output() itemClick = new EventEmitter<DropdownItem>();\n    @Output() dropdownToggle = new EventEmitter<boolean>();\n\n    // Signals\n    isOpen = signal(false);\n    currentPosition = signal<DropdownPosition>({\n        vertical: 'bottom',\n        horizontal: 'right',\n        spaceAvailable: { top: 0, bottom: 0, left: 0, right: 0 }\n    });\n\n    ngOnInit(): void {\n        // Setup cleanup on destroy\n        this.destroyRef.onDestroy(() => {\n            this.dropdownManager.unregisterDropdown(this.dropdownId);\n        });\n    }\n\n    ngOnDestroy(): void {\n        this.dropdownManager.unregisterDropdown(this.dropdownId);\n    }\n\n    // Methods\n    getTriggerClasses(): string {\n        const baseClasses = 'tw-inline-flex tw-items-center tw-justify-center tw-w-6 tw-h-6 tw-rounded-full tw-transition-all tw-duration-150 focus:tw-outline-none focus:tw-ring-2 focus:tw-ring-offset-2 focus:tw-ring-blue-500';\n\n        const colorClasses = this.config?.triggerColor || 'tw-text-gray-400';\n        const hoverColorClasses = this.config?.triggerHoverColor || 'hover:tw-text-gray-600';\n        const hoverBgClasses = this.config?.triggerHoverBgColor || 'hover:tw-bg-gray-100';\n\n        return `${baseClasses} ${colorClasses} ${hoverColorClasses} ${hoverBgClasses}`;\n    }\n\n    getTriggerIconClasses(): string {\n        return this.config?.triggerColor || 'tw-text-gray-400';\n    }\n\n    getMenuClasses(): string {\n        const baseClasses = 'tw-absolute tw-z-50 tw-rounded-md tw-bg-white tw-shadow-lg tw-ring-1 tw-ring-black tw-ring-opacity-5 focus:tw-outline-none tw-transition-all tw-duration-150';\n        const widthClass = this.config?.menuWidth || 'tw-w-44';\n        \n        return `${baseClasses} ${widthClass}`;\n    }\n\n    getMenuStyles(): string {\n        const position = this.currentPosition();\n        const offsetX = this.config?.offsetX || 0;\n        const offsetY = this.config?.offsetY || 4;\n        \n        let styles = 'position: absolute; z-index: 9999;';\n        \n        // Vertical positioning\n        if (position.vertical === 'bottom') {\n            styles += `top: calc(100% + ${offsetY}px);`;\n        } else {\n            styles += `bottom: calc(100% + ${offsetY}px);`;\n        }\n        \n        // Horizontal positioning\n        if (position.horizontal === 'right') {\n            styles += `right: ${offsetX}px;`;\n        } else {\n            styles += `left: ${offsetX}px;`;\n        }\n        \n        return styles;\n    }\n\n    calculatePosition(): DropdownPosition {\n        const container = this.dropdownContainer();\n        if (!container) {\n            return {\n                vertical: 'bottom',\n                horizontal: 'right',\n                spaceAvailable: { top: 0, bottom: 0, left: 0, right: 0 }\n            };\n        }\n\n        const rect = container.nativeElement.getBoundingClientRect();\n        const viewport = {\n            width: window.innerWidth,\n            height: window.innerHeight\n        };\n\n        // Calculate available space in each direction\n        const spaceAvailable = {\n            top: rect.top,\n            bottom: viewport.height - rect.bottom,\n            left: rect.left,\n            right: viewport.width - rect.right\n        };\n\n        // Estimated dropdown menu dimensions (adjust based on your needs)\n        const menuWidth = this.getMenuWidth();\n        const menuHeight = this.getEstimatedMenuHeight();\n\n        // Determine vertical position\n        let vertical: 'top' | 'bottom' = 'bottom';\n        if (this.config?.forcePosition === 'top' || this.config?.forcePosition === 'bottom') {\n            vertical = this.config.forcePosition;\n        } else {\n            // Check if there's enough space below\n            if (spaceAvailable.bottom < menuHeight && spaceAvailable.top > menuHeight) {\n                vertical = 'top';\n            }\n        }\n\n        // Determine horizontal position  \n        let horizontal: 'left' | 'right' = 'right';\n        if (this.config?.forcePosition === 'left' || this.config?.forcePosition === 'right') {\n            horizontal = this.config.forcePosition;\n        } else if (this.config?.menuPosition === 'left') {\n            horizontal = 'left';\n        } else if (this.config?.menuPosition === 'auto') {\n            // Auto-detect best horizontal position\n            if (spaceAvailable.right < menuWidth && spaceAvailable.left > menuWidth) {\n                horizontal = 'left';\n            }\n        }\n\n        return {\n            vertical,\n            horizontal,\n            spaceAvailable\n        };\n    }\n\n    private getMenuWidth(): number {\n        // Parse width from config or use default\n        const configWidth = this.config?.menuWidth || 'tw-w-44';\n        if (configWidth.includes('tw-w-')) {\n            const widthMap: { [key: string]: number } = {\n                'tw-w-32': 128, 'tw-w-36': 144, 'tw-w-40': 160,\n                'tw-w-44': 176, 'tw-w-48': 192, 'tw-w-52': 208,\n                'tw-w-56': 224, 'tw-w-60': 240, 'tw-w-64': 256\n            };\n            return widthMap[configWidth] || 176;\n        }\n        return 176; // Default width\n    }\n\n    private getEstimatedMenuHeight(): number {\n        // Estimate height based on number of items\n        const itemHeight = 40; // Approximate height per item\n        const padding = 8; // Top and bottom padding\n        return (this.items.length * itemHeight) + padding;\n    }\n\n    toggleDropdown(event: Event): void {\n        console.log('🔵 toggleDropdown called');\n        event.stopPropagation();\n        \n        if (!this.isOpen()) {\n            this.openDropdown();\n        } else {\n            this.closeDropdown();\n        }\n    }\n\n    private openDropdown(): void {\n        // Calculate position before opening\n        const newPosition = this.calculatePosition();\n        this.currentPosition.set(newPosition);\n        \n        this.isOpen.set(true);\n        \n        // Register with dropdown manager\n        const dropdownInstance: DropdownInstance = {\n            id: this.dropdownId,\n            close: () => this.closeDropdown(),\n            element: this.dropdownContainer().nativeElement\n        };\n        \n        this.dropdownManager.registerDropdown(dropdownInstance);\n        \n        console.log('🔵 Dropdown opened:', this.dropdownId);\n        console.log('🔵 Position:', this.currentPosition());\n        this.dropdownToggle.emit(true);\n    }\n\n  testMouseDown(item: DropdownItem): void {\n      console.log('🔵 Mouse down detected: ' + item.label);\n      // Don't close dropdown on mousedown\n  }\n\n  onItemClick(item: DropdownItem, event: Event): void {\n      console.log('🔵 Dropdown onItemClick called with:', item);\n\n      // Simple event handling\n      event.stopPropagation();\n\n      if (item.disabled || item.divider) {\n          console.log('🔵 Item is disabled or divider, returning');\n          return;\n      }\n\n      console.log('🔵 Emitting itemClick event');\n      this.itemClick.emit(item);\n\n      // Close dropdown after a small delay to ensure click is processed\n      setTimeout(() => {\n          this.closeDropdown();\n      }, 50);\n  }\n\n    closeDropdown(): void {\n        console.log('🔵 closeDropdown called, setting isOpen to false');\n        this.isOpen.set(false);\n        this.dropdownManager.unregisterDropdown(this.dropdownId);\n        this.dropdownToggle.emit(false);\n    }\n\n    getItemClasses(item: DropdownItem): string {\n        if (item.divider) {\n            return 'tw-border-t tw-border-gray-200 tw-my-1';\n        }\n\n        const baseClasses = 'tw-flex tw-items-center tw-w-full tw-px-3 tw-py-2 tw-text-sm tw-transition-colors tw-duration-150';\n\n        if (item.disabled) {\n            return `${baseClasses} tw-text-gray-400 tw-cursor-not-allowed`;\n        }\n\n        const textColor = item.textColor || 'tw-text-gray-700';\n        const hoverBg = item.hoverBgColor || 'hover:tw-bg-gray-100';\n        const hoverText = item.textColor || 'hover:tw-text-gray-900';\n\n        return `${baseClasses} ${textColor} ${hoverBg} ${hoverText}`;\n    }\n\n    // Host listeners for window events (position recalculation only)\n    // Note: Click outside and escape key handling is now managed by DropdownManagerService\n\n    @HostListener('window:resize')\n    onWindowResize(): void {\n        if (this.isOpen()) {\n            // Recalculate position on window resize\n            const newPosition = this.calculatePosition();\n            this.currentPosition.set(newPosition);\n        }\n    }\n\n    @HostListener('window:scroll', ['$event'])\n    onWindowScroll(): void {\n        if (this.isOpen()) {\n            // Recalculate position on scroll\n            const newPosition = this.calculatePosition();\n            this.currentPosition.set(newPosition);\n        }\n    }\n} "]}

package/esm2022/lib/components/global-notifications/global-notifications.component.mjs

@@ -0,0 +1,30 @@
+import { Component } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CideEleConfirmationModalComponent } from '../confirmation-modal/confirmation-modal.component';
+import { CideEleToastNotificationComponent } from '../toast-notification/toast-notification.component';
+import * as i0 from "@angular/core";
+export class CideEleGlobalNotificationsComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleGlobalNotificationsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.7", type: CideEleGlobalNotificationsComponent, isStandalone: true, selector: "cide-ele-global-notifications", ngImport: i0, template: `
+    <!-- Global Confirmation Modal -->
+    <cide-ele-confirmation-modal></cide-ele-confirmation-modal>
+    
+    <!-- Global Toast Notifications -->
+    <cide-ele-toast-notification></cide-ele-toast-notification>
+  `, isInline: true, styles: [":host{display:contents}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: CideEleConfirmationModalComponent, selector: "cide-ele-confirmation-modal" }, { kind: "component", type: CideEleToastNotificationComponent, selector: "cide-ele-toast-notification" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleGlobalNotificationsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cide-ele-global-notifications', standalone: true, imports: [
+                        CommonModule,
+                        CideEleConfirmationModalComponent,
+                        CideEleToastNotificationComponent
+                    ], template: `
+    <!-- Global Confirmation Modal -->
+    <cide-ele-confirmation-modal></cide-ele-confirmation-modal>
+    
+    <!-- Global Toast Notifications -->
+    <cide-ele-toast-notification></cide-ele-toast-notification>
+  `, styles: [":host{display:contents}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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