@energycap/components 0.42.4-esbuild.20250131-1219 → 0.42.4-esbuild.20250131-1256

package/esm2022/lib/display/tooltip-directive/tooltip.directive.mjs

@@ -0,0 +1,173 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { of, Subject } from 'rxjs';
+import { delay, switchMap, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./../tooltip/tooltip.service";
+export class TooltipDirective {
+    constructor(tooltipService, element, renderer2) {
+        this.tooltipService = tooltipService;
+        this.element = element;
+        this.renderer2 = renderer2;
+        //TooltipConfig: receives all the tooltip options to overwrite the
+        //default configuration of the tooltip
+        this.tooltipConfig = undefined;
+        //TooltipText: receives plain text to display in the default tooltip
+        this.tooltipText = undefined;
+        //TooltipCustomContent: receives a template reference to display
+        //into the tooltip content
+        this.tooltipCustomContent = undefined;
+        //This Input will remain as Input because tooltipPosition is not part
+        //of TooltipOptions type of object
+        this.tooltipPosition = "top-center";
+        //************************************************************//
+        //Events related
+        this.mouseOver = new Subject();
+        this.interrupt = new Subject();
+        this.hideCompleted = new Subject();
+        //Object with the tooltip options builded with the Input parameters
+        //and use it in tooltipService - show()
+        this.tooltipOptions = {};
+        /**Set when we show a tooltip, to allow us to unsubscribe to mouse move when hide fires.
+         * if we never showed the tooltip this will remain null and we won't have an event to unsubscribe to
+         */
+        this.mouseMoveUnsubscribe = null;
+    }
+    ngOnInit() {
+        //checkInputsValue(): if there is an error it will prevent to execute
+        //any code related with the tooltip setup
+        if (this.checkInputsValue()) {
+            //Create the object with the tooltip options provided as @Inputs
+            this.createTooltipOptions();
+            //MouseOver flow: start the process of showing the tooltip
+            //until the mouse leaves the anchor element with this.interrupt
+            this.mouseOver
+                .pipe(switchMap(v => of(v).pipe(delay(300), //delays the time previous of showing the tooltip
+            takeUntil(this.interrupt))))
+                .subscribe(() => this.show()); //Calls the function responsable of using the tooltipService
+            //Mouse leave flow: start the process of removing the tooltip when the mouse is away of the anchor element
+            this.interrupt.pipe(switchMap(v => of(v).pipe(delay(50), takeUntil(this.hideCompleted)))).subscribe(() => this.hide()); //hide the tooltip and triggers the completed cycle flag this.hideCompleted
+        }
+        else {
+            console.error('There are too many parameters or none parameter to config the tooltip options');
+        }
+    }
+    /**Detects where the mouse is to trigger the leave/hide process
+     * This is a backstop protection against us missing the mouseleave event and leaving a hanging chad.
+     * On some browsers, and on some actions (especially scroll) the mouseLeave seems to never fire */
+    onMouseMove(event) {
+        let callCallback = false;
+        if (this.contentRect) {
+            callCallback = this.tooltipService.onMove(event, this.contentRect);
+            if (callCallback) {
+                //trigger on hide process
+                this.interrupt.next();
+                //reset the contentRec for a new tooltip
+                this.contentRect = undefined;
+            }
+        }
+    }
+    //Trigger the process to show the tooltip
+    onMouseOver() {
+        this.mouseOver.next();
+    }
+    //Trigger the process to hide and later the process
+    //to mark as complete the cycle of show and hide the tooltip
+    onLeave() {
+        this.interrupt.next();
+    }
+    checkInputsValue() {
+        let parametersWithValue = 0;
+        if (this.tooltipText) {
+            parametersWithValue = parametersWithValue + 1;
+        }
+        if (this.tooltipCustomContent) {
+            parametersWithValue = parametersWithValue + 1;
+        }
+        if (this.tooltipConfig) {
+            parametersWithValue = parametersWithValue + 1;
+        }
+        if (parametersWithValue === 1) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * createTooltipOptions
+     * will only be executed after manageError() verifies
+     * if the parameters are not overlapping each other
+     * and it will build the tooltipOptions object
+     */
+    createTooltipOptions() {
+        this.tooltipOptions = {
+            id: `tooltip_${this.tooltipConfig?.id ? this.tooltipConfig?.id : ''}`,
+            text: this.tooltipConfig?.text || this.tooltipText,
+            title: this.tooltipConfig?.title,
+            subtitle: this.tooltipConfig?.subtitle,
+            customContent: this.tooltipConfig?.customContent || this.tooltipCustomContent,
+            dismissible: this.tooltipConfig?.dismissible || false,
+            maxWidth: this.tooltipConfig?.maxWidth,
+            width: this.tooltipConfig?.width,
+            backgroundColor: this.tooltipConfig?.backgroundColor,
+        };
+    }
+    show() {
+        //Reference to the element where to tooltip is attached
+        const element = this.element.nativeElement;
+        //contentRect will be assing only after showing a tooltip/popover and it will be
+        //reset after hide the same tooltip/popover
+        this.contentRect = this.element.nativeElement.getBoundingClientRect();
+        //tooltipPosition is never undefined, default value = "top-center"
+        if (!this.tooltip) {
+            this.tooltip = this.tooltipService.show(element, this.tooltipPosition, this.tooltipOptions);
+            this.mouseMoveUnsubscribe = this.renderer2.listen(document, 'mousemove', this.onMouseMove.bind(this));
+        }
+    }
+    hide() {
+        //There is a timing issue between the show - hide with 
+        //liner tooltip elements, so the below line
+        //makes sure the app doesn't break
+        if (this.tooltip) {
+            //Call the hide() from the tooltip component
+            this.tooltip.hide();
+            this.tooltip = undefined;
+            if (this.mouseMoveUnsubscribe) {
+                this.mouseMoveUnsubscribe();
+            }
+        }
+        //Interrupt the flow of mouseover with a delay and triggers the 
+        //flow to hide the tooltip with a delay 
+        this.interrupt.next();
+        //Work as a flag to indicate the flow of show and hide has been completed
+        this.hideCompleted.next();
+    }
+    //When the element where the tooltip is attached disappears
+    //the tooltip should be destroy as well  
+    ngOnDestroy() {
+        this.interrupt.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TooltipDirective, deps: [{ token: i1.TooltipService }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: TooltipDirective, selector: "[ecTooltip]", inputs: { tooltipConfig: "tooltipConfig", tooltipText: "tooltipText", tooltipCustomContent: "tooltipCustomContent", tooltipPosition: "tooltipPosition" }, host: { listeners: { "mouseover": "onMouseOver()", "mouseleave": "onLeave()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ecTooltip]'
+                }]
+        }], ctorParameters: () => [{ type: i1.TooltipService }, { type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { tooltipConfig: [{
+                type: Input
+            }], tooltipText: [{
+                type: Input
+            }], tooltipCustomContent: [{
+                type: Input
+            }], tooltipPosition: [{
+                type: Input
+            }], onMouseOver: [{
+                type: HostListener,
+                args: ['mouseover']
+            }], onLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/tooltip-directive/tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, Input, OnInit, Renderer2, TemplateRef } from '@angular/core';\r\nimport { of, Subject } from 'rxjs';\r\nimport { delay, switchMap, takeUntil } from 'rxjs/operators';\r\nimport { TooltipComponent, TooltipOptions, TooltipPosition } from './../tooltip/tooltip.component';\r\nimport { TooltipService } from './../tooltip/tooltip.service';\r\n\r\n@Directive({\r\n  selector: '[ecTooltip]'\r\n})\r\n\r\nexport class TooltipDirective implements OnInit {\r\n\r\n  //TooltipConfig: receives all the tooltip options to overwrite the\r\n  //default configuration of the tooltip\r\n  @Input() public tooltipConfig?: TooltipOptions = undefined\r\n\r\n  //TooltipText: receives plain text to display in the default tooltip\r\n  @Input() public tooltipText?: string = undefined; \r\n\r\n  //TooltipCustomContent: receives a template reference to display\r\n  //into the tooltip content\r\n  @Input() public tooltipCustomContent?: TemplateRef<any> = undefined;\r\n  \r\n  \r\n  //This Input will remain as Input because tooltipPosition is not part\r\n  //of TooltipOptions type of object\r\n  @Input() public tooltipPosition: TooltipPosition = \"top-center\";\r\n\r\n\r\n\r\n  //************************************************************//\r\n\r\n  //Events related\r\n  private mouseOver = new Subject<void>();\r\n  private interrupt = new Subject<void>();\r\n  private hideCompleted = new Subject<void>();\r\n  private contentRect: DOMRect | undefined;\r\n\r\n  //************************************************************//\r\n\r\n  //Reference to TooltipComponent, will be defined below in this.show()\r\n  private tooltip?: TooltipComponent;\r\n\r\n  //Object with the tooltip options builded with the Input parameters\r\n  //and use it in tooltipService - show()\r\n  private tooltipOptions?:TooltipOptions = {}\r\n  \r\n\r\n  /**Set when we show a tooltip, to allow us to unsubscribe to mouse move when hide fires.\r\n   * if we never showed the tooltip this will remain null and we won't have an event to unsubscribe to\r\n   */\r\n  private mouseMoveUnsubscribe: (()=> void) | null = null;\r\n\r\n  constructor(\r\n    private tooltipService: TooltipService,\r\n    private element: ElementRef, \r\n    private renderer2: Renderer2\r\n  ) {}\r\n\r\n  ngOnInit() {\r\n    //checkInputsValue(): if there is an error it will prevent to execute\r\n    //any code related with the tooltip setup\r\n    if(this.checkInputsValue()) {\r\n      //Create the object with the tooltip options provided as @Inputs\r\n      this.createTooltipOptions();\r\n\r\n      //MouseOver flow: start the process of showing the tooltip\r\n      //until the mouse leaves the anchor element with this.interrupt\r\n      this.mouseOver\r\n      .pipe(\r\n        switchMap(v =>\r\n          of(v).pipe(\r\n            delay(300), //delays the time previous of showing the tooltip\r\n            takeUntil(this.interrupt)\r\n          )\r\n        )\r\n      )\r\n      .subscribe(() => this.show()); //Calls the function responsable of using the tooltipService\r\n  \r\n      //Mouse leave flow: start the process of removing the tooltip when the mouse is away of the anchor element\r\n      this.interrupt.pipe(\r\n        switchMap(v => \r\n          of(v).pipe(\r\n            delay(50),\r\n            takeUntil(this.hideCompleted)\r\n          ))\r\n      ).subscribe(() => this.hide()); //hide the tooltip and triggers the completed cycle flag this.hideCompleted\r\n    } else {\r\n      console.error('There are too many parameters or none parameter to config the tooltip options');\r\n    }\r\n  }\r\n\r\n  /**Detects where the mouse is to trigger the leave/hide process\r\n   * This is a backstop protection against us missing the mouseleave event and leaving a hanging chad.\r\n   * On some browsers, and on some actions (especially scroll) the mouseLeave seems to never fire */\r\n  public onMouseMove(event:MouseEvent) {\r\n    let callCallback = false;\r\n    if(this.contentRect) {\r\n      callCallback = this.tooltipService.onMove(event, this.contentRect!);\r\n      if(callCallback) {\r\n        //trigger on hide process\r\n        this.interrupt.next(); \r\n        //reset the contentRec for a new tooltip\r\n        this.contentRect = undefined;\r\n      }\r\n    }\r\n  }\r\n\r\n  //Trigger the process to show the tooltip\r\n  @HostListener('mouseover')\r\n  public onMouseOver() {\r\n    this.mouseOver.next();\r\n  }\r\n  \r\n  //Trigger the process to hide and later the process\r\n  //to mark as complete the cycle of show and hide the tooltip\r\n  @HostListener('mouseleave')\r\n  public onLeave() {\r\n    this.interrupt.next();\r\n  }\r\n\r\n  private checkInputsValue():boolean {\r\n    let parametersWithValue = 0;\r\n    if(this.tooltipText) {\r\n      parametersWithValue = parametersWithValue + 1\r\n    } \r\n    if(this.tooltipCustomContent) {\r\n      parametersWithValue = parametersWithValue + 1\r\n    }\r\n    if(this.tooltipConfig) {\r\n      parametersWithValue = parametersWithValue + 1\r\n    }\r\n    if(parametersWithValue === 1) {\r\n      return true;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n  /**\r\n   * createTooltipOptions\r\n   * will only be executed after manageError() verifies \r\n   * if the parameters are not overlapping each other\r\n   * and it will build the tooltipOptions object\r\n   */\r\n  private createTooltipOptions(): void {\r\n    this.tooltipOptions = {\r\n      id: `tooltip_${this.tooltipConfig?.id? this.tooltipConfig?.id: ''}`,\r\n      text: this.tooltipConfig?.text || this.tooltipText,\r\n      title: this.tooltipConfig?.title,\r\n      subtitle: this.tooltipConfig?.subtitle,\r\n      customContent: this.tooltipConfig?.customContent || this.tooltipCustomContent,\r\n      dismissible: this.tooltipConfig?.dismissible || false,\r\n      maxWidth: this.tooltipConfig?.maxWidth,\r\n      width: this.tooltipConfig?.width,\r\n      backgroundColor: this.tooltipConfig?.backgroundColor,\r\n    };\r\n  }\r\n\r\n\r\n  private show():void {\r\n    //Reference to the element where to tooltip is attached\r\n    const element = this.element.nativeElement;\r\n    //contentRect will be assing only after showing a tooltip/popover and it will be\r\n    //reset after hide the same tooltip/popover\r\n    this.contentRect = this.element.nativeElement.getBoundingClientRect();\r\n    //tooltipPosition is never undefined, default value = \"top-center\"\r\n    if(!this.tooltip) {\r\n      this.tooltip = this.tooltipService.show(element as HTMLElement, this.tooltipPosition, this.tooltipOptions);\r\n      this.mouseMoveUnsubscribe = this.renderer2.listen(document, 'mousemove', this.onMouseMove.bind(this));\r\n    }\r\n  }\r\n\r\n  private hide():void {\r\n    //There is a timing issue between the show - hide with \r\n    //liner tooltip elements, so the below line\r\n    //makes sure the app doesn't break\r\n    if(this.tooltip) {\r\n      //Call the hide() from the tooltip component\r\n      this.tooltip.hide();\r\n      this.tooltip = undefined;\r\n      \r\n      if(this.mouseMoveUnsubscribe){\r\n        this.mouseMoveUnsubscribe();\r\n      }\r\n    }\r\n\r\n    //Interrupt the flow of mouseover with a delay and triggers the \r\n    //flow to hide the tooltip with a delay \r\n    this.interrupt.next();\r\n    //Work as a flag to indicate the flow of show and hide has been completed\r\n    this.hideCompleted.next();\r\n  }\r\n\r\n  //When the element where the tooltip is attached disappears\r\n  //the tooltip should be destroy as well  \r\n  ngOnDestroy(): void {\r\n   this.interrupt.next();\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/lib/display/tour/tour-types.mjs

@@ -0,0 +1,34 @@
+export class Tour {
+    constructor() {
+        /** Unique identifier for the tour */
+        this.id = '';
+        /** List of tour steps to present to the user */
+        this.steps = [];
+    }
+}
+export class TourStep {
+    constructor() {
+        /** Unique identifier for the tour step */
+        this.id = '';
+        /** HTML formatted text that contains the primary content of the tour step */
+        this.text = '';
+    }
+}
+export class TourAnchor {
+    constructor() {
+        /**
+         * Selector to attach the tooltip to. If defined but does not exist in the
+         * DOM skip this step because it is probably hidden to the user because of
+         * permissions.
+         */
+        this.selector = '';
+    }
+}
+export class TourEvent {
+    constructor(tours, tourAction = 'start', isAutoStart = false) {
+        this.tours = tours;
+        this.tourAction = tourAction;
+        this.isAutoStart = isAutoStart;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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