@enact/limestone 1.3.0

package/Slider/tests/Slider-specs.js

@@ -0,0 +1,573 @@
+"use strict";
+
+require("@testing-library/jest-dom");
+var _react = require("@testing-library/react");
+var _Slider = _interopRequireDefault(require("../Slider"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+var focus = function focus(slider) {
+  return _react.fireEvent.focus(slider);
+};
+var blur = function blur(slider) {
+  return _react.fireEvent.blur(slider);
+};
+var activate = function activate(slider) {
+  return _react.fireEvent.keyUp(slider, {
+    keyCode: 13
+  });
+};
+var keyDown = function keyDown(keyCode) {
+  return function (slider) {
+    return _react.fireEvent.keyDown(slider, {
+      keyCode: keyCode
+    });
+  };
+};
+var leftKeyDown = keyDown(37);
+var rightKeyDown = keyDown(39);
+var upKeyDown = keyDown(38);
+var downKeyDown = keyDown(40);
+var getElementClientCenter = function getElementClientCenter(element) {
+  var _element$getBoundingC = element.getBoundingClientRect(),
+    left = _element$getBoundingC.left,
+    top = _element$getBoundingC.top,
+    width = _element$getBoundingC.width,
+    height = _element$getBoundingC.height;
+  return {
+    x: left + width / 2,
+    y: top + height / 2
+  };
+};
+var drag = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(function* (element, _ref) {
+    var delta = _ref.delta,
+      _ref$steps = _ref.steps,
+      steps = _ref$steps === void 0 ? 1 : _ref$steps;
+    var from = getElementClientCenter(element);
+    var to = {
+      x: from.x + delta.x,
+      y: from.y + delta.y
+    };
+    var step = {
+      x: (to.x - from.x) / steps,
+      y: (to.y - from.y) / steps
+    };
+    var current = {
+      clientX: from.x,
+      clientY: from.y
+    };
+    _react.fireEvent.mouseEnter(element, current);
+    _react.fireEvent.mouseOver(element, current);
+    _react.fireEvent.mouseMove(element, current);
+    _react.fireEvent.mouseDown(element, current);
+    for (var i = 0; i < steps; i++) {
+      current.clientX += step.x;
+      current.clientY += step.y;
+      (0, _react.act)(function () {
+        return jest.advanceTimersByTime(1000 / steps);
+      });
+      _react.fireEvent.mouseMove(element, current);
+    }
+    _react.fireEvent.mouseUp(element, current);
+  });
+  return function drag(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+describe('Slider', function () {
+  beforeEach(function () {
+    jest.useFakeTimers();
+  });
+  afterEach(function () {
+    jest.useRealTimers();
+  });
+  test('should set "aria-valuetext" to hint string for the first render when vertical is false', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {}));
+    var slider = _react.screen.getByRole('slider');
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = 'From 0 to 100 0 change a value with left right button';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should set "aria-valuetext" to hint string for the first render when vertical is true', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      orientation: "vertical"
+    }));
+    var slider = _react.screen.getByRole('slider');
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = 'From 0 to 100 0 change a value with up down button';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should set "aria-valuetext" to value when value is changed', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 10
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    rightKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '11';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should activate the slider on enter keyup', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    var expected = 'active';
+    expect(slider).toHaveClass(expected);
+  });
+  test('should change value of slider on drag', /*#__PURE__*/_asyncToGenerator(function* () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    yield drag(slider, {
+      delta: {
+        x: 50,
+        y: 0
+      }
+    });
+    var expectedAttribute = 'aria-valuetext';
+    var unexpectedValue = '50 change a value with left right button';
+    expect(slider).not.toHaveAttribute(expectedAttribute, unexpectedValue);
+  }));
+  test('should deactivate the slider on blur', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true
+    }));
+    var slider = _react.screen.getByRole('slider');
+    var notExpected = 'active';
+    activate(slider);
+    expect(slider).toHaveClass(notExpected);
+    blur(slider);
+    expect(slider).not.toHaveClass(notExpected);
+  });
+  test('should not activate the slider on enter', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {}));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    var notExpected = 'active';
+    expect(slider).not.toHaveClass(notExpected);
+  });
+  test('should fire `onChange` with `onChange` type when value changed', function () {
+    var handleChange = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      onChange: handleChange
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    leftKeyDown(slider);
+    var expected = {
+      type: 'onChange'
+    };
+    var actual = handleChange.mock.calls.length && handleChange.mock.calls[0][0];
+    expect(actual).toMatchObject(expected);
+  });
+  test('should decrement the value of horizontal slider on key left when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    leftKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '49';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should decrement the value of horizontal slider on key left', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    leftKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '49';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should decrement the value of horizontal slider on wheel down when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    _react.fireEvent.wheel(slider, {
+      deltaY: 10
+    });
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '49';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should decrement the value of vertical slider on key down when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      orientation: "vertical"
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    downKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '49';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should decrement the value of vertical slider on key down', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50,
+      orientation: "vertical"
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    downKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '49';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should decrement the value of vertical slider on wheel down when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      orientation: "vertical"
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    _react.fireEvent.wheel(slider, {
+      deltaY: 10
+    });
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '49';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value of horizontal slider on key right when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    rightKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '51';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value of horizontal slider on key right', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    rightKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '51';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value of vertical slider on key up when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      orientation: "vertical"
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    upKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '51';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value of horizontal slider on wheel up when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    _react.fireEvent.wheel(slider, {
+      deltaY: -10
+    });
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '51';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value of vertical slider on key up', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50,
+      orientation: "vertical"
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    upKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '51';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value of vertical slider on wheel up when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      orientation: "vertical"
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    _react.fireEvent.wheel(slider, {
+      deltaY: -10
+    });
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '51';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should decrement the value by \'knobStep\' on key left when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      knobStep: 5
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    leftKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '45';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value by \'knobStep\' on key right when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      knobStep: 5
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    rightKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '55';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should decrement the value by \'step\' on key left when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      step: 5
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    leftKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '45';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should increment the value by \'step\' on key right when active', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      defaultValue: 50,
+      step: 5
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    rightKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '55';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+
+  // these tests validate behavior relating to `value` defaulting to `min`
+  test('should not emit onChange when decrementing at the lower bound when value is unset', function () {
+    var handleChange = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      min: 0,
+      max: 10,
+      onChange: handleChange
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    leftKeyDown(slider);
+    expect(handleChange).not.toHaveBeenCalled();
+  });
+  test('should increment from the lower bound when value is unset', function () {
+    var handleChange = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      activateOnSelect: true,
+      min: 0,
+      max: 10,
+      onChange: handleChange
+    }));
+    var slider = _react.screen.getByRole('slider');
+    activate(slider);
+    rightKeyDown(slider);
+    var expectedAttribute = 'aria-valuetext';
+    var expectedValue = '1';
+    expect(slider).toHaveAttribute(expectedAttribute, expectedValue);
+  });
+  test('should call onSpotlightLeft on horizontal slider at min value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 0,
+      onSpotlightLeft: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    leftKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should call onSpotlightLeft on vertical slider at any value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50,
+      orientation: "vertical",
+      onSpotlightLeft: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    leftKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should not call onSpotlightLeft on horizontal slider at greater than min value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 1,
+      onSpotlightLeft: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    leftKeyDown(slider);
+    expect(handleSpotlight).not.toHaveBeenCalled();
+  });
+  test('should call onSpotlightDown on vertical slider at min value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 0,
+      orientation: "vertical",
+      onSpotlightDown: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    downKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should call onSpotlightDown on horizontal slider at any value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50,
+      onSpotlightDown: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    downKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should not call onSpotlightDown on vertical slider at greater than min value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 1,
+      orientation: "vertical",
+      onSpotlightDown: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    downKeyDown(slider);
+    expect(handleSpotlight).not.toHaveBeenCalled();
+  });
+  test('should call onSpotlightRight on horizontal slider at max value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 100,
+      onSpotlightRight: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    rightKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should call onSpotlightRight on vertical slider at any value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50,
+      orientation: "vertical",
+      onSpotlightRight: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    rightKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should not call onSpotlightRight on horizontal slider at less than max value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 99,
+      onSpotlightRight: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    rightKeyDown(slider);
+    expect(handleSpotlight).not.toHaveBeenCalled();
+  });
+  test('should call onSpotlightUp on vertical slider at max value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 100,
+      max: 100,
+      orientation: "vertical",
+      onSpotlightUp: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    upKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should call onSpotlightUp on horizontal slider at any value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 50,
+      onSpotlightUp: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    upKeyDown(slider);
+    var expected = 1;
+    expect(handleSpotlight).toHaveBeenCalledTimes(expected);
+  });
+  test('should not call onSpotlightUp on vertical slider at less than max value', function () {
+    var handleSpotlight = jest.fn();
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      defaultValue: 99,
+      orientation: "vertical",
+      onSpotlightUp: handleSpotlight
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    upKeyDown(slider);
+    expect(handleSpotlight).not.toHaveBeenCalled();
+  });
+  test('should set the tooltip to visible when focused', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      tooltip: true
+    }));
+    var slider = _react.screen.getByRole('slider');
+    focus(slider);
+    var actual = _react.screen.getByText('0');
+    var expected = 'tooltipLabel';
+    expect(actual).toHaveClass(expected);
+  });
+  test('should set the tooltip to not visible when unfocused', function () {
+    (0, _react.render)(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Slider["default"], {
+      tooltip: true
+    }));
+    var tooltip = _react.screen.queryByText('0');
+    expect(tooltip).toBeNull();
+  });
+});

package/Slider/utils.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleIncrementByWheel = exports.handleIncrement = exports.handleDecrementByWheel = exports.handleDecrement = exports.forwardSpotlightEvents = exports.emitChange = void 0;
+var _handle = require("@enact/core/handle");
+var _keymap = require("@enact/core/keymap");
+var _util = require("@enact/core/util");
+var _utils = require("@enact/ui/Slider/utils");
+var nop = function nop() {};
+var handleAcceleratedKeyDown = function handleAcceleratedKeyDown(ev, prop, _ref) {
+  var spotlightAccelerator = _ref.current;
+  if (!spotlightAccelerator) {
+    return true;
+  }
+  if (!ev.repeat) {
+    spotlightAccelerator.reset();
+  }
+  if (spotlightAccelerator.processKey(ev, nop)) {
+    return false;
+  }
+  return true;
+};
+var calcStep = function calcStep(knobStep, step) {
+  var s;
+  if (knobStep != null) {
+    s = knobStep;
+  } else if (step != null) {
+    s = step;
+  }
+
+  // default to a step of 1 if neither are set or are set to 0
+  // otherwise, increment/decrement would be no-ops
+  return s || 1;
+};
+var isIncrementByWheel = function isIncrementByWheel(_ref2) {
+  var deltaY = _ref2.deltaY;
+  return deltaY < 0;
+};
+var isDecrementByWheel = function isDecrementByWheel(_ref3) {
+  var deltaY = _ref3.deltaY;
+  return deltaY > 0;
+};
+var isIncrement = function isIncrement(_ref4, _ref5) {
+  var keyCode = _ref4.keyCode;
+  var orientation = _ref5.orientation;
+  return orientation === 'vertical' ? (0, _keymap.is)('up', keyCode) : (0, _keymap.is)('right', keyCode);
+};
+var isDecrement = function isDecrement(_ref6, _ref7) {
+  var keyCode = _ref6.keyCode;
+  var orientation = _ref7.orientation;
+  return orientation === 'vertical' ? (0, _keymap.is)('down', keyCode) : (0, _keymap.is)('left', keyCode);
+};
+var isNotMax = function isNotMax(ev, _ref8) {
+  var value = _ref8.value,
+    max = _ref8.max;
+  return value !== max;
+};
+var isNotMin = function isNotMin(ev, _ref9) {
+  var min = _ref9.min,
+    _ref9$value = _ref9.value,
+    value = _ref9$value === void 0 ? min : _ref9$value;
+  return value !== min;
+};
+var checkInterval = function checkInterval(ev, _ref0, context) {
+  var wheelInterval = _ref0.wheelInterval;
+  if (ev.timeStamp - context.lastWheelTimeStamp < wheelInterval) {
+    return false;
+  }
+  context.lastWheelTimeStamp = ev.timeStamp;
+  return true;
+};
+var emitChange = exports.emitChange = function emitChange(direction) {
+  return (0, _handle.forwardCustom)('onChange', function (ev, _ref1) {
+    var knobStep = _ref1.knobStep,
+      max = _ref1.max,
+      min = _ref1.min,
+      step = _ref1.step,
+      _ref1$value = _ref1.value,
+      value = _ref1$value === void 0 ? min : _ref1$value;
+    var newValue = (0, _util.clamp)(min, max, value + calcStep(knobStep, step) * direction);
+    return {
+      value: newValue,
+      proportion: (0, _utils.calcProportion)(min, max, newValue)
+    };
+  });
+};
+var isActive = function isActive(ev, props) {
+  return props.active || !props.activateOnSelect;
+};
+var handleIncrement = exports.handleIncrement = (0, _handle.handle)(isActive, isIncrement, _handle.preventDefault, _handle.stop, handleAcceleratedKeyDown, isNotMax, emitChange(1));
+var handleDecrement = exports.handleDecrement = (0, _handle.handle)(isActive, isDecrement, _handle.preventDefault, _handle.stop, handleAcceleratedKeyDown, isNotMin, emitChange(-1));
+var handleIncrementByWheel = exports.handleIncrementByWheel = (0, _handle.handle)(isActive, isIncrementByWheel, _handle.preventDefault, _handle.stop, isNotMax, checkInterval, emitChange(1));
+var handleDecrementByWheel = exports.handleDecrementByWheel = (0, _handle.handle)(isActive, isDecrementByWheel, _handle.preventDefault, _handle.stop, isNotMin, checkInterval, emitChange(-1));
+var either = function either(a, b) {
+  return function () {
+    return a.apply(void 0, arguments) || b.apply(void 0, arguments);
+  };
+};
+var atMinimum = function atMinimum(ev, _ref10) {
+  var min = _ref10.min,
+    _ref10$value = _ref10.value,
+    value = _ref10$value === void 0 ? min : _ref10$value;
+  return value <= min;
+};
+var atMaximum = function atMaximum(ev, _ref11) {
+  var max = _ref11.max,
+    min = _ref11.min,
+    _ref11$value = _ref11.value,
+    value = _ref11$value === void 0 ? min : _ref11$value;
+  return value >= max;
+};
+var forwardSpotlightEvents = exports.forwardSpotlightEvents = (0, _handle.oneOf)([(0, _handle.forKey)('left'), (0, _handle.handle)(either((0, _handle.forProp)('orientation', 'vertical'), atMinimum), (0, _handle.forwardCustom)('onSpotlightLeft'))], [(0, _handle.forKey)('right'), (0, _handle.handle)(either((0, _handle.forProp)('orientation', 'vertical'), atMaximum), (0, _handle.forwardCustom)('onSpotlightRight'))], [(0, _handle.forKey)('down'), (0, _handle.handle)(either((0, _handle.forProp)('orientation', 'horizontal'), atMinimum), (0, _handle.forwardCustom)('onSpotlightDown'))], [(0, _handle.forKey)('up'), (0, _handle.handle)(either((0, _handle.forProp)('orientation', 'horizontal'), atMaximum), (0, _handle.forwardCustom)('onSpotlightUp'))]);