@king-design/vue 2.0.0-beta.0

package/components/slider/index.spec.js

@@ -0,0 +1,737 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _asyncToGenerator from "@babel/runtime-corejs3/helpers/asyncToGenerator";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import BasicDemo from '~/components/slider/demos/basic';
+import RangeDemo from '~/components/slider/demos/range';
+import DisabledDemo from '~/components/slider/demos/disabled';
+import StepDemo from '~/components/slider/demos/step';
+import TooltipDemo from '~/components/slider/demos/tooltip';
+import { mount, unmount, dispatchEvent, wait, getElements, fakeError } from '../../test/utils';
+import { Slider } from './';
+import { Component } from 'intact-vue-next';
+import DynamicStepDemo from '~/components/slider/demos/dynamicStep';
+describe('Slider', function () {
+  afterEach(function () {
+    return unmount();
+  });
+  it('basic test', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _mount, instance, element, _element$querySelecto, slider, handle, wrapper, width, bar;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _mount = mount(BasicDemo), instance = _mount[0], element = _mount[1];
+            _element$querySelecto = element.querySelectorAll('.k-slider'), slider = _element$querySelecto[1]; // drag
+
+            handle = slider.querySelector('.k-slider-thumb');
+            dispatchEvent(handle, 'mousedown', {
+              which: 1
+            });
+            dispatchEvent(handle, 'focusin');
+            dispatchEvent(document, 'mousemove', {
+              clientX: 0
+            });
+            expect(instance.get('value2')).eql(50); // move to boundary
+
+            dispatchEvent(document, 'mousemove', {
+              clientX: -10
+            });
+            expect(instance.get('value2')).eql(50);
+            dispatchEvent(document, 'mousemove', {
+              clientX: 999999
+            });
+            expect(instance.get('value2')).eql(500);
+            dispatchEvent(document, 'mouseup'); // click
+
+            wrapper = slider.querySelector('.k-slider-track-wrapper');
+            width = wrapper.getBoundingClientRect().width;
+            dispatchEvent(wrapper, 'click', {
+              clientX: width / 2
+            });
+            expect(instance.get('value2')).eql((500 + 50) / 2); // set value
+
+            bar = slider.querySelector('.k-slider-bar');
+            instance.set('value2', 135 + 50);
+            _context.next = 20;
+            return wait();
+
+          case 20:
+            expect(bar.style.width).eql('30%');
+            instance.set('value2', -10);
+            _context.next = 24;
+            return wait();
+
+          case 24:
+            expect(bar.style.width).eql('0%');
+            instance.set('value2', 1000);
+            _context.next = 28;
+            return wait();
+
+          case 28:
+            expect(bar.style.width).eql('100%');
+
+          case 29:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+  it('range test', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _mount2, instance, element, windowWidth, _element$querySelecto2, first, second, wrapper;
+
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _mount2 = mount(RangeDemo), instance = _mount2[0], element = _mount2[1];
+            windowWidth = 800; //document.documentElement.clientWidth;
+
+            _element$querySelecto2 = element.querySelectorAll('.k-slider-thumb'), first = _element$querySelecto2[0], second = _element$querySelecto2[1]; // drag
+
+            dispatchEvent(first, 'mousedown', {
+              which: 1
+            });
+            dispatchEvent(first, 'focusin');
+            dispatchEvent(first, 'mousemove', {
+              clientX: windowWidth * 0.8
+            });
+            _context2.next = 8;
+            return wait();
+
+          case 8:
+            expect(element.innerHTML).to.matchSnapshot();
+            expect(instance.get('values')).eql([76, 80]);
+            dispatchEvent(first, 'mouseup');
+            dispatchEvent(second, 'mousedown', {
+              which: 1
+            });
+            dispatchEvent(second, 'focusin');
+            dispatchEvent(second, 'mousemove', {
+              clientX: windowWidth * 0.6
+            });
+            _context2.next = 16;
+            return wait();
+
+          case 16:
+            expect(element.innerHTML).to.matchSnapshot();
+            expect(instance.get('values')).eql([60, 76]);
+            dispatchEvent(first, 'mouseup'); // click
+
+            wrapper = element.querySelector('.k-slider-track-wrapper');
+            dispatchEvent(wrapper, 'click', {
+              clientX: windowWidth * 0.5
+            });
+            _context2.next = 23;
+            return wait();
+
+          case 23:
+            expect(element.innerHTML).to.matchSnapshot();
+            expect(instance.get('values')).eql([50, 76]);
+            dispatchEvent(wrapper, 'click', {
+              clientX: windowWidth * 0.7
+            });
+            _context2.next = 28;
+            return wait();
+
+          case 28:
+            expect(element.innerHTML).to.matchSnapshot();
+            expect(instance.get('values')).eql([50, 70]); // set invalid value
+
+            instance.set('values', 1);
+            _context2.next = 33;
+            return wait();
+
+          case 33:
+            expect(instance.get('values')).eql([1, 1]);
+
+          case 34:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  })));
+  it('keyboard operation for basic', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _mount3, instance, element, _element$querySelecto3, slider, handle;
+
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _mount3 = mount(BasicDemo), instance = _mount3[0], element = _mount3[1];
+            _element$querySelecto3 = element.querySelectorAll('.k-slider'), slider = _element$querySelecto3[1];
+            handle = slider.querySelector('.k-slider-thumb');
+            dispatchEvent(handle, 'focusin');
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 37
+            });
+            _context3.next = 7;
+            return wait();
+
+          case 7:
+            expect(slider.innerHTML).to.matchSnapshot();
+            expect(instance.get('value2')).to.eql(276);
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 39
+            });
+            _context3.next = 12;
+            return wait();
+
+          case 12:
+            expect(slider.innerHTML).to.matchSnapshot();
+            expect(instance.get('value2')).to.eql(277);
+            dispatchEvent(handle, 'focusout');
+            _context3.next = 17;
+            return wait();
+
+          case 17:
+            expect(slider.innerHTML).to.matchSnapshot();
+
+          case 18:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  })));
+  it('keyboard operation for range', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _mount4, instance, element, _element$querySelecto4, first, second;
+
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _mount4 = mount(RangeDemo), instance = _mount4[0], element = _mount4[1];
+            _element$querySelecto4 = element.querySelectorAll('.k-slider-thumb'), first = _element$querySelecto4[0], second = _element$querySelecto4[1];
+            instance.set('values', [50, 51]);
+            _context4.next = 5;
+            return wait();
+
+          case 5:
+            dispatchEvent(first, 'focusin');
+            dispatchEvent(first, 'keydown', {
+              keyCode: 39
+            });
+            _context4.next = 9;
+            return wait();
+
+          case 9:
+            expect(element.innerHTML).to.matchSnapshot();
+            expect(instance.get('values')).to.eql([51, 51]);
+            dispatchEvent(first, 'keydown', {
+              keyCode: 39
+            });
+            _context4.next = 14;
+            return wait();
+
+          case 14:
+            expect(element.innerHTML).to.matchSnapshot();
+            expect(instance.get('values')).to.eql([51, 52]);
+            dispatchEvent(second, 'keydown', {
+              keyCode: 39
+            });
+            _context4.next = 19;
+            return wait();
+
+          case 19:
+            expect(element.innerHTML).to.matchSnapshot();
+            expect(instance.get('values')).to.eql([51, 53]);
+            dispatchEvent(second, 'focusout');
+            instance.set('values', [50, 51]);
+            _context4.next = 25;
+            return wait();
+
+          case 25:
+            dispatchEvent(second, 'focusin');
+            dispatchEvent(second, 'keydown', {
+              keyCode: 37
+            });
+            _context4.next = 29;
+            return wait();
+
+          case 29:
+            expect(instance.get('values')).to.eql([50, 50]);
+            expect(element.innerHTML).to.matchSnapshot();
+            dispatchEvent(second, 'keydown', {
+              keyCode: 37
+            });
+            _context4.next = 34;
+            return wait();
+
+          case 34:
+            expect(instance.get('values')).to.eql([49, 50]);
+            expect(element.innerHTML).to.matchSnapshot();
+            dispatchEvent(first, 'keydown', {
+              keyCode: 37
+            });
+            _context4.next = 39;
+            return wait();
+
+          case 39:
+            expect(instance.get('values')).to.eql([48, 50]);
+            expect(element.innerHTML).to.matchSnapshot();
+            dispatchEvent(first, 'focusout');
+
+          case 42:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  })));
+  it('disabled', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var _mount5, instance, element, slider, sliderDom, handle, wrapper;
+
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            _mount5 = mount(DisabledDemo), instance = _mount5[0], element = _mount5[1];
+            slider = instance.refs.__test; // cannot drag
+
+            sliderDom = element.querySelector('.k-slider');
+            handle = sliderDom.querySelector('.k-slider-thumb');
+            dispatchEvent(handle, 'mousedown', {
+              which: 1
+            });
+            dispatchEvent(handle, 'focusin');
+            dispatchEvent(document, 'mousemove', {
+              clientX: 0
+            });
+            dispatchEvent(handle, 'mouseup', {
+              clientX: 0
+            });
+            _context5.next = 10;
+            return wait();
+
+          case 10:
+            expect(sliderDom.innerHTML).to.matchSnapshot();
+            expect(slider.get('value')).to.eql(50); // keyboard
+
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 37
+            });
+            dispatchEvent(handle, 'focusout');
+            _context5.next = 16;
+            return wait();
+
+          case 16:
+            expect(sliderDom.innerHTML).to.matchSnapshot();
+            expect(slider.get('value')).to.eql(50); // click
+
+            wrapper = sliderDom.querySelector('.k-slider-track-wrapper');
+            dispatchEvent(wrapper, 'click', {
+              clientX: 0
+            });
+            _context5.next = 22;
+            return wait();
+
+          case 22:
+            expect(sliderDom.innerHTML).to.matchSnapshot();
+            expect(slider.get('value')).to.eql(50);
+
+          case 24:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  })));
+  it('min/max/step is undefined', function () {
+    var Demo = /*#__PURE__*/function (_Component) {
+      _inheritsLoose(Demo, _Component);
+
+      function Demo() {
+        var _context6;
+
+        var _this;
+
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        _this = _Component.call.apply(_Component, _concatInstanceProperty(_context6 = [this]).call(_context6, args)) || this;
+        _this.Slider = Slider;
+        return _this;
+      }
+
+      return Demo;
+    }(Component);
+
+    Demo.template = "const {Slider} = this; <Slider min={undefined}\n                max={undefined}\n                step={undefined}\n                value={1}\n            />";
+
+    var _mount6 = mount(Demo),
+        instance = _mount6[0],
+        element = _mount6[1];
+
+    expect(element.innerHTML).to.matchSnapshot();
+  });
+  it('should log error when max < min', function () {
+    var Demo = /*#__PURE__*/function (_Component2) {
+      _inheritsLoose(Demo, _Component2);
+
+      function Demo() {
+        var _context7;
+
+        var _this2;
+
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+
+        _this2 = _Component2.call.apply(_Component2, _concatInstanceProperty(_context7 = [this]).call(_context7, args)) || this;
+        _this2.Slider = Slider;
+        return _this2;
+      }
+
+      return Demo;
+    }(Component);
+
+    Demo.template = "const {Slider} = this; <Slider min={20}\n                max={0}\n                step={undefined}\n                value={1}\n            />";
+    var error = fakeError();
+
+    var _mount7 = mount(Demo),
+        instance = _mount7[0],
+        element = _mount7[1];
+
+    expect(element.innerHTML).to.matchSnapshot();
+    error('[Slider] min must less than or equal to max, but got min: 20 max: 0');
+  });
+  it('should input any value even if it has step', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var _mount8, instance, element, input, slider;
+
+    return _regeneratorRuntime.wrap(function _callee6$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            _mount8 = mount(StepDemo), instance = _mount8[0], element = _mount8[1];
+            input = element.querySelector('input');
+            input.value = '1';
+            dispatchEvent(input, 'input');
+            _context8.next = 6;
+            return wait();
+
+          case 6:
+            expect(input.value).to.eql('1');
+            input.value = '11';
+            dispatchEvent(input, 'input');
+            _context8.next = 11;
+            return wait();
+
+          case 11:
+            expect(input.value).to.eql('11');
+            expect(instance.get('value1')).to.eql(10);
+            dispatchEvent(input, 'change');
+            _context8.next = 16;
+            return wait();
+
+          case 16:
+            expect(input.value).to.eql('10');
+            instance.set('value1', 13);
+            _context8.next = 20;
+            return wait();
+
+          case 20:
+            expect(instance.get('value1')).to.eql(15); // disable forceStep
+
+            slider = instance.refs.__test;
+            slider.set('forceStep', false);
+            instance.set('value1', 13);
+            _context8.next = 26;
+            return wait();
+
+          case 26:
+            expect(instance.get('value1')).to.eql(13);
+
+          case 27:
+          case "end":
+            return _context8.stop();
+        }
+      }
+    }, _callee6);
+  })));
+  it('should show tooltip', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+    var _mount9, instance, element, content;
+
+    return _regeneratorRuntime.wrap(function _callee7$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            _mount9 = mount(TooltipDemo), instance = _mount9[0], element = _mount9[1];
+            instance.set('value2', 11);
+            _context9.next = 4;
+            return wait();
+
+          case 4:
+            content = getElements('.k-tooltip-content')[0];
+            expect(content.textContent).to.eql('满2年，优惠4个月');
+            instance.set('value2', 5);
+            _context9.next = 9;
+            return wait();
+
+          case 9:
+            expect(content.textContent).to.eql('');
+
+          case 10:
+          case "end":
+            return _context9.stop();
+        }
+      }
+    }, _callee7);
+  })));
+  it('should locate at the end if start value is equal to end value', function () {
+    var Demo = /*#__PURE__*/function (_Component3) {
+      _inheritsLoose(Demo, _Component3);
+
+      function Demo() {
+        var _context10;
+
+        var _this3;
+
+        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+          args[_key3] = arguments[_key3];
+        }
+
+        _this3 = _Component3.call.apply(_Component3, _concatInstanceProperty(_context10 = [this]).call(_context10, args)) || this;
+        _this3.Slider = Slider;
+        return _this3;
+      }
+
+      return Demo;
+    }(Component);
+
+    Demo.template = "const {Slider} = this; <div>\n                <Slider min={1} max={1} value={1} />\n                <Slider min={1} max={1} range />\n            </div>";
+
+    var _mount10 = mount(Demo),
+        instance = _mount10[0],
+        element = _mount10[1];
+
+    expect(element.innerHTML).to.matchSnapshot();
+  });
+  it('should trigger change event correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var spy, Demo, _mount11, instance, element, handle, bar, width, start, input, btn;
+
+    return _regeneratorRuntime.wrap(function _callee8$(_context12) {
+      while (1) {
+        switch (_context12.prev = _context12.next) {
+          case 0:
+            spy = sinon.spy();
+
+            Demo = /*#__PURE__*/function (_Component4) {
+              _inheritsLoose(Demo, _Component4);
+
+              function Demo() {
+                var _context11;
+
+                var _this4;
+
+                for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+                  args[_key4] = arguments[_key4];
+                }
+
+                _this4 = _Component4.call.apply(_Component4, _concatInstanceProperty(_context11 = [this]).call(_context11, args)) || this;
+                _this4.Slider = Slider;
+                return _this4;
+              }
+
+              Demo.defaults = function defaults() {
+                return {
+                  value: 0
+                };
+              };
+
+              var _proto = Demo.prototype;
+
+              _proto._onChange = function _onChange(v) {
+                console.log('change', v);
+                spy(v);
+              };
+
+              return Demo;
+            }(Component);
+
+            Demo.template = "const Slider = this.Slider; <Slider ev-change={this._onChange} v-model=\"value\" />";
+            _mount11 = mount(Demo), instance = _mount11[0], element = _mount11[1];
+            handle = element.querySelector('.k-slider-thumb');
+            bar = element.querySelector('.k-slider-track-wrapper'); // keyboard
+
+            dispatchEvent(handle, 'focusin');
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 39
+            });
+            expect(spy.callCount).to.eql(0);
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 39
+            });
+            expect(spy.callCount).to.eql(0);
+            dispatchEvent(handle, 'keyup', {
+              keyCode: 13
+            });
+            expect(spy.callCount).to.eql(0);
+            dispatchEvent(handle, 'keyup', {
+              keyCode: 39
+            });
+            expect(spy.callCount).to.eql(1);
+            expect(spy.calledWith(2)).to.be.true;
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 39
+            });
+            expect(spy.callCount).to.eql(1);
+            dispatchEvent(handle, 'keyup', {
+              keyCode: 39
+            });
+            expect(spy.callCount).to.eql(2);
+            expect(spy.calledWith(3)).to.be.true; // drag
+
+            width = bar.getBoundingClientRect().width;
+            dispatchEvent(handle, 'mousedown', {
+              which: 1
+            });
+            dispatchEvent(document, 'mousemove', {
+              clientX: 0.1 * width
+            });
+            expect(spy.callCount).to.eql(2);
+            dispatchEvent(document, 'mouseup', {
+              clientX: 0.1 * width
+            });
+            expect(spy.callCount).to.eql(3);
+            expect(spy.calledWith(10)).to.be.true; // click
+
+            dispatchEvent(bar, 'click', {
+              clientX: 0.2 * width
+            });
+            expect(spy.callCount).to.eql(4);
+            expect(spy.calledWith(20)).to.be.true; // click end
+
+            start = element.querySelector('.k-slider-ends span');
+            start.click();
+            expect(spy.callCount).to.eql(5);
+            expect(spy.calledWith(0)).to.be.true; // spinner
+
+            input = element.querySelector('input');
+            input.value = '1';
+            dispatchEvent(input, 'input');
+            _context12.next = 40;
+            return wait();
+
+          case 40:
+            expect(spy.callCount).to.eql(6);
+            expect(spy.calledWith(1)).to.be.true;
+            btn = element.querySelector('.k-btn');
+            btn.click();
+            _context12.next = 46;
+            return wait();
+
+          case 46:
+            expect(spy.callCount).to.eql(7);
+            expect(spy.calledWith(0)).to.be.true;
+
+          case 48:
+          case "end":
+            return _context12.stop();
+        }
+      }
+    }, _callee8);
+  }))); // it('should set init value to min value', async () => {
+  // class Demo extends Component<{a: number, b: number}> {
+  // static template = `const {Slider} = this; <div>
+  // <Slider min={-1} max={1} v-model="a"/>
+  // <Slider min={-1} max={1} isRange v-model="b" />
+  // </div>`;
+  // private Slider = Slider;
+  // }
+  // const [instance, element] = mount(Demo);
+  // expect(instance.get('a')).to.eql(-1);
+  // expect(instance.get('b')).to.eql([-1, -1]);
+  // });
+
+  it('should set value by `min + step * n`', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+    var Demo, _mount12, instance, element;
+
+    return _regeneratorRuntime.wrap(function _callee9$(_context14) {
+      while (1) {
+        switch (_context14.prev = _context14.next) {
+          case 0:
+            Demo = /*#__PURE__*/function (_Component5) {
+              _inheritsLoose(Demo, _Component5);
+
+              function Demo() {
+                var _context13;
+
+                var _this5;
+
+                for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+                  args[_key5] = arguments[_key5];
+                }
+
+                _this5 = _Component5.call.apply(_Component5, _concatInstanceProperty(_context13 = [this]).call(_context13, args)) || this;
+                _this5.Slider = Slider;
+                return _this5;
+              }
+
+              return Demo;
+            }(Component);
+
+            Demo.template = "const {Slider} = this; <div>\n                <Slider min={-6} max={20} v-model=\"value\" step={5} points />\n            </div>";
+            _mount12 = mount(Demo), instance = _mount12[0], element = _mount12[1];
+            instance.set('value', 0);
+            _context14.next = 6;
+            return wait();
+
+          case 6:
+            expect(instance.get('value')).to.eql(-1);
+
+          case 7:
+          case "end":
+            return _context14.stop();
+        }
+      }
+    }, _callee9);
+  })));
+  it('dynamic step', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+    var _mount13, instance, element, handle, model;
+
+    return _regeneratorRuntime.wrap(function _callee10$(_context15) {
+      while (1) {
+        switch (_context15.prev = _context15.next) {
+          case 0:
+            _mount13 = mount(DynamicStepDemo), instance = _mount13[0], element = _mount13[1];
+            handle = element.querySelector('.k-slider-thumb');
+            model = "value1";
+            instance.set(model, 100);
+            _context15.next = 6;
+            return wait();
+
+          case 6:
+            dispatchEvent(handle, 'focusin');
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 37
+            });
+            expect(instance.get(model)).to.eql(90);
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 39
+            });
+            expect(instance.get(model)).to.eql(100);
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 39
+            });
+            expect(instance.get(model)).to.eql(150);
+            dispatchEvent(handle, 'keydown', {
+              keyCode: 37
+            });
+            expect(instance.get(model)).to.eql(100);
+            dispatchEvent(handle, 'focusout');
+
+          case 16:
+          case "end":
+            return _context15.stop();
+        }
+      }
+    }, _callee10);
+  })));
+});
+
+export {normalize} from 'intact-vue-next';