cloud-ide-element 0.0.1 → 1.0.2

package/esm2022/lib/services/notification.service.mjs

@@ -0,0 +1,196 @@
+import { Injectable, signal, computed } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NotificationService {
+    constructor() {
+        this.notifications = signal([]);
+        this.maxNotifications = 5; // Maximum notifications to show at once
+        // Computed signals
+        this.activeNotifications = computed(() => this.notifications().filter(n => n.isVisible));
+    }
+    /**
+     * Show a success notification
+     */
+    success(message, options) {
+        return this.show({
+            message,
+            type: 'success',
+            icon: 'check_circle',
+            duration: 3000,
+            ...options
+        });
+    }
+    /**
+     * Show an error notification
+     */
+    error(message, options) {
+        return this.show({
+            message,
+            type: 'error',
+            icon: 'error',
+            duration: 5000,
+            ...options
+        });
+    }
+    /**
+     * Show a warning notification
+     */
+    warning(message, options) {
+        return this.show({
+            message,
+            type: 'warning',
+            icon: 'warning',
+            duration: 4000,
+            ...options
+        });
+    }
+    /**
+     * Show an info notification
+     */
+    info(message, options) {
+        return this.show({
+            message,
+            type: 'info',
+            icon: 'info',
+            duration: 3000,
+            ...options
+        });
+    }
+    /**
+     * Show a notification with undo functionality
+     */
+    showWithUndo(message, undoAction, options) {
+        return this.show({
+            message,
+            type: 'info',
+            icon: 'info',
+            duration: 8000,
+            showUndo: true,
+            undoAction,
+            undoText: 'Undo',
+            ...options
+        });
+    }
+    /**
+     * Show a notification for reversible destructive actions
+     */
+    showReversibleAction(action, itemName, undoAction, options) {
+        return this.showWithUndo(`${action} "${itemName}"`, undoAction, {
+            type: 'warning',
+            icon: 'delete',
+            title: `${action} completed`,
+            ...options
+        });
+    }
+    /**
+     * Show a notification for background tasks
+     */
+    showBackgroundTask(taskName, isComplete = true, options) {
+        return this.show({
+            message: isComplete ? `${taskName} completed successfully` : `${taskName} in progress...`,
+            type: isComplete ? 'success' : 'info',
+            icon: isComplete ? 'check_circle' : 'sync',
+            duration: isComplete ? 3000 : 0, // Don't auto-dismiss for in-progress tasks
+            ...options
+        });
+    }
+    /**
+     * Core show method
+     */
+    show(options) {
+        const notification = {
+            id: this.generateId(),
+            message: options.message,
+            type: options.type || 'info',
+            duration: options.duration || 3000,
+            showUndo: options.showUndo || false,
+            undoAction: options.undoAction,
+            undoText: options.undoText || 'Undo',
+            icon: options.icon || this.getDefaultIcon(options.type || 'info'),
+            title: options.title,
+            timestamp: Date.now(),
+            isVisible: true
+        };
+        this.addNotification(notification);
+        return notification.id;
+    }
+    /**
+     * Remove a specific notification
+     */
+    remove(id) {
+        this.notifications.update(notifications => notifications.map(n => n.id === id ? { ...n, isVisible: false } : n));
+        // Remove from array after animation
+        setTimeout(() => {
+            this.notifications.update(notifications => notifications.filter(n => n.id !== id));
+        }, 300);
+    }
+    /**
+     * Remove all notifications
+     */
+    clearAll() {
+        this.notifications.update(notifications => notifications.map(n => ({ ...n, isVisible: false })));
+        setTimeout(() => {
+            this.notifications.set([]);
+        }, 300);
+    }
+    /**
+     * Execute undo action for a notification
+     */
+    executeUndo(id) {
+        const notification = this.notifications().find(n => n.id === id);
+        if (notification && notification.undoAction) {
+            notification.undoAction();
+            this.remove(id);
+        }
+    }
+    // Internal methods
+    addNotification(notification) {
+        this.notifications.update(notifications => {
+            const newNotifications = [...notifications, notification];
+            // Limit the number of visible notifications
+            if (newNotifications.length > this.maxNotifications) {
+                // Remove oldest notifications
+                const toRemove = newNotifications.length - this.maxNotifications;
+                for (let i = 0; i < toRemove; i++) {
+                    if (newNotifications[i]) {
+                        newNotifications[i] = { ...newNotifications[i], isVisible: false };
+                    }
+                }
+            }
+            return newNotifications;
+        });
+        // Auto-remove after duration (if not 0)
+        if (notification.duration > 0) {
+            setTimeout(() => {
+                this.remove(notification.id);
+            }, notification.duration);
+        }
+    }
+    generateId() {
+        return `notification-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    getDefaultIcon(type) {
+        const iconMap = {
+            success: 'check_circle',
+            error: 'error',
+            warning: 'warning',
+            info: 'info'
+        };
+        return iconMap[type];
+    }
+    // Public getters for components
+    getNotifications() {
+        return this.notifications;
+    }
+    getActiveNotifications() {
+        return this.activeNotifications;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: NotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.service.js","sourceRoot":"","sources":["../../../../../projects/cloud-ide-element/src/lib/services/notification.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed } from '@angular/core';\r\nimport { Observable, Subject } from 'rxjs';\r\n\r\nexport interface NotificationOptions {\r\n  message: string;\r\n  type?: 'success' | 'error' | 'warning' | 'info';\r\n  duration?: number;\r\n  showUndo?: boolean;\r\n  undoAction?: () => void;\r\n  undoText?: string;\r\n  icon?: string;\r\n  title?: string;\r\n}\r\n\r\nexport interface NotificationItem {\r\n  id: string;\r\n  message: string;\r\n  type: 'success' | 'error' | 'warning' | 'info';\r\n  duration: number;\r\n  showUndo: boolean;\r\n  undoAction?: () => void;\r\n  undoText: string;\r\n  icon: string;\r\n  title?: string;\r\n  timestamp: number;\r\n  isVisible: boolean;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class NotificationService {\r\n  private notifications = signal<NotificationItem[]>([]);\r\n  private maxNotifications = 5; // Maximum notifications to show at once\r\n\r\n  // Computed signals\r\n  activeNotifications = computed(() => \r\n    this.notifications().filter(n => n.isVisible)\r\n  );\r\n\r\n  constructor() {}\r\n\r\n  /**\r\n   * Show a success notification\r\n   */\r\n  success(message: string, options?: Partial<NotificationOptions>): string {\r\n    return this.show({\r\n      message,\r\n      type: 'success',\r\n      icon: 'check_circle',\r\n      duration: 3000,\r\n      ...options\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show an error notification\r\n   */\r\n  error(message: string, options?: Partial<NotificationOptions>): string {\r\n    return this.show({\r\n      message,\r\n      type: 'error',\r\n      icon: 'error',\r\n      duration: 5000,\r\n      ...options\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show a warning notification\r\n   */\r\n  warning(message: string, options?: Partial<NotificationOptions>): string {\r\n    return this.show({\r\n      message,\r\n      type: 'warning',\r\n      icon: 'warning',\r\n      duration: 4000,\r\n      ...options\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show an info notification\r\n   */\r\n  info(message: string, options?: Partial<NotificationOptions>): string {\r\n    return this.show({\r\n      message,\r\n      type: 'info',\r\n      icon: 'info',\r\n      duration: 3000,\r\n      ...options\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show a notification with undo functionality\r\n   */\r\n  showWithUndo(\r\n    message: string, \r\n    undoAction: () => void, \r\n    options?: Partial<NotificationOptions>\r\n  ): string {\r\n    return this.show({\r\n      message,\r\n      type: 'info',\r\n      icon: 'info',\r\n      duration: 8000,\r\n      showUndo: true,\r\n      undoAction,\r\n      undoText: 'Undo',\r\n      ...options\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Show a notification for reversible destructive actions\r\n   */\r\n  showReversibleAction(\r\n    action: string,\r\n    itemName: string,\r\n    undoAction: () => void,\r\n    options?: Partial<NotificationOptions>\r\n  ): string {\r\n    return this.showWithUndo(\r\n      `${action} \"${itemName}\"`,\r\n      undoAction,\r\n      {\r\n        type: 'warning',\r\n        icon: 'delete',\r\n        title: `${action} completed`,\r\n        ...options\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Show a notification for background tasks\r\n   */\r\n  showBackgroundTask(\r\n    taskName: string,\r\n    isComplete: boolean = true,\r\n    options?: Partial<NotificationOptions>\r\n  ): string {\r\n    return this.show({\r\n      message: isComplete ? `${taskName} completed successfully` : `${taskName} in progress...`,\r\n      type: isComplete ? 'success' : 'info',\r\n      icon: isComplete ? 'check_circle' : 'sync',\r\n      duration: isComplete ? 3000 : 0, // Don't auto-dismiss for in-progress tasks\r\n      ...options\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Core show method\r\n   */\r\n  private show(options: NotificationOptions): string {\r\n    const notification: NotificationItem = {\r\n      id: this.generateId(),\r\n      message: options.message,\r\n      type: options.type || 'info',\r\n      duration: options.duration || 3000,\r\n      showUndo: options.showUndo || false,\r\n      undoAction: options.undoAction,\r\n      undoText: options.undoText || 'Undo',\r\n      icon: options.icon || this.getDefaultIcon(options.type || 'info'),\r\n      title: options.title,\r\n      timestamp: Date.now(),\r\n      isVisible: true\r\n    };\r\n\r\n    this.addNotification(notification);\r\n    return notification.id;\r\n  }\r\n\r\n  /**\r\n   * Remove a specific notification\r\n   */\r\n  remove(id: string): void {\r\n    this.notifications.update(notifications => \r\n      notifications.map(n => \r\n        n.id === id ? { ...n, isVisible: false } : n\r\n      )\r\n    );\r\n\r\n    // Remove from array after animation\r\n    setTimeout(() => {\r\n      this.notifications.update(notifications => \r\n        notifications.filter(n => n.id !== id)\r\n      );\r\n    }, 300);\r\n  }\r\n\r\n  /**\r\n   * Remove all notifications\r\n   */\r\n  clearAll(): void {\r\n    this.notifications.update(notifications => \r\n      notifications.map(n => ({ ...n, isVisible: false }))\r\n    );\r\n\r\n    setTimeout(() => {\r\n      this.notifications.set([]);\r\n    }, 300);\r\n  }\r\n\r\n  /**\r\n   * Execute undo action for a notification\r\n   */\r\n  executeUndo(id: string): void {\r\n    const notification = this.notifications().find(n => n.id === id);\r\n    if (notification && notification.undoAction) {\r\n      notification.undoAction();\r\n      this.remove(id);\r\n    }\r\n  }\r\n\r\n  // Internal methods\r\n  private addNotification(notification: NotificationItem): void {\r\n    this.notifications.update(notifications => {\r\n      const newNotifications = [...notifications, notification];\r\n      \r\n      // Limit the number of visible notifications\r\n      if (newNotifications.length > this.maxNotifications) {\r\n        // Remove oldest notifications\r\n        const toRemove = newNotifications.length - this.maxNotifications;\r\n        for (let i = 0; i < toRemove; i++) {\r\n          if (newNotifications[i]) {\r\n            newNotifications[i] = { ...newNotifications[i], isVisible: false };\r\n          }\r\n        }\r\n      }\r\n      \r\n      return newNotifications;\r\n    });\r\n\r\n    // Auto-remove after duration (if not 0)\r\n    if (notification.duration > 0) {\r\n      setTimeout(() => {\r\n        this.remove(notification.id);\r\n      }, notification.duration);\r\n    }\r\n  }\r\n\r\n  private generateId(): string {\r\n    return `notification-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;\r\n  }\r\n\r\n  private getDefaultIcon(type: 'success' | 'error' | 'warning' | 'info'): string {\r\n    const iconMap = {\r\n      success: 'check_circle',\r\n      error: 'error',\r\n      warning: 'warning',\r\n      info: 'info'\r\n    };\r\n    return iconMap[type];\r\n  }\r\n\r\n  // Public getters for components\r\n  getNotifications() {\r\n    return this.notifications;\r\n  }\r\n\r\n  getActiveNotifications() {\r\n    return this.activeNotifications;\r\n  }\r\n}\r\n\r\n"]}

package/esm2022/lib/utils/directives/resizer/resizer.directive.mjs

@@ -0,0 +1,231 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+<!-- Basic horizontal (left-right) layout -->
+<div class="panel-container">
+    <div class="left-panel">
+        Left Panel Content
+    </div>
+
+    <div cideEleResizer direction="horizontal" [minPrevSize]="100" [minNextSize]="100">resize
+    </div>
+
+    <div class="right-panel">
+        Right Panel Content
+    </div>
+</div>
+
+<!-- Basic vertical (top-bottom) layout -->
+<div class="panel-container-vertical">
+    <div class="top-panel">
+        Top Panel Content
+    </div>
+
+    <div cideEleResizer direction="vertical" [minPrevSize]="50" [minNextSize]="50">resize
+    </div>
+
+    <div class="bottom-panel">
+        Bottom Panel Content
+    </div>
+</div>
+
+<!-- Using with custom selectors -->
+<div class="complex-layout">
+    <div id="panel1">Panel 1</div>
+    <div id="panel2">Panel 2</div>
+
+    <div cideEleResizer direction="horizontal" prevElementSelector="#panel1" nextElementSelector="#panel2"
+        [usePercentage]="true">resize
+    </div>
+
+    <div id="panel3">Panel 3</div>
+</div>
+ */
+export class CideEleResizerDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.direction = 'horizontal';
+        this.to = "";
+        this.prevElementSelector = ''; // Selector for previous element
+        this.nextElementSelector = ''; // Selector for next element
+        this.parentElementSelector = ''; // Selector for parent element
+        this.minPrevSize = 0; // Minimum size of previous element (px)
+        this.minNextSize = 0; // Minimum size of next element (px)
+        this.usePercentage = false; // Use percentage instead of pixels
+        this.resizeStart = new EventEmitter();
+        this.resizing = new EventEmitter();
+        this.resizeEnd = new EventEmitter();
+        this.isResizing = false;
+        this.startPosition = 0;
+        this.prevElement = null;
+        this.nextElement = null;
+        this.prevSize = 0;
+        this.nextSize = 0;
+        this.containerSize = 0;
+        this.startPrevSize = 0;
+        this.startNextSize = 0;
+        this.onMouseMove = (event) => {
+            if (!this.isResizing)
+                return;
+            // Calculate movement
+            const currentPosition = this.direction === 'horizontal' ? event.clientX : event.clientY;
+            const delta = currentPosition - this.startPosition;
+            // Calculate new sizes
+            let newPrevSize = this.startPrevSize + delta;
+            let newNextSize = this.startNextSize - delta;
+            // Apply constraints
+            if (newPrevSize < this.minPrevSize) {
+                const diff = this.minPrevSize - newPrevSize;
+                newPrevSize = this.minPrevSize;
+                newNextSize = this.startNextSize - delta + diff;
+                // skip if previsus size is equal to the minimum size, note above code is dark code which will not be executed
+                return;
+            }
+            if (newNextSize < this.minNextSize) {
+                const diff = this.minNextSize - newNextSize;
+                newNextSize = this.minNextSize;
+                newPrevSize = this.startPrevSize + delta - diff;
+                // skip if next size is equal to the minimum size, note above code is dark code which will not be executed
+                return;
+            }
+            // Update sizes
+            this.prevSize = newPrevSize;
+            this.nextSize = newNextSize;
+            // Apply new sizes
+            if (this.usePercentage) {
+                const prevPercent = (newPrevSize / this.containerSize) * 100;
+                const nextPercent = (newNextSize / this.containerSize) * 100;
+                this.renderer.setStyle(this.prevElement, this.getSizeProperty(), `${prevPercent}%`);
+                this.renderer.setStyle(this.nextElement, this.getSizeProperty(), `${nextPercent}%`);
+            }
+            else {
+                this.renderer.setStyle(this.prevElement, this.getSizeProperty(), `${newPrevSize}px`);
+                this.renderer.setStyle(this.nextElement, this.getSizeProperty(), `${newNextSize}px`);
+            }
+            // Emit resizing event
+            this.resizing.emit({ prevSize: newPrevSize, nextSize: newNextSize });
+        };
+        this.onMouseUp = () => {
+            this.isResizing = false;
+            // Remove event listeners
+            document.removeEventListener('mousemove', this.onMouseMove);
+            document.removeEventListener('mouseup', this.onMouseUp);
+            // Restore text selection
+            document.body.style.userSelect = '';
+            // Emit resizeEnd event
+            if (this.prevElement && this.nextElement) {
+                this.resizeEnd.emit({ prevSize: this.prevSize, nextSize: this.nextSize });
+            }
+            // Remove visual feedback
+            this.renderer.removeClass(this.el.nativeElement, 'resizing');
+        };
+    }
+    ngOnInit() {
+        // Set cursor style based on direction
+        this.renderer.setStyle(this.el.nativeElement, 'cursor', this.direction === 'horizontal' ? 'ew-resize' : 'ns-resize');
+        // Add a class to help with styling
+        this.renderer.addClass(this.el.nativeElement, 'panel-resizer');
+        this.renderer.addClass(this.el.nativeElement, `panel-resizer-${this.direction}`);
+        this.renderer.addClass(this.el.nativeElement, `cide-lyt-devider-${this.direction}`);
+        if (this.to) {
+            this.renderer.addClass(this.el.nativeElement, `cide-lyt-devider-${this.direction}-${this.to}`);
+        }
+    }
+    onMouseDown(event) {
+        event.preventDefault();
+        // Get the elements to resize
+        this.prevElement = this.getPrevElement();
+        this.nextElement = this.getNextElement();
+        // if (!this.prevElement || !this.nextElement) {
+        //   console.error('Could not find elements to resize');
+        //   return;
+        // }
+        // Get container size
+        const parent = this.parentElementSelector ? document.querySelector(this.parentElementSelector) : this.el.nativeElement.parentElement;
+        if (parent) {
+            console.log(parent.offsetWidth, "parent.offsetWidth");
+            this.containerSize = this.direction === 'horizontal'
+                ? parent.offsetWidth
+                : parent.offsetHeight;
+        }
+        // Store initial positions and sizes
+        this.startPosition = this.direction === 'horizontal' ? event.clientX : event.clientY;
+        if (this.prevElement) {
+            console.log(this.prevElement.offsetWidth, "this.prevElement.offsetWidth");
+            this.startPrevSize = this.direction === 'horizontal'
+                ? this.prevElement.offsetWidth
+                : this.prevElement.offsetHeight;
+        }
+        if (this.nextElement) {
+            console.log(this.nextElement.offsetWidth, "this.nextElement.offsetWidth");
+            this.startNextSize = this.direction === 'horizontal'
+                ? this.nextElement.offsetWidth
+                : this.nextElement.offsetHeight;
+        }
+        this.prevSize = this.startPrevSize;
+        this.nextSize = this.startNextSize;
+        this.isResizing = true;
+        // Add event listeners
+        document.addEventListener('mousemove', this.onMouseMove);
+        document.addEventListener('mouseup', this.onMouseUp);
+        // Disable text selection
+        document.body.style.userSelect = 'none';
+        // Emit resizeStart event
+        this.resizeStart.emit();
+        // Add visual feedback
+        this.renderer.addClass(this.el.nativeElement, 'resizing');
+    }
+    getPrevElement() {
+        if (this.prevElementSelector) {
+            const parent = this.parentElementSelector ? document.querySelector(this.parentElementSelector) : this.el.nativeElement.parentElement;
+            return parent?.querySelector(this.prevElementSelector) || null;
+        }
+        return this.el.nativeElement.previousElementSibling;
+    }
+    getNextElement() {
+        if (this.nextElementSelector) {
+            const parent = this.parentElementSelector ? document.querySelector(this.parentElementSelector) : this.el.nativeElement.parentElement;
+            return parent?.querySelector(this.nextElementSelector) || null;
+        }
+        return this.el.nativeElement.nextElementSibling;
+    }
+    getSizeProperty() {
+        return this.direction === 'horizontal' ? 'width' : 'height';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleResizerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.7", type: CideEleResizerDirective, isStandalone: true, selector: "[cideEleResizer]", inputs: { direction: "direction", to: "to", prevElementSelector: "prevElementSelector", nextElementSelector: "nextElementSelector", parentElementSelector: "parentElementSelector", minPrevSize: "minPrevSize", minNextSize: "minNextSize", usePercentage: "usePercentage" }, outputs: { resizeStart: "resizeStart", resizing: "resizing", resizeEnd: "resizeEnd" }, host: { listeners: { "mousedown": "onMouseDown($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideEleResizerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cideEleResizer]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { direction: [{
+                type: Input
+            }], to: [{
+                type: Input
+            }], prevElementSelector: [{
+                type: Input
+            }], nextElementSelector: [{
+                type: Input
+            }], parentElementSelector: [{
+                type: Input
+            }], minPrevSize: [{
+                type: Input
+            }], minNextSize: [{
+                type: Input
+            }], usePercentage: [{
+                type: Input
+            }], resizeStart: [{
+                type: Output
+            }], resizing: [{
+                type: Output
+            }], resizeEnd: [{
+                type: Output
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizer.directive.js","sourceRoot":"","sources":["../../../../../../../projects/cloud-ide-element/src/lib/utils/directives/resizer/resizer.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, HostListener, Input, OnInit, Output, Renderer2 } from '@angular/core';\r\n\r\nexport type CideEleResizerDirection = 'horizontal' | 'vertical';\r\nexport type CideEleResizerDirectionTo = \"right-to-left\" | \"left-to-right\" | \"\";\r\n\r\n@Directive({\r\n  selector: '[cideEleResizer]',\r\n  standalone: true\r\n})\r\n\r\n/**\r\n<!-- Basic horizontal (left-right) layout -->\r\n<div class=\"panel-container\">\r\n    <div class=\"left-panel\">\r\n        Left Panel Content\r\n    </div>\r\n\r\n    <div cideEleResizer direction=\"horizontal\" [minPrevSize]=\"100\" [minNextSize]=\"100\">resize\r\n    </div>\r\n\r\n    <div class=\"right-panel\">\r\n        Right Panel Content\r\n    </div>\r\n</div>\r\n\r\n<!-- Basic vertical (top-bottom) layout -->\r\n<div class=\"panel-container-vertical\">\r\n    <div class=\"top-panel\">\r\n        Top Panel Content\r\n    </div>\r\n\r\n    <div cideEleResizer direction=\"vertical\" [minPrevSize]=\"50\" [minNextSize]=\"50\">resize\r\n    </div>\r\n\r\n    <div class=\"bottom-panel\">\r\n        Bottom Panel Content\r\n    </div>\r\n</div>\r\n\r\n<!-- Using with custom selectors -->\r\n<div class=\"complex-layout\">\r\n    <div id=\"panel1\">Panel 1</div>\r\n    <div id=\"panel2\">Panel 2</div>\r\n\r\n    <div cideEleResizer direction=\"horizontal\" prevElementSelector=\"#panel1\" nextElementSelector=\"#panel2\"\r\n        [usePercentage]=\"true\">resize\r\n    </div>\r\n\r\n    <div id=\"panel3\">Panel 3</div>\r\n</div>\r\n */\r\nexport class CideEleResizerDirective implements OnInit {\r\n  @Input() direction: CideEleResizerDirection = 'horizontal';\r\n  @Input() to: CideEleResizerDirectionTo = \"\";\r\n  @Input() prevElementSelector = '';  // Selector for previous element\r\n  @Input() nextElementSelector = '';  // Selector for next element\r\n  @Input() parentElementSelector = '';  // Selector for parent element\r\n  @Input() minPrevSize = 0;           // Minimum size of previous element (px)\r\n  @Input() minNextSize = 0;           // Minimum size of next element (px)\r\n  @Input() usePercentage = false;     // Use percentage instead of pixels\r\n  @Output() resizeStart = new EventEmitter<void>();\r\n  @Output() resizing = new EventEmitter<{ prevSize: number, nextSize: number }>();\r\n  @Output() resizeEnd = new EventEmitter<{ prevSize: number, nextSize: number }>();\r\n\r\n  private isResizing = false;\r\n  private startPosition = 0;\r\n  private prevElement: HTMLElement | null = null;\r\n  private nextElement: HTMLElement | null = null;\r\n  private prevSize = 0;\r\n  private nextSize = 0;\r\n  private containerSize = 0;\r\n  private startPrevSize = 0;\r\n  private startNextSize = 0;\r\n\r\n  constructor(private el: ElementRef, private renderer: Renderer2) { }\r\n\r\n  ngOnInit() {\r\n    // Set cursor style based on direction\r\n    this.renderer.setStyle(\r\n      this.el.nativeElement,\r\n      'cursor',\r\n      this.direction === 'horizontal' ? 'ew-resize' : 'ns-resize'\r\n    );\r\n\r\n    // Add a class to help with styling\r\n    this.renderer.addClass(this.el.nativeElement, 'panel-resizer');\r\n    this.renderer.addClass(this.el.nativeElement, `panel-resizer-${this.direction}`);\r\n    this.renderer.addClass(this.el.nativeElement, `cide-lyt-devider-${this.direction}`);\r\n    if (this.to) {\r\n      this.renderer.addClass(this.el.nativeElement, `cide-lyt-devider-${this.direction}-${this.to}`);\r\n    }\r\n  }\r\n\r\n  @HostListener('mousedown', ['$event'])\r\n  onMouseDown(event: MouseEvent) {\r\n    event.preventDefault();\r\n\r\n    // Get the elements to resize\r\n    this.prevElement = this.getPrevElement();\r\n    this.nextElement = this.getNextElement();\r\n\r\n    // if (!this.prevElement || !this.nextElement) {\r\n    //   console.error('Could not find elements to resize');\r\n    //   return;\r\n    // }\r\n\r\n    // Get container size\r\n\r\n    const parent = this.parentElementSelector ? document.querySelector(this.parentElementSelector) : this.el.nativeElement.parentElement;\r\n    if (parent) {\r\n      console.log(parent.offsetWidth, \"parent.offsetWidth\")\r\n      this.containerSize = this.direction === 'horizontal'\r\n        ? parent.offsetWidth\r\n        : parent.offsetHeight;\r\n    }\r\n\r\n    \r\n    // Store initial positions and sizes\r\n    this.startPosition = this.direction === 'horizontal' ? event.clientX : event.clientY;\r\n    if (this.prevElement) {\r\n      console.log(this.prevElement.offsetWidth, \"this.prevElement.offsetWidth\")\r\n      this.startPrevSize = this.direction === 'horizontal'\r\n        ? this.prevElement.offsetWidth\r\n        : this.prevElement.offsetHeight;\r\n    }\r\n    if (this.nextElement) {\r\n      console.log(this.nextElement.offsetWidth, \"this.nextElement.offsetWidth\")\r\n      this.startNextSize = this.direction === 'horizontal'\r\n        ? this.nextElement.offsetWidth\r\n        : this.nextElement.offsetHeight;\r\n    }\r\n\r\n    this.prevSize = this.startPrevSize;\r\n    this.nextSize = this.startNextSize;\r\n\r\n    this.isResizing = true;\r\n\r\n    // Add event listeners\r\n    document.addEventListener('mousemove', this.onMouseMove);\r\n    document.addEventListener('mouseup', this.onMouseUp);\r\n\r\n    // Disable text selection\r\n    document.body.style.userSelect = 'none';\r\n\r\n    // Emit resizeStart event\r\n    this.resizeStart.emit();\r\n\r\n    // Add visual feedback\r\n    this.renderer.addClass(this.el.nativeElement, 'resizing');\r\n  }\r\n\r\n  private onMouseMove = (event: MouseEvent) => {\r\n    if (!this.isResizing) return;\r\n\r\n    // Calculate movement\r\n    const currentPosition = this.direction === 'horizontal' ? event.clientX : event.clientY;\r\n    const delta = currentPosition - this.startPosition;\r\n\r\n    // Calculate new sizes\r\n    let newPrevSize = this.startPrevSize + delta;\r\n    let newNextSize = this.startNextSize - delta;\r\n\r\n    // Apply constraints\r\n    if (newPrevSize < this.minPrevSize) {\r\n      const diff = this.minPrevSize - newPrevSize;\r\n      newPrevSize = this.minPrevSize;\r\n      newNextSize = this.startNextSize - delta + diff;\r\n      // skip if previsus size is equal to the minimum size, note above code is dark code which will not be executed\r\n      return;\r\n    }\r\n\r\n    if (newNextSize < this.minNextSize) {\r\n      const diff = this.minNextSize - newNextSize;\r\n      newNextSize = this.minNextSize;\r\n      newPrevSize = this.startPrevSize + delta - diff;\r\n      // skip if next size is equal to the minimum size, note above code is dark code which will not be executed\r\n      return;\r\n    }\r\n\r\n    // Update sizes\r\n    this.prevSize = newPrevSize;\r\n    this.nextSize = newNextSize;\r\n\r\n    // Apply new sizes\r\n    if (this.usePercentage) {\r\n      const prevPercent = (newPrevSize / this.containerSize) * 100;\r\n      const nextPercent = (newNextSize / this.containerSize) * 100;\r\n\r\n      this.renderer.setStyle(this.prevElement, this.getSizeProperty(), `${prevPercent}%`);\r\n      this.renderer.setStyle(this.nextElement, this.getSizeProperty(), `${nextPercent}%`);\r\n    } else {\r\n      this.renderer.setStyle(this.prevElement, this.getSizeProperty(), `${newPrevSize}px`);\r\n      this.renderer.setStyle(this.nextElement, this.getSizeProperty(), `${newNextSize}px`);\r\n    }\r\n\r\n    // Emit resizing event\r\n    this.resizing.emit({ prevSize: newPrevSize, nextSize: newNextSize });\r\n  }\r\n\r\n  private onMouseUp = () => {\r\n    this.isResizing = false;\r\n\r\n    // Remove event listeners\r\n    document.removeEventListener('mousemove', this.onMouseMove);\r\n    document.removeEventListener('mouseup', this.onMouseUp);\r\n\r\n    // Restore text selection\r\n    document.body.style.userSelect = '';\r\n\r\n    // Emit resizeEnd event\r\n    if (this.prevElement && this.nextElement) {\r\n      this.resizeEnd.emit({ prevSize: this.prevSize, nextSize: this.nextSize });\r\n    }\r\n\r\n    // Remove visual feedback\r\n    this.renderer.removeClass(this.el.nativeElement, 'resizing');\r\n  }\r\n\r\n  private getPrevElement(): HTMLElement | null {\r\n    if (this.prevElementSelector) {\r\n      const parent = this.parentElementSelector ? document.querySelector(this.parentElementSelector) : this.el.nativeElement.parentElement;\r\n      return parent?.querySelector(this.prevElementSelector) || null;\r\n    }\r\n    return this.el.nativeElement.previousElementSibling as HTMLElement;\r\n  }\r\n\r\n  private getNextElement(): HTMLElement | null {\r\n    if (this.nextElementSelector) {\r\n      const parent = this.parentElementSelector ? document.querySelector(this.parentElementSelector) : this.el.nativeElement.parentElement;\r\n      return parent?.querySelector(this.nextElementSelector) || null;\r\n    }\r\n    return this.el.nativeElement.nextElementSibling as HTMLElement;\r\n  }\r\n\r\n  private getSizeProperty(): string {\r\n    return this.direction === 'horizontal' ? 'width' : 'height';\r\n  }\r\n}"]}