@visa/nova-angular
Version:
Visa Product Design System Nova Angular library
306 lines • 46.4 kB
JavaScript
/**
* Copyright (c) 2025 Visa, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**/
import { ElementRef, EventEmitter, Injectable, Output, RendererFactory2, signal } from '@angular/core';
import { arrow, autoUpdate, computePosition, flip, offset, shift } from '@floating-ui/dom';
import { AppReadyService } from '../_utilities/services/app-stable-check.service';
import { UUIDService } from '../_utilities/services/uuid.service';
import { FloatingUIPlacements, FloatingUIVisibility } from './floating-ui.constants';
import * as i0 from "@angular/core";
import * as i1 from "../_utilities/services/uuid.service";
import * as i2 from "../_utilities/services/app-stable-check.service";
/**
* This internal service is used by Combobox, Dropdown Menu, and Tooltip components. <br />
* It can be used with generic FloatingUIContainer, FloatingUIElementDirective, and FloatingUITriggerDirective to create your own custom floating-ui. <br />
* If you are using any of the components mentioned, you will typically not need to use this service directly. <br />
* Derived from [Floating UI documentation](https://floating-ui.com/).
*/
export class FloatingUIService {
constructor(rendererFactory, uuidService, appReadyService) {
this.rendererFactory = rendererFactory;
this.uuidService = uuidService;
this.appReadyService = appReadyService;
/** @ignore */
this.offsetDefault = 2;
/** @ignore */
this.comboboxMiddleware = [offset(0), flip(), shift()];
/** @ignore */
this.middlewareDefault = [offset(this.offsetDefault), flip(), shift()];
/** @ignore */
this.middleware = this.middlewareDefault;
/** @ignore */
this.placement = FloatingUIPlacements.BOTTOM;
/** @ignore */
this.isShown = signal(false);
/**
* Displays property of the floating UI element.
* @default 'flex'
*/
this.display = 'flex';
/**
* Emits true when this floating UI element is shown and false when hidden.
*/
this.isShownEmitter = new EventEmitter();
// for keepOnHover
/** @ignore */
this.onTooltip = false;
/** @ignore */
this.onTrigger = false;
this.renderer = rendererFactory.createRenderer(null, null);
}
/**
* The setUpFloatingUI method is required to initialize the floating element and its trigger. <br />
* Called by default with FloatingUIContainer or ComboboxDirective.
* @param referenceEl References element that will trigger floating UI.
* @param floatingEl References floating UI element.
* @param eventArray Array of events for the reference/trigger element to listen for. <br> i.e. <code>[new UIEvent('focus'), FloatingUIVisibility.SHOW]</code> <br> tells the element to show the floating UI when the triggering element is focused.
*/
setUpfloatingUI(referenceEl, floatingEl, eventArray) {
this.trigger = this.nativeElement(referenceEl);
this.floatingUI = floatingEl;
this.renderer.setStyle(this.floatingUI.nativeElement, 'top', '0');
this.renderer.setStyle(this.floatingUI.nativeElement, 'left', '0');
this.renderer.setStyle(this.floatingUI.nativeElement, 'display', 'none');
if (eventArray) {
this.setUpTrigger(eventArray);
}
else {
console.error('No events provided to trigger the Floating UI.');
}
}
/**
* The nativeElement method returns the Element type of the reference element.
* @param element Element to be converted to Element type.
* @returns Element
*/
nativeElement(element) {
if (element instanceof ElementRef) {
return element.nativeElement;
}
return element;
}
/**
* The customizeFloatingUI method allows you to provide custom placement and middleware options to the Floating UI service.
* @param placement Optional. See <code>FloatingUIPlacements</code> enum.
* @param middleware Optional. Visit the official Floating UI documentation for more on [middleware options](https://floating-ui.com/docs/computePosition#middleware).
* @param display Optional. Sets CSS display property for the floating UI element.
* @param tooltipArrow Optional. Directive reference to the arrow element. See TooltipArrowDirective.
*/
customizeFloatingUI(placement, middleware, display, tooltipArrow) {
if (placement) {
this.placement = placement;
}
if (middleware) {
this.middleware = middleware;
// save a custom offset
const customOffset = this.middleware.find((m) => m['name'] === 'offset') || 2;
this.offset = customOffset.options;
}
if (display) {
this.display = display;
}
if (tooltipArrow) {
this.arrow = tooltipArrow;
// update the offset to factor in the arrow size if no custom offset was placed
const floatingOffset = Math.ceil(Math.sqrt(2 * this.arrow.customSize ** 2) / 2);
this.offset = this.offset ? floatingOffset + this.offset : floatingOffset + this.offsetDefault;
this.middleware.push(arrow({ element: this.arrow.el.nativeElement }));
const offsetIndex = this.middleware.findIndex((func) => func.name === 'offset');
// START GENAI@CHATGPT4
if (offsetIndex !== -1) {
// Replace the old offset function with the new one
this.middleware = [
...this.middleware.slice(0, offsetIndex),
offset(this.offset),
...this.middleware.slice(offsetIndex + 1)
];
}
else {
// If no old offset function is found, just add the new one
this.middleware = [...this.middleware, offset(this.offset)];
}
// END GENAI@CHATGPT4
}
}
/**
* The positionFloatingUI method positions the Floating UI based on the given placement and middleware. <br />
* For more details on the internal function, refer to Floating UI's [compute position documentation](https://floating-ui.com/docs/computePosition).
* @param trigger The triggering element.
* @param floatingUI The element that will "float" when triggered.
* @param placement Reference FloatingUIPlacements.
* @param middleware Visit the official Floating UI documentation for more on [middleware options](https://floating-ui.com/docs/computePosition#middleware).
*/
positionFloatingUI(trigger = this.trigger, floatingUI = this.floatingUI.nativeElement, placement = this.placement) {
autoUpdate(trigger, floatingUI, () => {
computePosition(trigger, floatingUI, {
placement: placement,
middleware: this.middleware
}).then(({ x, y, middlewareData, placement }) => {
floatingUI.style.left = `${x}px`;
floatingUI.style.top = `${y}px`;
if (middlewareData.arrow) {
// see: https://codesandbox.io/s/mystifying-kare-ee3hmh?file=/src/index.js
if (this.arrow) {
const { x, y } = middlewareData.arrow;
this.renderer.setStyle(this.arrow.el.nativeElement, 'left', x != null ? `${x}px` : '');
this.renderer.setStyle(this.arrow.el.nativeElement, 'top', y != null ? `${y}px` : '');
this.renderer.setStyle(this.arrow.el.nativeElement, 'right', '');
this.renderer.setStyle(this.arrow.el.nativeElement, 'bottom', '');
const side = placement.split('-')[0];
const staticSide = {
top: 'bottom',
bottom: 'top',
left: 'right',
right: 'left'
}[side];
if (staticSide) {
this.renderer.setStyle(this.arrow.el.nativeElement, staticSide, -(this.arrow.el.nativeElement.offsetWidth / 2) + 'px');
}
}
}
});
});
}
/**
* The showFloatingUI method displays the Floating UI element.
*/
showfloatingUI() {
if (this.appReadyService.isBrowserAndDomAvailable()) {
const triggerDisabled = this.trigger.getAttribute('disabled');
if (triggerDisabled)
return;
}
this.positionFloatingUI();
this.isShown.set(true);
this.isShownEmitter.emit(this.isShown());
this.renderer.setStyle(this.floatingUI.nativeElement, 'display', this.display);
}
/**
* The hideFloatingUI method hides the Floating UI element.
*/
hidefloatingUI() {
this.renderer.setStyle(this.floatingUI.nativeElement, 'display', 'none');
this.isShown.set(false);
this.isShownEmitter.emit(this.isShown());
}
/**
* The toggleFloatingUI method toggles the visibility of the Floating UI element.
*/
toggleFloatingUI() {
if (this.isShown()) {
this.hidefloatingUI();
}
else {
this.showfloatingUI();
}
}
/**
* The closeOnClickOut method closes the menu when a click occurs outside of the menu and the triggering element.
* @param event Document click event.
*/
closeOnClickOut(event) {
// listen for document click and close menu if click is outside of component
if (this.isShown()) {
const target = event.target;
if (!this.floatingUI.nativeElement.contains(event.target) && !this.trigger.contains(target)) {
this.hidefloatingUI();
}
}
}
/**
* The addCloseActions method adds default close actions to the Floating UI component. These actions include closing the menu when the escape key is pressed or when clicking outside of the floating element.
*/
addCloseActions() {
const document = this.appReadyService.checkDocumentExists();
// close menu on escape key press or clicking outside of menu
if (document) {
this.renderer.listen(document, 'click', this.closeOnClickOut.bind(this));
this.renderer.listen(document, 'keydown.esc', this.hidefloatingUI.bind(this));
}
}
/**
* The setUpTrigger method configures the triggering element by setting up the events to listen for and the actions to take when those events are triggered.
* @param eventArray Array of events for the reference/trigger element to listen for.<br> i.e. <code>[new UIEvent('focus'), FloatingUIVisibility.SHOW]</code> <br> tells the element to show the floating UI when the triggering element is focused.
*/
setUpTrigger(eventArray) {
// add default actions to close menu
this.addCloseActions();
eventArray.forEach((pair) => {
/**
* if a custom eventArray is **not** typed as UIEventVisibilityPair[],<br />
* Typescript will type the array as ((UIEvent | "show")[] | (UIEvent | "hide")[])[] <br />
* because the passed arrays have different types, the type of the array is inferred as a union of the types of the passed arrays. <br />
* The following code ensures the correct types are assigned to the event and listener variables.
*/
const event = pair.find((e) => e instanceof UIEvent);
const listener = pair.find((e) => e === FloatingUIVisibility.SHOW || e === FloatingUIVisibility.HIDE);
if (event instanceof UIEvent) {
if (event.type === 'click') {
this.renderer.listen(this.trigger, event.type, this.toggleFloatingUI.bind(this));
}
else if (event.type === 'mouseleave' && listener && listener === FloatingUIVisibility.HIDE) {
this.keepOnHover();
}
else if (listener && listener === FloatingUIVisibility.SHOW) {
this.renderer.listen(this.trigger, event.type, this.showfloatingUI.bind(this));
}
else if (listener && listener === FloatingUIVisibility.HIDE) {
this.renderer.listen(this.trigger, event.type, this.hidefloatingUI.bind(this));
}
}
});
}
/**
* The keepOnHover method keeps the floating element visible when hovering over the trigger or the floating element.
*/
keepOnHover() {
let offset = this.middleware.find((m) => m['name'] === 'offset');
offset = this.hideOnHoverTimeout ? this.hideOnHoverTimeout : offset['options'] ? offset['options'] * 20 : 50;
this.renderer.listen(this.trigger, 'mouseleave', () => {
setTimeout(() => {
this.onTrigger = false;
if (!this.onTooltip) {
this.hidefloatingUI();
}
}, offset);
});
this.renderer.listen(this.trigger, 'mouseenter', () => {
this.onTrigger = true;
});
this.renderer.listen(this.floatingUI.nativeElement, 'mouseenter', () => {
this.onTooltip = true;
});
this.renderer.listen(this.floatingUI.nativeElement, 'mouseleave', () => {
setTimeout(() => {
this.onTooltip = false;
if (!this.onTrigger) {
this.hidefloatingUI();
}
}, offset);
});
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FloatingUIService, deps: [{ token: i0.RendererFactory2 }, { token: i1.UUIDService }, { token: i2.AppReadyService }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FloatingUIService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FloatingUIService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i0.RendererFactory2 }, { type: i1.UUIDService }, { type: i2.AppReadyService }], propDecorators: { isShownEmitter: [{
type: Output
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"floating-ui.service.js","sourceRoot":"","sources":["../../../../../../libs/nova-lib/src/lib/floating-ui/floating-ui.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *              Copyright (c) 2025 Visa, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *         http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n **/\nimport { ElementRef, EventEmitter, Injectable, Output, Renderer2, RendererFactory2, signal } from '@angular/core';\nimport { arrow, autoUpdate, computePosition, ComputePositionReturn, flip, offset, shift } from '@floating-ui/dom';\nimport { AppReadyService } from '../_utilities/services/app-stable-check.service';\nimport { UUIDService } from '../_utilities/services/uuid.service';\nimport { TooltipArrowDirective } from '../arrow/arrow.directive';\nimport { FloatingUIPlacements, FloatingUIVisibility, UIEventVisibilityPair } from './floating-ui.constants';\n\n/**\n * This internal service is used by Combobox, Dropdown Menu, and Tooltip components. <br />\n * It can be used with generic FloatingUIContainer, FloatingUIElementDirective, and FloatingUITriggerDirective to create your own custom floating-ui. <br />\n * If you are using any of the components mentioned, you will typically not need to use this service directly. <br />\n * Derived from [Floating UI documentation](https://floating-ui.com/).\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class FloatingUIService {\n  constructor(\n    private rendererFactory: RendererFactory2,\n    private uuidService: UUIDService,\n    private appReadyService: AppReadyService\n  ) {\n    this.renderer = rendererFactory.createRenderer(null, null);\n  }\n  /** @ignore */\n  private renderer: Renderer2;\n  /** @ignore */\n  trigger: Element;\n  /** @ignore */\n  floatingUI: ElementRef;\n  /** @ignore */\n  arrow: TooltipArrowDirective;\n  /** @ignore */\n  eventArray: UIEventVisibilityPair;\n  /** @ignore */\n  offset: number;\n  /** @ignore */\n  offsetDefault = 2;\n  /** @ignore */\n  comboboxMiddleware: any = [offset(0), flip(), shift()];\n  /** @ignore */\n  middlewareDefault: any = [offset(this.offsetDefault), flip(), shift()];\n  /** @ignore */\n  middleware: any = this.middlewareDefault;\n  /** @ignore */\n  placement: FloatingUIPlacements = FloatingUIPlacements.BOTTOM;\n  /** @ignore */\n  isShown = signal(false);\n\n  /**\n   * Displays property of the floating UI element.\n   * @default 'flex'\n   */\n  display = 'flex';\n\n  /**\n   * Time in milliseconds to wait before hiding the floating UI element when the trigger is hovered over.\n   * @default A factor of the offset middleware option if provided, otherwise 50.\n   */\n  hideOnHoverTimeout: number;\n\n  /**\n   * Emits true when this floating UI element is shown and false when hidden.\n   */\n  @Output() isShownEmitter = new EventEmitter();\n\n  /**\n   * The setUpFloatingUI method is required to initialize the floating element and its trigger. <br />\n   * Called by default with FloatingUIContainer or ComboboxDirective.\n   * @param referenceEl References element that will trigger floating UI.\n   * @param floatingEl References floating UI element.\n   * @param eventArray Array of events for the reference/trigger element to listen for. <br> i.e. <code>[new UIEvent('focus'), FloatingUIVisibility.SHOW]</code> <br> tells the element to show the floating UI when the triggering element is focused.\n   */\n  setUpfloatingUI(referenceEl: ElementRef | HTMLElement, floatingEl: ElementRef, eventArray: UIEventVisibilityPair) {\n    this.trigger = this.nativeElement(referenceEl);\n    this.floatingUI = floatingEl;\n\n    this.renderer.setStyle(this.floatingUI.nativeElement, 'top', '0');\n    this.renderer.setStyle(this.floatingUI.nativeElement, 'left', '0');\n    this.renderer.setStyle(this.floatingUI.nativeElement, 'display', 'none');\n\n    if (eventArray) {\n      this.setUpTrigger(eventArray);\n    } else {\n      console.error('No events provided to trigger the Floating UI.');\n    }\n  }\n\n  /**\n   * The nativeElement method returns the Element type of the reference element.\n   * @param element Element to be converted to Element type.\n   * @returns Element\n   */\n  nativeElement(element: ElementRef<any> | HTMLElement): Element {\n    if (element instanceof ElementRef) {\n      return element.nativeElement;\n    }\n    return element;\n  }\n\n  /**\n   * The customizeFloatingUI method allows you to provide custom placement and middleware options to the Floating UI service.\n   * @param placement Optional. See <code>FloatingUIPlacements</code> enum.\n   * @param middleware Optional. Visit the official Floating UI documentation for more on [middleware options](https://floating-ui.com/docs/computePosition#middleware).\n   * @param display Optional. Sets CSS display property for the floating UI element.\n   * @param tooltipArrow Optional. Directive reference to the arrow element. See TooltipArrowDirective.\n   */\n  customizeFloatingUI(\n    placement?: FloatingUIPlacements,\n    middleware?: any,\n    display?: string,\n    tooltipArrow?: TooltipArrowDirective\n  ) {\n    if (placement) {\n      this.placement = placement;\n    }\n    if (middleware) {\n      this.middleware = middleware;\n      // save a custom offset\n      const customOffset = (this.middleware.find((m: any) => m['name'] === 'offset') as any) || 2;\n      this.offset = customOffset.options;\n    }\n    if (display) {\n      this.display = display;\n    }\n\n    if (tooltipArrow) {\n      this.arrow = tooltipArrow;\n      // update the offset to factor in the arrow size if no custom offset was placed\n      const floatingOffset = Math.ceil(Math.sqrt(2 * this.arrow.customSize ** 2) / 2);\n      this.offset = this.offset ? floatingOffset + this.offset : floatingOffset + this.offsetDefault;\n      this.middleware.push(arrow({ element: this.arrow.el.nativeElement }));\n      const offsetIndex = this.middleware.findIndex((func: any) => func.name === 'offset');\n\n      // START GENAI@CHATGPT4\n      if (offsetIndex !== -1) {\n        // Replace the old offset function with the new one\n        this.middleware = [\n          ...this.middleware.slice(0, offsetIndex),\n          offset(this.offset),\n          ...this.middleware.slice(offsetIndex + 1)\n        ];\n      } else {\n        // If no old offset function is found, just add the new one\n        this.middleware = [...this.middleware, offset(this.offset)];\n      }\n      // END GENAI@CHATGPT4\n    }\n  }\n\n  /**\n   * The positionFloatingUI method positions the Floating UI based on the given placement and middleware. <br />\n   * For more details on the internal function, refer to Floating UI's [compute position documentation](https://floating-ui.com/docs/computePosition).\n   * @param trigger The triggering element.\n   * @param floatingUI The element that will \"float\" when triggered.\n   * @param placement Reference FloatingUIPlacements.\n   * @param middleware Visit the official Floating UI documentation for more on [middleware options](https://floating-ui.com/docs/computePosition#middleware).\n   */\n  positionFloatingUI(\n    trigger: Element = this.trigger,\n    floatingUI: HTMLElement = this.floatingUI.nativeElement,\n    placement: FloatingUIPlacements = this.placement\n  ) {\n    autoUpdate(trigger, floatingUI, () => {\n      computePosition(trigger, floatingUI, {\n        placement: placement,\n        middleware: this.middleware\n      }).then(({ x, y, middlewareData, placement }: ComputePositionReturn) => {\n        floatingUI.style.left = `${x}px`;\n        floatingUI.style.top = `${y}px`;\n\n        if (middlewareData.arrow) {\n          // see: https://codesandbox.io/s/mystifying-kare-ee3hmh?file=/src/index.js\n          if (this.arrow) {\n            const { x, y } = middlewareData.arrow;\n\n            this.renderer.setStyle(this.arrow.el.nativeElement, 'left', x != null ? `${x}px` : '');\n            this.renderer.setStyle(this.arrow.el.nativeElement, 'top', y != null ? `${y}px` : '');\n            this.renderer.setStyle(this.arrow.el.nativeElement, 'right', '');\n            this.renderer.setStyle(this.arrow.el.nativeElement, 'bottom', '');\n\n            const side = placement.split('-')[0];\n            const staticSide = {\n              top: 'bottom',\n              bottom: 'top',\n              left: 'right',\n              right: 'left'\n            }[side];\n\n            if (staticSide) {\n              this.renderer.setStyle(\n                this.arrow.el.nativeElement,\n                staticSide,\n                -(this.arrow.el.nativeElement.offsetWidth / 2) + 'px'\n              );\n            }\n          }\n        }\n      });\n    });\n  }\n\n  /**\n   * The showFloatingUI method displays the Floating UI element.\n   */\n  showfloatingUI() {\n    if (this.appReadyService.isBrowserAndDomAvailable()) {\n      const triggerDisabled = this.trigger.getAttribute('disabled');\n      if (triggerDisabled) return;\n    }\n    this.positionFloatingUI();\n    this.isShown.set(true);\n    this.isShownEmitter.emit(this.isShown());\n    this.renderer.setStyle(this.floatingUI.nativeElement, 'display', this.display);\n  }\n\n  /**\n   * The hideFloatingUI method hides the Floating UI element.\n   */\n  hidefloatingUI() {\n    this.renderer.setStyle(this.floatingUI.nativeElement, 'display', 'none');\n    this.isShown.set(false);\n    this.isShownEmitter.emit(this.isShown());\n  }\n\n  /**\n   * The toggleFloatingUI method toggles the visibility of the Floating UI element.\n   */\n  toggleFloatingUI() {\n    if (this.isShown()) {\n      this.hidefloatingUI();\n    } else {\n      this.showfloatingUI();\n    }\n  }\n\n  /**\n   * The closeOnClickOut method closes the menu when a click occurs outside of the menu and the triggering element.\n   * @param event Document click event.\n   */\n  closeOnClickOut(event: Event) {\n    // listen for document click and close menu if click is outside of component\n    if (this.isShown()) {\n      const target = event.target as HTMLInputElement;\n      if (!this.floatingUI.nativeElement.contains(event.target) && !this.trigger.contains(target)) {\n        this.hidefloatingUI();\n      }\n    }\n  }\n\n  /**\n   * The addCloseActions method adds default close actions to the Floating UI component. These actions include closing the menu when the escape key is pressed or when clicking outside of the floating element.\n   */\n  addCloseActions() {\n    const document = this.appReadyService.checkDocumentExists();\n    // close menu on escape key press or clicking outside of menu\n    if (document) {\n      this.renderer.listen(document, 'click', this.closeOnClickOut.bind(this));\n      this.renderer.listen(document, 'keydown.esc', this.hidefloatingUI.bind(this));\n    }\n  }\n\n  /**\n   * The setUpTrigger method configures the triggering element by setting up the events to listen for and the actions to take when those events are triggered.\n   * @param eventArray Array of events for the reference/trigger element to listen for.<br> i.e. <code>[new UIEvent('focus'), FloatingUIVisibility.SHOW]</code> <br> tells the element to show the floating UI when the triggering element is focused.\n   */\n  setUpTrigger(eventArray: UIEventVisibilityPair) {\n    // add default actions to close menu\n    this.addCloseActions();\n    eventArray.forEach((pair) => {\n      /**\n       * if a custom eventArray is **not** typed as UIEventVisibilityPair[],<br />\n       * Typescript will type the array as ((UIEvent | \"show\")[] | (UIEvent | \"hide\")[])[] <br />\n       * because the passed arrays have different types, the type of the array is inferred as a union of the types of the passed arrays. <br />\n       * The following code ensures the correct types are assigned to the event and listener variables.\n       */\n      const event: UIEvent | undefined | FloatingUIVisibility = pair.find((e) => e instanceof UIEvent);\n      const listener: FloatingUIVisibility | undefined | UIEvent = pair.find(\n        (e) => e === FloatingUIVisibility.SHOW || e === FloatingUIVisibility.HIDE\n      );\n      if (event instanceof UIEvent) {\n        if (event.type === 'click') {\n          this.renderer.listen(this.trigger, event.type, this.toggleFloatingUI.bind(this));\n        } else if (event.type === 'mouseleave' && listener && listener === FloatingUIVisibility.HIDE) {\n          this.keepOnHover();\n        } else if (listener && listener === FloatingUIVisibility.SHOW) {\n          this.renderer.listen(this.trigger, event.type, this.showfloatingUI.bind(this));\n        } else if (listener && listener === FloatingUIVisibility.HIDE) {\n          this.renderer.listen(this.trigger, event.type, this.hidefloatingUI.bind(this));\n        }\n      }\n    });\n  }\n\n  // for keepOnHover\n  /** @ignore */\n  onTooltip = false;\n  /** @ignore */\n  onTrigger = false;\n\n  /**\n   * The keepOnHover method keeps the floating element visible when hovering over the trigger or the floating element.\n   */\n  keepOnHover() {\n    let offset = this.middleware.find((m: any) => m['name'] === 'offset') as any;\n    offset = this.hideOnHoverTimeout ? this.hideOnHoverTimeout : offset['options'] ? offset['options'] * 20 : 50;\n    this.renderer.listen(this.trigger, 'mouseleave', () => {\n      setTimeout(() => {\n        this.onTrigger = false;\n        if (!this.onTooltip) {\n          this.hidefloatingUI();\n        }\n      }, offset);\n    });\n    this.renderer.listen(this.trigger, 'mouseenter', () => {\n      this.onTrigger = true;\n    });\n\n    this.renderer.listen(this.floatingUI.nativeElement, 'mouseenter', () => {\n      this.onTooltip = true;\n    });\n    this.renderer.listen(this.floatingUI.nativeElement, 'mouseleave', () => {\n      setTimeout(() => {\n        this.onTooltip = false;\n        if (!this.onTrigger) {\n          this.hidefloatingUI();\n        }\n      }, offset);\n    });\n  }\n}\n"]}