@ember-eui/core 11.0.3 → 12.0.1

package/dist/components/eui-popover.js

@@ -1,7 +1,7 @@
 import Component from '@glimmer/component';
 import { tracked } from '@glimmer/tracking';
 import { assert } from '@ember/debug';
-import { concat, hash } from '@ember/helper';
+import { hash, concat } from '@ember/helper';
 import { action } from '@ember/object';
 import didInsert from '@ember/render-modifiers/modifiers/did-insert';
 import didUpdate from '@ember/render-modifiers/modifiers/did-update';
@@ -10,7 +10,7 @@ import { htmlSafe } from '@ember/template';
 import optional from 'ember-composable-helpers/helpers/optional';
 import { focusTrap } from 'ember-focus-trap';
 import onKey from 'ember-keyboard/modifiers/on-key';
-import { or, not, and } from 'ember-truth-helpers';
+import { and, not, or } from 'ember-truth-helpers';
 import { tabbable } from 'tabbable';
 import randomId from '../-private/random-id.js';
 import { argOrDefaultDecorator } from '../helpers/arg-or-default.js';
@@ -36,31 +36,31 @@ const anchorPositionToPopoverPositionMap = {
   down: 'bottom',
   left: 'left'
 };
-function getPopoverPositionFromAnchorPosition(anchorPosition1) {
+function getPopoverPositionFromAnchorPosition(anchorPosition) {
   // maps the anchor position to the matching popover position
   // e.g. "upLeft" -> "top", "downRight" -> "bottom"
   // extract the first positional word from anchorPosition:
   // starts at the beginning (" ^ ") of anchorPosition and
   // captures all of the characters (" (.*?) ") until the
   // first capital letter (" [A-Z] ") is encountered
-  const match1 = anchorPosition1.match(/^(.*?)[A-Z]/);
-  if (match1?.length && match1.length > 1) {
-    return anchorPositionToPopoverPositionMap[match1[1]];
+  const match = anchorPosition.match(/^(.*?)[A-Z]/);
+  if (match?.length && match.length > 1) {
+    return anchorPositionToPopoverPositionMap[match[1]];
   }
   return anchorPositionToPopoverPositionMap['up'];
 }
-function getPopoverAlignFromAnchorPosition(anchorPosition1) {
+function getPopoverAlignFromAnchorPosition(anchorPosition) {
   // maps the gravity to the matching popover position
   // e.g. "upLeft" -> "left", "rightDown" -> "bottom"
   // extract the second positional word from anchorPosition:
   // starts a capture group at the first capital letter
   // and includes everything after it
-  const match1 = anchorPosition1.match(/([A-Z].*)/);
+  const match = anchorPosition.match(/([A-Z].*)/);
   // this performs two tasks:
   // 1. normalizes the align position by lowercasing it
   // 2. `center` doesn't exist in the lookup map which converts it to `undefined` meaning no align
-  if (match1?.length && match1.length > 1) {
-    return anchorPositionToPopoverPositionMap[match1[1]?.toLowerCase()];
+  if (match?.length && match.length > 1) {
+    return anchorPositionToPopoverPositionMap[match[1]?.toLowerCase()];
   }
   return anchorPositionToPopoverPositionMap['left'];
 }
@@ -70,109 +70,109 @@ const DEFAULT_POPOVER_STYLES = {
   top: 50,
   left: 50
 };
-function getElementFromInitialFocus(initialFocus1) {
-  const initialFocusType1 = typeof initialFocus1;
-  if (initialFocusType1 === 'string') {
-    return document.querySelector(initialFocus1);
+function getElementFromInitialFocus(initialFocus) {
+  const initialFocusType = typeof initialFocus;
+  if (initialFocusType === 'string') {
+    return document.querySelector(initialFocus);
   }
-  if (initialFocusType1 === 'function') {
-    return initialFocus1();
+  if (initialFocusType === 'function') {
+    return initialFocus();
   }
-  return initialFocus1;
+  return initialFocus;
 }
 class EuiPopoverComponent extends Component {
   static {
     g(this.prototype, "isOpen", [argOrDefaultDecorator(false)]);
   }
-  #isOpen = (i(this, "isOpen"), void 0); // Defaults
+  #isOpen = (i(this, "isOpen"), undefined); // Defaults
   static {
     g(this.prototype, "ownFocus", [argOrDefaultDecorator(true)]);
   }
-  #ownFocus = (i(this, "ownFocus"), void 0);
+  #ownFocus = (i(this, "ownFocus"), undefined);
   static {
     g(this.prototype, "anchorPosition", [argOrDefaultDecorator('downCenter')]);
   }
-  #anchorPosition = (i(this, "anchorPosition"), void 0);
+  #anchorPosition = (i(this, "anchorPosition"), undefined);
   static {
     g(this.prototype, "panelPaddingSize", [argOrDefaultDecorator('m')]);
   }
-  #panelPaddingSize = (i(this, "panelPaddingSize"), void 0);
+  #panelPaddingSize = (i(this, "panelPaddingSize"), undefined);
   static {
     g(this.prototype, "hasArrow", [argOrDefaultDecorator(true)]);
   }
-  #hasArrow = (i(this, "hasArrow"), void 0);
+  #hasArrow = (i(this, "hasArrow"), undefined);
   static {
     g(this.prototype, "display", [argOrDefaultDecorator('inlineBlock')]);
   }
-  #display = (i(this, "display"), void 0);
+  #display = (i(this, "display"), undefined);
   static {
     g(this.prototype, "shouldSelfFocus", [argOrDefaultDecorator(true)]);
   }
-  #shouldSelfFocus = (i(this, "shouldSelfFocus"), void 0);
+  #shouldSelfFocus = (i(this, "shouldSelfFocus"), undefined);
   static {
     g(this.prototype, "isFocusTrapPaused", [argOrDefaultDecorator(false)]);
   }
-  #isFocusTrapPaused = (i(this, "isFocusTrapPaused"), void 0);
+  #isFocusTrapPaused = (i(this, "isFocusTrapPaused"), undefined);
   static {
     g(this.prototype, "prevIsOpen", [tracked]);
   }
-  #prevIsOpen = (i(this, "prevIsOpen"), void 0); //State
+  #prevIsOpen = (i(this, "prevIsOpen"), undefined); //State
   static {
     g(this.prototype, "suppressingPopover", [tracked]);
   }
-  #suppressingPopover = (i(this, "suppressingPopover"), void 0);
+  #suppressingPopover = (i(this, "suppressingPopover"), undefined);
   static {
     g(this.prototype, "isClosing", [tracked], function () {
       return false;
     });
   }
-  #isClosing = (i(this, "isClosing"), void 0);
+  #isClosing = (i(this, "isClosing"), undefined);
   static {
     g(this.prototype, "isOpening", [tracked], function () {
       return false;
     });
   }
-  #isOpening = (i(this, "isOpening"), void 0);
+  #isOpening = (i(this, "isOpening"), undefined);
   static {
     g(this.prototype, "popoverStyles", [tracked], function () {
       return {};
     });
   }
-  #popoverStyles = (i(this, "popoverStyles"), void 0);
+  #popoverStyles = (i(this, "popoverStyles"), undefined);
   static {
     g(this.prototype, "arrowStyles", [tracked], function () {
       return {};
     });
   }
-  #arrowStyles = (i(this, "arrowStyles"), void 0);
+  #arrowStyles = (i(this, "arrowStyles"), undefined);
   static {
     g(this.prototype, "arrowPosition", [tracked], function () {
       return null;
     });
   }
-  #arrowPosition = (i(this, "arrowPosition"), void 0);
+  #arrowPosition = (i(this, "arrowPosition"), undefined);
   static {
     g(this.prototype, "openPosition", [tracked], function () {
       return null;
     });
   }
-  #openPosition = (i(this, "openPosition"), void 0);
+  #openPosition = (i(this, "openPosition"), undefined);
   static {
     g(this.prototype, "isOpenStable", [tracked], function () {
       return false;
     });
   }
-  #isOpenStable = (i(this, "isOpenStable"), void 0);
+  #isOpenStable = (i(this, "isOpenStable"), undefined);
   static {
     g(this.prototype, "isCurrentlyOpen", [tracked]);
   }
-  #isCurrentlyOpen = (i(this, "isCurrentlyOpen"), void 0);
+  #isCurrentlyOpen = (i(this, "isCurrentlyOpen"), undefined);
   static {
     g(this.prototype, "popoverHost", [tracked], function () {
       return null;
     });
   }
-  #popoverHost = (i(this, "popoverHost"), void 0);
+  #popoverHost = (i(this, "popoverHost"), undefined);
   ///
   respositionTimeout = null;
   closingTransitionTimeout = null;
@@ -184,15 +184,15 @@ class EuiPopoverComponent extends Component {
       return null;
     });
   }
-  #button = (i(this, "button"), void 0);
+  #button = (i(this, "button"), undefined);
   static {
     g(this.prototype, "panel", [tracked], function () {
       return null;
     });
   }
-  #panel = (i(this, "panel"), void 0);
-  constructor(owner1, args1) {
-    super(owner1, args1);
+  #panel = (i(this, "panel"), undefined);
+  constructor(owner, args) {
+    super(owner, args);
     assert(`Must provide closePopover function`, this.args.closePopover);
     this.prevIsOpen = this.isOpen;
     this.suppressingPopover = this.isOpen;
@@ -220,33 +220,33 @@ class EuiPopoverComponent extends Component {
   static {
     n(this.prototype, "closePopover", [action]);
   }
-  onEscapeKey(event1, ekEvent1) {
+  onEscapeKey(event, ekEvent) {
     if (this.isOpen) {
-      ekEvent1?.stopPropagation();
-      ekEvent1?.stopImmediatePropagation();
-      event1.preventDefault();
-      event1.stopPropagation();
+      ekEvent?.stopPropagation();
+      ekEvent?.stopImmediatePropagation();
+      event.preventDefault();
+      event.stopPropagation();
       this.closePopover();
     }
   }
   static {
     n(this.prototype, "onEscapeKey", [action]);
   }
-  onKeyDown(event1, ekEvent1) {
-    if (event1.key === cascadingMenuKeys.ESCAPE) {
-      this.onEscapeKey(event1, ekEvent1);
+  onKeyDown(event, ekEvent) {
+    if (event.key === cascadingMenuKeys.ESCAPE) {
+      this.onEscapeKey(event, ekEvent);
     }
   }
   static {
     n(this.prototype, "onKeyDown", [action]);
   }
-  onClickOutside(event1) {
+  onClickOutside(event) {
     if (this.args.focusTrapOptions?.onClickOutside) {
-      this.args.focusTrapOptions.onClickOutside(event1);
+      this.args.focusTrapOptions.onClickOutside(event);
     } else {
       // only close the popover if the event source isn't the anchor button
       // otherwise, it is up to the anchor to toggle the popover's open status
-      if (this.button && this.button.contains(event1.target) === false) {
+      if (this.button && this.button.contains(event.target) === false) {
         this.closePopover();
       }
     }
@@ -265,41 +265,41 @@ class EuiPopoverComponent extends Component {
         return;
       }
       // Otherwise let's focus the first tabbable item and expedite input from the user.
-      let focusTarget1;
+      let focusTarget;
       if (this.args.initialFocus != null) {
-        focusTarget1 = getElementFromInitialFocus(this.args.initialFocus);
+        focusTarget = getElementFromInitialFocus(this.args.initialFocus);
       } else {
-        const tabbableItems1 = tabbable(this.panel);
-        if (tabbableItems1.length) {
-          focusTarget1 = tabbableItems1[0];
+        const tabbableItems = tabbable(this.panel);
+        if (tabbableItems.length) {
+          focusTarget = tabbableItems[0];
         }
       }
       // there's a race condition between the popover content becoming visible and this function call
       // if the element isn't visible yet (due to css styling) then it can't accept focus
       // so wait for another render and try again
-      if (focusTarget1 == null) {
+      if (focusTarget == null) {
         // there isn't a focus target, one of two reasons:
         // #1 is the whole panel hidden? If so, schedule another check
         // #2 panel is visible but no tabbables exist, move focus to the panel
-        const panelVisibility1 = window.getComputedStyle(this.panel).opacity;
-        if (panelVisibility1 === '0') {
+        const panelVisibility = window.getComputedStyle(this.panel).opacity;
+        if (panelVisibility === '0') {
           // #1
           this.updateFocus();
         } else {
           // #2
-          focusTarget1 = this.panel;
+          focusTarget = this.panel;
         }
       } else {
         // found an element to focus, but is it visible?
-        const visibility1 = window.getComputedStyle(focusTarget1).visibility;
-        if (visibility1 === 'hidden') {
+        const visibility = window.getComputedStyle(focusTarget).visibility;
+        if (visibility === 'hidden') {
           // not visible, check again next render frame
           this.updateFocus();
         }
       }
-      if (focusTarget1 != null) {
+      if (focusTarget != null) {
         this.hasSetInitialFocus = true;
-        focusTarget1.focus();
+        focusTarget.focus();
       }
     });
   }
@@ -312,16 +312,16 @@ class EuiPopoverComponent extends Component {
     });
     // for each child element of `this.panel`, find any transition duration we should wait for before stabilizing
     const {
-      durationMatch: durationMatch1,
-      delayMatch: delayMatch1
+      durationMatch,
+      delayMatch
     } = Array.prototype.slice.call(this.panel ? this.panel.children : []).reduce(({
-      durationMatch: durationMatch1,
-      delayMatch: delayMatch1
-    }, element1) => {
-      const transitionTimings1 = getTransitionTimings(element1);
+      durationMatch,
+      delayMatch
+    }, element) => {
+      const transitionTimings = getTransitionTimings(element);
       return {
-        durationMatch: Math.max(durationMatch1, transitionTimings1.durationMatch),
-        delayMatch: Math.max(delayMatch1, transitionTimings1.delayMatch)
+        durationMatch: Math.max(durationMatch, transitionTimings.durationMatch),
+        delayMatch: Math.max(delayMatch, transitionTimings.delayMatch)
       };
     }, {
       durationMatch: 0,
@@ -329,12 +329,12 @@ class EuiPopoverComponent extends Component {
     });
     this.respositionTimeout = later(this, () => {
       this.isOpenStable = true;
-      const fn1 = () => {
+      const fn = () => {
         this.positionPopoverFixed();
         this.updateFocus();
       };
-      scheduleOnce('afterRender', this, fn1);
-    }, durationMatch1 + delayMatch1);
+      scheduleOnce('afterRender', this, fn);
+    }, durationMatch + delayMatch);
   }
   static {
     n(this.prototype, "onOpenPopover", [action]);
@@ -342,24 +342,24 @@ class EuiPopoverComponent extends Component {
   get shouldAccountForOtherPopovers() {
     return this.args.shouldAccountForOtherPopovers ?? true;
   }
-  checkIfPopoverIsInsideAnotherPopover(ele1) {
-    const otherPopover1 = ele1.closest('div.euiPopover__panel');
-    this.popoverHost = otherPopover1;
+  checkIfPopoverIsInsideAnotherPopover(ele) {
+    const otherPopover = ele.closest('div.euiPopover__panel');
+    this.popoverHost = otherPopover;
   }
-  didInsertPopover(ele1) {
+  didInsertPopover(ele) {
     if (this.suppressingPopover) {
       // component was created with isOpen=true; now that it's inserted
       // stop suppressing and start opening
       this.suppressingPopover = false;
       this.isOpening = true;
-      const fn1 = () => this.onOpenPopover();
-      scheduleOnce('afterRender', this, fn1);
+      const fn = () => this.onOpenPopover();
+      scheduleOnce('afterRender', this, fn);
     }
     if (this.args.repositionOnScroll) {
       window.addEventListener('scroll', this.positionPopoverFixed, true);
     }
     if (this.shouldAccountForOtherPopovers) {
-      this.checkIfPopoverIsInsideAnotherPopover(ele1);
+      this.checkIfPopoverIsInsideAnotherPopover(ele);
     }
     this.updateFocus();
   }
@@ -404,33 +404,33 @@ class EuiPopoverComponent extends Component {
     cancelAnimationFrame(this.closingTransitionAnimationFrame);
     cancelAnimationFrame(this.updateFocusAnimationFrame);
   }
-  onMutation(records1) {
-    const waitDuration1 = getWaitDuration(records1);
+  onMutation(records) {
+    const waitDuration = getWaitDuration(records);
     this.positionPopoverFixed();
-    performOnFrame(waitDuration1, this.positionPopoverFixed);
+    performOnFrame(waitDuration, this.positionPopoverFixed);
   }
   static {
     n(this.prototype, "onMutation", [action]);
   }
-  positionPopover(allowEnforcePosition1) {
+  positionPopover(allowEnforcePosition) {
     if (this.button == null || this.panel == null) return;
-    let position1 = getPopoverPositionFromAnchorPosition(this.anchorPosition);
-    let forcePosition1 = undefined;
-    if (allowEnforcePosition1 && this.isOpenStable && this.openPosition != null) {
-      position1 = this.openPosition;
-      forcePosition1 = true;
+    let position = getPopoverPositionFromAnchorPosition(this.anchorPosition);
+    let forcePosition = undefined;
+    if (allowEnforcePosition && this.isOpenStable && this.openPosition != null) {
+      position = this.openPosition;
+      forcePosition = true;
     }
     const {
-      top: top1,
-      left: left1,
-      position: foundPosition1,
-      arrow: arrow1,
-      anchorBoundingBox: anchorBoundingBox1
+      top,
+      left,
+      position: foundPosition,
+      arrow,
+      anchorBoundingBox
     } = findPopoverPosition({
       container: this.args.container,
       host: this.shouldAccountForOtherPopovers ? this.popoverHost : null,
-      position: position1,
-      forcePosition: forcePosition1,
+      position,
+      forcePosition,
       align: getPopoverAlignFromAnchorPosition(this.anchorPosition),
       anchor: this.button,
       popover: this.panel,
@@ -446,43 +446,43 @@ class EuiPopoverComponent extends Component {
     // this keeps a button's popover under a flyout that would cover the button
     // but a popover triggered inside a flyout will appear over that flyout
     const {
-      zIndex: zIndexProp1
+      zIndex: zIndexProp
     } = this.args;
-    const zIndex1 = zIndexProp1 == null ? getElementZIndex(this.button, this.panel) + 2000 : zIndexProp1;
-    const popoverStyles1 = {
-      top: top1,
-      left: this.args.attachToAnchor && anchorBoundingBox1 ? anchorBoundingBox1.left : left1,
-      zIndex: zIndex1
+    const zIndex = zIndexProp == null ? getElementZIndex(this.button, this.panel) + 2000 : zIndexProp;
+    const popoverStyles = {
+      top,
+      left: this.args.attachToAnchor && anchorBoundingBox ? anchorBoundingBox.left : left,
+      zIndex
     };
-    const willRenderArrow1 = !this.args.attachToAnchor && this.hasArrow;
-    const arrowStyles1 = willRenderArrow1 ? arrow1 : undefined;
-    const arrowPosition1 = foundPosition1;
-    this.popoverStyles = popoverStyles1;
-    this.arrowStyles = arrowStyles1;
-    this.arrowPosition = arrowPosition1;
-    this.openPosition = foundPosition1;
+    const willRenderArrow = !this.args.attachToAnchor && this.hasArrow;
+    const arrowStyles = willRenderArrow ? arrow : undefined;
+    const arrowPosition = foundPosition;
+    this.popoverStyles = popoverStyles;
+    this.arrowStyles = arrowStyles;
+    this.arrowPosition = arrowPosition;
+    this.openPosition = foundPosition;
   }
   static {
     n(this.prototype, "positionPopover", [action]);
   }
   get _arrowStyles() {
     const {
-      arrowStyles: arrowStyles1
+      arrowStyles
     } = this;
-    return arrowStyles1 ? htmlSafe(`top: ${arrowStyles1?.top}px; left: ${arrowStyles1?.left}px;`) : undefined;
+    return arrowStyles ? htmlSafe(`top: ${arrowStyles?.top}px; left: ${arrowStyles?.left}px;`) : undefined;
   }
   get _popoverStyles() {
     const {
-      panelStyle: panelStyle1
+      panelStyle
     } = this.args;
     const {
-      popoverStyles: popoverStyles1
+      popoverStyles
     } = this;
     return {
-      ...panelStyle1,
-      top: `${popoverStyles1.top}px`,
-      left: `${popoverStyles1.left}px`,
-      zIndex: `${popoverStyles1.zIndex}`
+      ...panelStyle,
+      top: `${popoverStyles.top}px`,
+      left: `${popoverStyles.left}px`,
+      zIndex: `${popoverStyles.zIndex}`
     };
   }
   get tabindex() {
@@ -503,17 +503,17 @@ class EuiPopoverComponent extends Component {
   static {
     n(this.prototype, "positionPopoverFluid", [action]);
   }
-  registerButton(btn1) {
-    this.button = btn1;
-    this.args.buttonRef?.(btn1);
+  registerButton(btn) {
+    this.button = btn;
+    this.args.buttonRef?.(btn);
   }
   static {
     n(this.prototype, "registerButton", [action]);
   }
-  registerPanel(panel1) {
-    this.panel = panel1;
-    this.args.panelRef?.(panel1);
-    if (panel1 === null) {
+  registerPanel(panel) {
+    this.panel = panel;
+    this.args.panelRef?.(panel);
+    if (panel === null) {
       // panel has unmounted, restore the state defaults
       this.popoverStyles = DEFAULT_POPOVER_STYLES;
       this.arrowStyles = {};