@jetbrains/ring-ui 4.1.3 → 5.0.0-beta.0

package/components/select/select__popup.test.js

@@ -1,156 +0,0 @@
-import React from 'react';
-import {Simulate} from 'react-dom/test-utils';
-import {shallow, mount} from 'enzyme';
-
-import getUID from '../global/get-uid';
-
-import List from '../list/list';
-import simulateCombo from '../../test-helpers/simulate-combo';
-
-import SelectPopup from './select__popup';
-
-describe('SelectPopup', () => {
-  const factory = props => (
-    <SelectPopup
-      filter
-      onSelect={sandbox.spy()}
-      onFilter={sandbox.spy()}
-      onCloseAttempt={sandbox.spy()}
-      data={[]}
-      {...props}
-    />
-  );
-  const shallowSelectPopup = props => shallow(factory(props));
-  const mountSelectPopup = props => mount(factory(props));
-
-  describe('hidden', () => {
-    describe('filter', () => {
-      it('should disable shortcuts', () => {
-        const wrapper = shallowSelectPopup();
-        const instance = wrapper.instance();
-        sandbox.spy(instance, 'tabPress');
-
-        simulateCombo('tab');
-
-        instance.tabPress.should.not.be.called;
-      });
-    });
-  });
-
-
-  describe('visible', () => {
-    function createListItemMock(itemLabel, id) {
-      const key = id || getUID('popup-test-');
-      const label = itemLabel || getUID('popup-label-');
-
-      return {
-        key,
-        label,
-        type: List.ListProps.Type.ITEM
-      };
-    }
-
-
-    let testData;
-    beforeEach(() => {
-      testData = [
-        createListItemMock(),
-        createListItemMock()
-      ];
-    });
-
-
-    it('should initialize', () => {
-      shallowSelectPopup().should.exist;
-    });
-
-
-    it('should call close handler when user press tab', () => {
-      const wrapper = mountSelectPopup({data: testData});
-      wrapper.setProps({hidden: false});
-      wrapper.instance().list.state.activeItem = {};
-
-      simulateCombo('tab');
-
-      wrapper.prop('onCloseAttempt').should.be.called;
-    });
-
-
-    describe('popup without data', () => {
-      it('should not throw error when user press tab but we do not have the list', () => {
-        const wrapper = mountSelectPopup();
-        wrapper.setProps({hidden: false});
-        (() => {
-          simulateCombo('tab');
-        }).should.not.throw();
-      });
-    });
-
-
-    describe('navigation', () => {
-      it('should highlight first item', () => {
-        const wrapper = mountSelectPopup({data: testData});
-        wrapper.setProps({hidden: false});
-        const firstItem = testData[0];
-
-        wrapper.instance().list.getSelected().should.be.equal(firstItem);
-      });
-
-
-      it('should highlight last item', () => {
-        const wrapper = mountSelectPopup({data: testData});
-        wrapper.setProps({hidden: false});
-        const lastItem = testData[testData.length - 1];
-
-        simulateCombo('up');
-
-        wrapper.instance().list.getSelected().should.be.equal(lastItem);
-      });
-
-
-      it('should select item', () => {
-        const wrapper = mountSelectPopup({data: testData});
-        wrapper.setProps({hidden: false});
-        const firstItem = testData[0];
-
-        simulateCombo('enter');
-
-        wrapper.prop('onSelect').should.be.calledWith(firstItem);
-      });
-    });
-
-    describe('filter', () => {
-      function expectPopupFilterShortcutsDisabled(fn, value) {
-        fn.should.be.calledWith({
-          popupFilterShortcutsOptions: {
-            modal: true,
-            disabled: value
-          }
-        });
-      }
-
-      it('should enable shortcuts on focus', () => {
-        const wrapper = mountSelectPopup({data: testData});
-        wrapper.setProps({hidden: false});
-        const instance = wrapper.instance();
-        sandbox.spy(instance, 'setState');
-
-        Simulate.focus(instance.filter);
-
-        expectPopupFilterShortcutsDisabled(instance.setState, false);
-      });
-
-
-      it('should disable shortcuts on blur', () => {
-        const wrapper = mountSelectPopup({data: testData});
-        wrapper.setProps({hidden: false});
-        const instance = wrapper.instance();
-        sandbox.spy(instance, 'setState');
-
-        Simulate.blur(instance.filter);
-
-        expectPopupFilterShortcutsDisabled(instance.setState, true);
-      });
-    });
-  });
-});

package/components/shortcuts/core.js

@@ -1,232 +0,0 @@
-import Combokeys from 'combokeys';
-
-import sniffr from '../global/sniffer';
-
-class Shortcuts {
-  ALLOW_SHORTCUTS_SELECTOR = '.ring-js-shortcuts';
-  ROOT_SCOPE = {
-    scopeId: 'ROOT',
-    options: {}
-  };
-
-  _scopes = {};
-
-  combokeys = new Combokeys(document.documentElement);
-  trigger = combo => this.combokeys.trigger(combo);
-
-  constructor() {
-    this.setFilter();
-    this.setScope();
-  }
-
-  _dispatcher = (e, key) => {
-    let currentScope;
-
-    for (let i = this._scopeChain.length - 1; i >= 0; i--) {
-      const scopeInChain = this._scopeChain[i];
-      currentScope = this._scopes[scopeInChain.scopeId];
-
-      if (currentScope && currentScope[key]) {
-        const ret = currentScope[key](e, key, scopeInChain.scopeId);
-
-        // Fall down in chain when returning true
-        if (ret !== true) {
-          return ret;
-        }
-      }
-
-      if (scopeInChain.options.modal) {
-        return true;
-      }
-    }
-
-    return undefined;
-  };
-
-  /**
-   * Binds a handler to a shortcut
-   *
-   * @param params.key {string | Array.<string>) Keys to bind
-   * @param params.handler {Function} Events handle
-   * @param params.scope {string} Scope (optional)
-   * @param params.type {string} Event type, will be passed to Combokeys (optional)
-   */
-  bind(params) {
-    if (!(params instanceof Object) || typeof params.handler !== 'function') {
-      throw new Error('Shortcut handler should exist');
-    }
-
-    if (!params.scope) {
-      params.scope = this.ROOT_SCOPE.scopeId;
-    }
-
-    if (Array.isArray(params.key)) {
-      for (let i = 0; i < params.key.length; i++) {
-        this.bind(Object.assign({}, params, {key: params.key[i]}));
-      }
-
-      return;
-    }
-
-    if (typeof params.key !== 'string') {
-      throw new Error('Shortcut key should exist');
-    }
-
-    if (!this._scopes[params.scope]) {
-      this._scopes[params.scope] = {};
-    }
-    this._scopes[params.scope][params.key] = params.handler;
-
-    this.combokeys.bind(params.key, this._dispatcher, this._getKeyboardEventType(params));
-  }
-
-  /**
-   * Binds a map of shortcuts to handlers with common options
-   *
-   * @map {Object) Keys to handlers map
-   * @options.scope {string} Scope (optional)
-   * @options.type {string} Event type, will be passed to Combokeys (optional)
-   */
-  bindMap(map, options) {
-    if (!(map instanceof Object)) {
-      throw new Error('Shortcuts map shouldn\'t be empty');
-    }
-
-    for (const key in map) {
-      if (map.hasOwnProperty(key)) {
-        this.bind(Object.assign({}, options || {}, {key, handler: map[key]}));
-      }
-    }
-  }
-
-  unbindScope(scope) {
-    this._scopes[scope] = null;
-  }
-
-  getScope() {
-    return this._scopeChain.slice(1);
-  }
-
-  hasScope(scopeId) {
-    return this.indexOfScope(scopeId) !== -1;
-  }
-
-  /**
-   * Adds a scope to the chain
-   * @param scopeId id of scope to add
-   * @param options options for pushing scope
-   * @param options.modal whether keys should fall through this scope or not.
-   * Useful for modals or overlays
-   */
-  pushScope(scopeId, options = {}) {
-    if (scopeId) {
-      const position = this.indexOfScope(scopeId);
-
-      if (position !== -1) {
-        this._scopeChain.splice(position, 1);
-      }
-
-      this._scopeChain.push(this.wrapScope(scopeId, options));
-    }
-  }
-
-  popScope(scopeId) {
-    if (scopeId) {
-      const position = this.indexOfScope(scopeId);
-
-      if (position !== -1) {
-        return this._scopeChain.splice(position, this._scopeChain.length - 1);
-      }
-    }
-
-    return undefined;
-  }
-
-  spliceScope(scopeId) {
-    if (scopeId) {
-      const position = this.indexOfScope(scopeId);
-
-      if (position !== -1) {
-        this._scopeChain.splice(position, 1);
-      }
-    }
-  }
-
-  setScope(scope) {
-    if (scope) {
-      let scopeChain;
-
-      if (typeof scope === 'string' || (!Array.isArray(scope) && typeof scope === 'object' && scope !== null)) {
-        scopeChain = [scope];
-      } else {
-        scopeChain = scope;
-      }
-
-      if (!Array.isArray(scopeChain)) {
-        return;
-      }
-
-      scopeChain = scopeChain.map(scopeItem => {
-        const isScopeId = typeof scopeItem === 'string';
-        return isScopeId ? this.wrapScope(scopeItem) : scopeItem;
-      });
-
-      this._scopeChain = [this.ROOT_SCOPE].concat(scopeChain);
-    } else {
-      this._scopeChain = [this.ROOT_SCOPE];
-    }
-  }
-
-  wrapScope(scopeId, options = {}) {
-    return {scopeId, options};
-  }
-
-  hasKey(key, scope) {
-    return !!(this._scopes[scope] && this._scopes[scope][key]);
-  }
-
-  _defaultFilter = (e, element, key) => {
-    // if the element or its parents have the class "ring-js-shortcuts" then no need to stop
-    if (
-      element === document ||
-      element.matches(this.ALLOW_SHORTCUTS_SELECTOR) ||
-      (element.dataset.enabledShortcuts != null
-        ? element.dataset.enabledShortcuts.split(',').includes(key)
-        : element.closest(this.ALLOW_SHORTCUTS_SELECTOR) != null)
-    ) {
-      return false;
-    }
-
-    // stop for input, select, and textarea
-    return element.matches('input,select,textarea') || (element.contentEditable && element.contentEditable === 'true');
-  };
-
-  _getKeyboardEventType(params) {
-    if (!params.type && sniffr.os.name === 'windows') {
-      const isSystemShortcut = params.key.match(/ctrl/i) && params.key.match(/shift/i) && params.key.match(/[0-9]/);
-      /**
-       * Windows system shortcuts (ctrl+shift+[0-9] are caught by the OS on 'keydown', so let's use 'keyup'
-       */
-      if (isSystemShortcut) {
-        return 'keyup';
-      }
-    }
-    return params.type;
-  }
-
-  setFilter(fn) {
-    this.combokeys.stopCallback = typeof fn === 'function' ? fn : this._defaultFilter;
-  }
-
-  indexOfScope(scopeId) {
-    return this._scopeChain.findIndex(scope => scope.scopeId === scopeId);
-  }
-
-  reset() {
-    this._scopes = {};
-    this.setScope();
-    this.combokeys.reset();
-  }
-}
-
-export default new Shortcuts();

package/components/shortcuts/core.test.js

@@ -1,282 +0,0 @@
-import {simulate} from 'combokeys/test/lib/key-event';
-
-import sniffr from '../global/sniffer';
-
-import shortcuts from './core';
-
-describe('Shortcuts', () => {
-  const key = 'a';
-  const keyCode = '65';
-  const key2 = 'b';
-  const scope = 'scope scope scope';
-  let noop;
-  let noop2;
-
-  function trigger() {
-    simulate(key.charCodeAt(0), keyCode);
-  }
-
-  const wrapScope = shortcuts.wrapScope.bind(shortcuts);
-
-  beforeEach(() => {
-    shortcuts.reset();
-    shortcuts.setScope();
-    shortcuts.setFilter();
-
-    noop = sandbox.stub();
-    noop2 = sandbox.stub();
-  });
-
-  describe('bind', () => {
-    it('should throw without a handler', () => {
-      (() => {
-        shortcuts.bind();
-      }).should.throw(Error, 'Shortcut handler should exist');
-    });
-
-    it('should throw without a key', () => {
-      (() => {
-        shortcuts.bind({handler: sandbox.stub()});
-      }).should.throw(Error, 'Shortcut key should exist');
-    });
-
-    it('should bind to root scope', () => {
-      shortcuts.bind({key, handler: noop});
-
-      shortcuts._scopes[shortcuts.ROOT_SCOPE.scopeId][key].should.equal(noop);
-    });
-
-    it('should bind to custom scope', () => {
-      shortcuts.bind({key, scope, handler: noop});
-
-      shortcuts._scopes[scope][key].should.equal(noop);
-    });
-
-    it('should bind array of keys', () => {
-      const keys = [key, key2];
-      shortcuts.bind({key: keys, handler: noop});
-
-      shortcuts._scopes[shortcuts.ROOT_SCOPE.scopeId][key].should.equal(noop);
-      shortcuts._scopes[shortcuts.ROOT_SCOPE.scopeId][key2].should.equal(noop);
-    });
-  });
-
-  describe('bindMap', () => {
-    it('should throw without a map', () => {
-      (() => {
-        shortcuts.bindMap();
-      }).should.throw(Error, 'Shortcuts map shouldn\'t be empty');
-    });
-
-    it('should throw with wrong handler', () => {
-      (() => {
-        shortcuts.bindMap({a: {}});
-      }).should.throw(Error, 'Shortcut handler should exist');
-    });
-
-    it('should bind map of keys to root scope', () => {
-      const keys = {};
-      keys[key] = noop;
-      keys[key2] = noop2;
-      shortcuts.bindMap(keys);
-
-      shortcuts._scopes[shortcuts.ROOT_SCOPE.scopeId][key].should.equal(noop);
-      shortcuts._scopes[shortcuts.ROOT_SCOPE.scopeId][key2].should.equal(noop2);
-    });
-
-    it('should bind map of keys to custom scope', () => {
-      const keys = {};
-      keys[key] = noop;
-      keys[key2] = noop2;
-      shortcuts.bindMap(keys, {scope});
-
-      shortcuts._scopes[scope][key].should.equal(noop);
-      shortcuts._scopes[scope][key2].should.equal(noop2);
-    });
-  });
-
-  describe('unbindScope', () => {
-    it('should clear scope', () => {
-      shortcuts.bind({key, scope, handler: noop});
-      shortcuts.unbindScope(scope);
-
-      should.not.exist(shortcuts._scopes[scope]);
-    });
-  });
-
-  describe('hasKey', () => {
-    it('should clear scope', () => {
-      shortcuts.bind({key, scope, handler: noop});
-
-      shortcuts.hasKey(key, scope).should.be.true;
-      shortcuts.hasKey(key, shortcuts.ROOT_SCOPE.scopeId).should.be.false;
-    });
-  });
-
-  describe('filter', () => {
-    it('should setFilter', () => {
-      shortcuts.setFilter(noop2);
-      shortcuts.bind({key, handler: noop});
-
-      trigger();
-
-      noop.should.have.been.called;
-      noop2.should.have.been.called;
-    });
-
-    it('should prevent handler run', () => {
-      const stop = sandbox.stub().returns(true);
-
-      shortcuts.setFilter(stop);
-      shortcuts.bind({key, handler: noop});
-
-      trigger();
-
-      stop.should.have.been.called;
-      noop.should.not.have.been.called;
-    });
-  });
-
-  describe('key press', () => {
-    it('should handle keys in root scope', () => {
-      shortcuts.bind({key, handler: noop});
-
-      trigger();
-
-      noop.should.have.been.called;
-    });
-
-    it('should handle keys in root scope with other scope defined', () => {
-      shortcuts.bind({key, handler: noop});
-      shortcuts.bind({key, scope, handler: noop2});
-
-      trigger();
-
-      noop.should.have.been.called;
-      noop2.should.not.have.been.called;
-    });
-
-    it('should handle keys in top scope', () => {
-      shortcuts.bind({key, handler: noop});
-      shortcuts.bind({key, scope, handler: noop2});
-
-      shortcuts.pushScope(scope);
-      trigger();
-
-      noop.should.not.have.been.called;
-      noop2.should.have.been.called;
-    });
-
-    it('should fall trough scopes when returning true', () => {
-      const fallthrough = sandbox.stub().returns(true);
-
-      shortcuts.bind({key, handler: noop});
-      shortcuts.bind({key, scope, handler: fallthrough});
-
-      shortcuts.pushScope(scope);
-      trigger();
-
-      noop.should.have.been.called;
-      fallthrough.should.have.been.called;
-    });
-
-    it('should not fall trough modal scope', () => {
-      const fallthrough = sandbox.stub().returns(true);
-
-      shortcuts.bind({key, handler: noop});
-      shortcuts.bind({key, scope, handler: fallthrough});
-
-      shortcuts.pushScope(scope, {modal: true});
-      trigger();
-
-      fallthrough.should.have.been.called;
-      noop.should.not.have.been.called;
-    });
-
-    it('should not fall trough modal scope even if it has no handler for key', () => {
-      const fallthrough = sandbox.stub().returns(true);
-
-      shortcuts.bind({key, handler: noop});
-      shortcuts.bind({key: key2, scope, handler: fallthrough});
-
-      shortcuts.pushScope(scope, {modal: true});
-      trigger();
-
-      noop.should.not.have.been.called;
-    });
-  });
-
-  describe('scope chain operations', () => {
-    const scope1 = 'a';
-    const scope2 = 'bb';
-    const scope3 = 'ccc';
-
-    it('empty scope chain should be equal to default', () => {
-      shortcuts.getScope().should.deep.equal([]);
-    });
-
-    it('setScope should set full scope chain by string name', () => {
-      const myscope = 'aaaa';
-      shortcuts.setScope(myscope);
-
-      shortcuts.getScope().should.deep.equal([wrapScope(myscope)]);
-    });
-
-    it('setScope should set full scope chain by array of names', () => {
-      shortcuts.setScope([scope1, scope2]);
-
-      shortcuts.getScope().should.deep.equal([wrapScope(scope1), wrapScope(scope2)]);
-    });
-
-    it('pushScope should add scope to scope chain end', () => {
-      shortcuts.setScope(scope1);
-      shortcuts.pushScope(scope2);
-
-      shortcuts.getScope().should.deep.equal([wrapScope(scope1), wrapScope(scope2)]);
-    });
-
-    it('popScope should remove by name scope and next scopes from chain', () => {
-      shortcuts.setScope([scope1, scope2, scope3]);
-      shortcuts.popScope(scope2);
-
-      shortcuts.getScope().should.deep.equal([wrapScope(scope1)]);
-    });
-
-    it('spliceScope should remove by name scope from chain', () => {
-      shortcuts.setScope([scope1, scope2, scope3]);
-      shortcuts.spliceScope(scope2);
-
-      shortcuts.getScope().should.deep.equal([wrapScope(scope1), wrapScope(scope3)]);
-    });
-
-    it('should store options passed with scope', () => {
-      shortcuts.pushScope(scope1, {foo: 'bar'});
-
-      shortcuts.getScope().should.deep.equal([wrapScope(scope1, {foo: 'bar'})]);
-    });
-
-    it('should workaround system windows shortcuts', () => {
-      let eventType;
-      sandbox.stub(shortcuts.combokeys, 'bind').callsFake((param1, param2, param3) => {
-        eventType = param3;
-      });
-      sandbox.stub(sniffr, 'os').value({name: 'windows'});
-
-      shortcuts.bind({key: 'shift+ctrl+0', handler: noop});
-
-      eventType.should.equal('keyup');
-    });
-
-    it('should not apply workaround for system windows shortcuts on other operating systems', () => {
-      let eventType;
-      sandbox.stub(shortcuts.combokeys, 'bind').callsFake((param1, param2, param3) => {
-        eventType = param3;
-      });
-      sandbox.stub(sniffr, 'os').value({name: 'macos'});
-
-      shortcuts.bind({key: 'shift+ctrl+0', handler: noop});
-
-      ('keyup').should.not.equal(eventType);
-    });
-  });
-});