@ember-eui/core 11.0.2 → 12.0.0

package/dist/components/eui-dual-range.js

@@ -8,7 +8,7 @@ import didInsert from '@ember/render-modifiers/modifiers/did-insert';
 import { later } from '@ember/runloop';
 import optional from 'ember-composable-helpers/helpers/optional';
 import onKey from 'ember-keyboard/modifiers/on-key';
-import { and, not, or, eq } from 'ember-truth-helpers';
+import { eq, or, not, and } from 'ember-truth-helpers';
 import argOrDefault, { argOrDefaultDecorator } from '../helpers/arg-or-default.js';
 import castTo from '../helpers/cast-to.js';
 import simpleStyle from '../modifiers/simple-style.js';
@@ -32,84 +32,84 @@ class EuiDualRangeComponent extends Component {
   static {
     g(this.prototype, "min", [argOrDefaultDecorator(0)]);
   }
-  #min = (i(this, "min"), void 0); // Defaults
+  #min = (i(this, "min"), undefined); // Defaults
   static {
     g(this.prototype, "max", [argOrDefaultDecorator(100)]);
   }
-  #max = (i(this, "max"), void 0);
+  #max = (i(this, "max"), undefined);
   static {
     g(this.prototype, "step", [argOrDefaultDecorator(1)]);
   }
-  #step = (i(this, "step"), void 0);
+  #step = (i(this, "step"), undefined);
   static {
     g(this.prototype, "fullWidth", [argOrDefaultDecorator(false)]);
   }
-  #fullWidth = (i(this, "fullWidth"), void 0);
+  #fullWidth = (i(this, "fullWidth"), undefined);
   static {
     g(this.prototype, "compressed", [argOrDefaultDecorator(false)]);
   }
-  #compressed = (i(this, "compressed"), void 0);
+  #compressed = (i(this, "compressed"), undefined);
   static {
     g(this.prototype, "showLabels", [argOrDefaultDecorator(false)]);
   }
-  #showLabels = (i(this, "showLabels"), void 0);
+  #showLabels = (i(this, "showLabels"), undefined);
   static {
     g(this.prototype, "showInput", [argOrDefaultDecorator(false)]);
   }
-  #showInput = (i(this, "showInput"), void 0);
+  #showInput = (i(this, "showInput"), undefined);
   static {
     g(this.prototype, "showRange", [argOrDefaultDecorator(true)]);
   }
-  #showRange = (i(this, "showRange"), void 0);
+  #showRange = (i(this, "showRange"), undefined);
   static {
     g(this.prototype, "showTicks", [argOrDefaultDecorator(false)]);
   }
-  #showTicks = (i(this, "showTicks"), void 0);
+  #showTicks = (i(this, "showTicks"), undefined);
   static {
     g(this.prototype, "levels", [argOrDefaultDecorator([])]);
   }
-  #levels = (i(this, "levels"), void 0);
+  #levels = (i(this, "levels"), undefined);
   static {
     g(this.prototype, "id", [tracked], function () {
       return this.args.id || guidFor({});
     });
   }
-  #id = (i(this, "id"), void 0); //State
+  #id = (i(this, "id"), undefined); //State
   static {
     g(this.prototype, "hasFocus", [tracked], function () {
       return false;
     });
   }
-  #hasFocus = (i(this, "hasFocus"), void 0);
+  #hasFocus = (i(this, "hasFocus"), undefined);
   static {
     g(this.prototype, "rangeSliderRefAvailable", [tracked], function () {
       return false;
     });
   }
-  #rangeSliderRefAvailable = (i(this, "rangeSliderRefAvailable"), void 0);
+  #rangeSliderRefAvailable = (i(this, "rangeSliderRefAvailable"), undefined);
   static {
     g(this.prototype, "isPopoverOpen", [tracked], function () {
       return false;
     });
   }
-  #isPopoverOpen = (i(this, "isPopoverOpen"), void 0);
+  #isPopoverOpen = (i(this, "isPopoverOpen"), undefined);
   static {
     g(this.prototype, "rangeWidth", [tracked]);
   }
-  #rangeWidth = (i(this, "rangeWidth"), void 0);
+  #rangeWidth = (i(this, "rangeWidth"), undefined);
   static {
     g(this.prototype, "isVisible", [tracked], function () {
       return true;
     });
   }
-  #isVisible = (i(this, "isVisible"), void 0);
+  #isVisible = (i(this, "isVisible"), undefined);
   ///
   preventPopoverClose = false;
   rangeSliderRef = null;
-  didInsertRangeSlider(ref1) {
-    this.rangeSliderRef = ref1;
-    this.rangeSliderRefAvailable = !!ref1;
-    this.rangeWidth = ref1 ? ref1.clientWidth : undefined;
+  didInsertRangeSlider(ref) {
+    this.rangeSliderRef = ref;
+    this.rangeSliderRefAvailable = !!ref;
+    this.rangeWidth = ref ? ref.clientWidth : undefined;
     if (this.rangeSliderRef?.clientWidth && !this.isVisible) {
       this.isVisible = true;
     }
@@ -132,189 +132,189 @@ class EuiDualRangeComponent extends Component {
   get isValid() {
     return this.lowerValueIsValid && this.upperValueIsValid;
   }
-  _determineInvalidThumbMovement(newVal1, lower1, upper1, e1) {
+  _determineInvalidThumbMovement(newVal, lower, upper, e) {
     // If the values are invalid, find whether the new value is in the upper
     // or lower half and move the appropriate handle to the new value,
     // while the other handle gets moved to the opposite bound (if invalid)
-    const lowerHalf1 = Math.abs(this.max - this.min) / 2 + this.min;
-    const newValIsLow1 = isWithinRange(this.min, lowerHalf1, newVal1);
-    if (newValIsLow1) {
-      lower1 = newVal1;
-      upper1 = !this.upperValueIsValid ? this.max : upper1;
+    const lowerHalf = Math.abs(this.max - this.min) / 2 + this.min;
+    const newValIsLow = isWithinRange(this.min, lowerHalf, newVal);
+    if (newValIsLow) {
+      lower = newVal;
+      upper = !this.upperValueIsValid ? this.max : upper;
     } else {
-      lower1 = !this.lowerValueIsValid ? this.min : lower1;
-      upper1 = newVal1;
+      lower = !this.lowerValueIsValid ? this.min : lower;
+      upper = newVal;
     }
-    this._handleOnChange(lower1, upper1, e1);
+    this._handleOnChange(lower, upper, e);
   }
   static {
     n(this.prototype, "_determineInvalidThumbMovement", [action]);
   }
-  _determineValidThumbMovement(newVal1, lower1, upper1, e1) {
+  _determineValidThumbMovement(newVal, lower, upper, e) {
     // Lower thumb targeted or right-moving swap has occurred
-    if (Math.abs(lower1 - newVal1) < Math.abs(upper1 - newVal1)) {
-      lower1 = newVal1;
+    if (Math.abs(lower - newVal) < Math.abs(upper - newVal)) {
+      lower = newVal;
     } else {
-      upper1 = newVal1;
+      upper = newVal;
     }
-    this._handleOnChange(lower1, upper1, e1);
+    this._handleOnChange(lower, upper, e);
   }
   static {
     n(this.prototype, "_determineValidThumbMovement", [action]);
   }
-  _determineThumbMovement(newVal1, e1) {
+  _determineThumbMovement(newVal, e) {
     // Determine thumb movement based on slider interaction
     if (!this.isValid) {
       // Non-standard positioning follows
-      this._determineInvalidThumbMovement(newVal1, this.lowerValue, this.upperValue, e1);
+      this._determineInvalidThumbMovement(newVal, this.lowerValue, this.upperValue, e);
     } else {
       // Standard positioning based on click event proximity to thumb locations
-      this._determineValidThumbMovement(newVal1, this.lowerValue, this.upperValue, e1);
+      this._determineValidThumbMovement(newVal, this.lowerValue, this.upperValue, e);
     }
   }
   static {
     n(this.prototype, "_determineThumbMovement", [action]);
   }
-  _handleOnChange(lower1, upper1, e1) {
-    const isValid1 = isWithinRange(this.min, upper1, lower1) && isWithinRange(lower1, this.max, upper1);
-    this.args.onChange([lower1, upper1], isValid1, e1);
+  _handleOnChange(lower, upper, e) {
+    const isValid = isWithinRange(this.min, upper, lower) && isWithinRange(lower, this.max, upper);
+    this.args.onChange([lower, upper], isValid, e);
   }
   static {
     n(this.prototype, "_handleOnChange", [action]);
   }
-  handleSliderChange(e1) {
-    this._determineThumbMovement(Number(e1.currentTarget.value), e1);
+  handleSliderChange(e) {
+    this._determineThumbMovement(Number(e.currentTarget.value), e);
   }
   static {
     n(this.prototype, "handleSliderChange", [action]);
   }
-  _resetToRangeEnds(e1) {
+  _resetToRangeEnds(e) {
     // Arbitrary decision to pass `min` instead of `max`. Result is the same.
-    this._determineInvalidThumbMovement(this.min, this.lowerValue, this.upperValue, e1);
+    this._determineInvalidThumbMovement(this.min, this.lowerValue, this.upperValue, e);
   }
   static {
     n(this.prototype, "_resetToRangeEnds", [action]);
   }
-  _isDirectionalKeyPress(event1) {
-    return [keys.ARROW_UP, keys.ARROW_RIGHT, keys.ARROW_DOWN, keys.ARROW_LEFT].indexOf(event1.key) > -1;
+  _isDirectionalKeyPress(event) {
+    return [keys.ARROW_UP, keys.ARROW_RIGHT, keys.ARROW_DOWN, keys.ARROW_LEFT].indexOf(event.key) > -1;
   }
   static {
     n(this.prototype, "_isDirectionalKeyPress", [action]);
   }
-  handleInputKeyDown(e1) {
+  handleInputKeyDown(e) {
     // Relevant only when initial values are both `''` and `showInput` is set
-    if (this._isDirectionalKeyPress(e1) && !this.isValid) {
-      e1.preventDefault();
-      this._resetToRangeEnds(e1);
+    if (this._isDirectionalKeyPress(e) && !this.isValid) {
+      e.preventDefault();
+      this._resetToRangeEnds(e);
     }
   }
   static {
     n(this.prototype, "handleInputKeyDown", [action]);
   }
-  handleLowerInputChange(e1) {
-    this._handleOnChange(e1.target.value, this.upperValue, e1);
+  handleLowerInputChange(e) {
+    this._handleOnChange(e.target.value, this.upperValue, e);
   }
   static {
     n(this.prototype, "handleLowerInputChange", [action]);
   }
-  handleUpperInputChange(e1) {
-    this._handleOnChange(this.lowerValue, e1.target.value, e1);
+  handleUpperInputChange(e) {
+    this._handleOnChange(this.lowerValue, e.target.value, e);
   }
   static {
     n(this.prototype, "handleUpperInputChange", [action]);
   }
-  _handleKeyDown(value1, event1) {
-    let newVal1 = Number(value1);
-    let stepRemainder1 = 0;
-    const step1 = this.args.step || 1;
-    switch (event1.key) {
+  _handleKeyDown(value, event) {
+    let newVal = Number(value);
+    let stepRemainder = 0;
+    const step = this.args.step || 1;
+    switch (event.key) {
       case keys.ARROW_UP:
       case keys.ARROW_RIGHT:
-        event1.preventDefault();
-        newVal1 += step1;
-        stepRemainder1 = (newVal1 - this.min) % step1;
-        if (step1 !== 1 && stepRemainder1 > 0) {
-          newVal1 = newVal1 - stepRemainder1;
+        event.preventDefault();
+        newVal += step;
+        stepRemainder = (newVal - this.min) % step;
+        if (step !== 1 && stepRemainder > 0) {
+          newVal = newVal - stepRemainder;
         }
         break;
       case keys.ARROW_DOWN:
       case keys.ARROW_LEFT:
-        event1.preventDefault();
-        newVal1 -= step1;
-        stepRemainder1 = (newVal1 - this.min) % step1;
-        if (step1 !== 1 && stepRemainder1 > 0) {
-          newVal1 = newVal1 + (step1 - stepRemainder1);
+        event.preventDefault();
+        newVal -= step;
+        stepRemainder = (newVal - this.min) % step;
+        if (step !== 1 && stepRemainder > 0) {
+          newVal = newVal + (step - stepRemainder);
         }
         break;
     }
-    return newVal1;
+    return newVal;
   }
   static {
     n(this.prototype, "_handleKeyDown", [action]);
   }
-  handleLowerKeyDown(event1) {
-    let lower1 = this.lowerValue;
-    switch (event1.key) {
+  handleLowerKeyDown(event) {
+    let lower = this.lowerValue;
+    switch (event.key) {
       case keys.TAB:
         return;
       default:
         if (!this.lowerValueIsValid) {
           // Relevant only when initial value is `''` and `showInput` is not set
-          event1.preventDefault();
-          this._resetToRangeEnds(event1);
+          event.preventDefault();
+          this._resetToRangeEnds(event);
           return;
         }
-        lower1 = this._handleKeyDown(lower1, event1);
+        lower = this._handleKeyDown(lower, event);
     }
-    if (lower1 >= this.upperValue || lower1 < this.min) return;
-    this._handleOnChange(lower1, this.upperValue, event1);
+    if (lower >= this.upperValue || lower < this.min) return;
+    this._handleOnChange(lower, this.upperValue, event);
   }
   static {
     n(this.prototype, "handleLowerKeyDown", [action]);
   }
-  handleUpperKeyDown(event1) {
-    let upper1 = this.upperValue;
-    switch (event1.key) {
+  handleUpperKeyDown(event) {
+    let upper = this.upperValue;
+    switch (event.key) {
       case keys.TAB:
         return;
       default:
         if (!this.upperValueIsValid) {
           // Relevant only when initial value is `''` and `showInput` is not set
-          event1.preventDefault();
-          this._resetToRangeEnds(event1);
+          event.preventDefault();
+          this._resetToRangeEnds(event);
           return;
         }
-        upper1 = this._handleKeyDown(upper1, event1);
+        upper = this._handleKeyDown(upper, event);
     }
-    if (upper1 <= this.lowerValue || upper1 > this.max) return;
-    this._handleOnChange(this.lowerValue, upper1, event1);
+    if (upper <= this.lowerValue || upper > this.max) return;
+    this._handleOnChange(this.lowerValue, upper, event);
   }
   static {
     n(this.prototype, "handleUpperKeyDown", [action]);
   }
-  calculateThumbPositionStyle(value1, width1) {
+  calculateThumbPositionStyle(value, width) {
     // Calculate the left position based on value
-    const decimal1 = (value1 - this.min) / (this.max - this.min);
+    const decimal = (value - this.min) / (this.max - this.min);
     // Must be between 0-100%
-    let valuePosition1 = decimal1 <= 1 ? decimal1 : 1;
-    valuePosition1 = valuePosition1 >= 0 ? valuePosition1 : 0;
-    const trackWidth1 = this.args.showInput === 'inputWithPopover' && !!width1 ? width1 : this.rangeSliderRef?.clientWidth;
-    let thumbToTrackRatio1 = 0;
-    if (trackWidth1) {
-      thumbToTrackRatio1 = EUI_THUMB_SIZE / trackWidth1;
+    let valuePosition = decimal <= 1 ? decimal : 1;
+    valuePosition = valuePosition >= 0 ? valuePosition : 0;
+    const trackWidth = this.args.showInput === 'inputWithPopover' && !!width ? width : this.rangeSliderRef?.clientWidth;
+    let thumbToTrackRatio = 0;
+    if (trackWidth) {
+      thumbToTrackRatio = EUI_THUMB_SIZE / trackWidth;
     } else {
-      thumbToTrackRatio1 = EUI_THUMB_SIZE / 1;
+      thumbToTrackRatio = EUI_THUMB_SIZE / 1;
     }
-    const trackPositionScale1 = (1 - thumbToTrackRatio1) * 100;
+    const trackPositionScale = (1 - thumbToTrackRatio) * 100;
     return {
-      left: `${valuePosition1 * trackPositionScale1}%`
+      left: `${valuePosition * trackPositionScale}%`
     };
   }
   static {
     n(this.prototype, "calculateThumbPositionStyle", [action]);
   }
-  setPreventPopoverClose(value1) {
-    this.preventPopoverClose = value1;
+  setPreventPopoverClose(value) {
+    this.preventPopoverClose = value;
   }
   static {
     n(this.prototype, "setPreventPopoverClose", [action]);
@@ -331,27 +331,27 @@ class EuiDualRangeComponent extends Component {
   static {
     n(this.prototype, "toggleHasFocus", [action]);
   }
-  onThumbFocus(e1) {
+  onThumbFocus(e) {
     if (this.args.onFocus) {
-      this.args.onFocus(e1);
+      this.args.onFocus(e);
     }
     this.hasFocus = true;
   }
   static {
     n(this.prototype, "onThumbFocus", [action]);
   }
-  onThumbBlur(e1) {
+  onThumbBlur(e) {
     if (this.args.onBlur) {
-      this.args.onBlur(e1);
+      this.args.onBlur(e);
     }
     this.hasFocus = false;
   }
   static {
     n(this.prototype, "onThumbBlur", [action]);
   }
-  onInputFocus(e1) {
+  onInputFocus(e) {
     if (this.args.onFocus) {
-      this.args.onFocus(e1);
+      this.args.onFocus(e);
     }
     this.preventPopoverClose = true;
     this.isPopoverOpen = true;
@@ -359,7 +359,7 @@ class EuiDualRangeComponent extends Component {
   static {
     n(this.prototype, "onInputFocus", [action]);
   }
-  onInputBlur(e1) {
+  onInputBlur(e) {
     later(this, () => {
       // Safari does not recognize any focus-related eventing for input[type=range]
       // making it impossible to capture its state using active/focus/relatedTarget
@@ -370,7 +370,7 @@ class EuiDualRangeComponent extends Component {
         return;
       }
       if (this.args.onBlur) {
-        this.args.onBlur(e1);
+        this.args.onBlur(e);
       }
       this.closePopover();
     }, 200);
@@ -385,8 +385,8 @@ class EuiDualRangeComponent extends Component {
   static {
     n(this.prototype, "closePopover", [action]);
   }
-  onResize(width1) {
-    this.rangeWidth = width1;
+  onResize(width) {
+    this.rangeWidth = width;
   }
   static {
     n(this.prototype, "onResize", [action]);