@king-design/intact 2.1.0 → 2.1.2

package/es/components/dropdown/item.d.ts

@@ -21,6 +21,6 @@ export declare class DropdownItem extends Component<DropdownItemProps, DropdownI
     private dropdownMenu;
     init(): void;
     select(): void;
-    hasSubMenu(): Dropdown<any, any, any> | undefined;
+    hasSubMenu(): undefined;
     private onClick;
 }

package/es/components/dropdown/item.js

@@ -5,8 +5,9 @@ import { Component, inject } from 'intact';
 import template from './item.vdt';
 import { bind } from '../utils';
 import { useItemKeyboard } from './useKeyboard';
-import { Dropdown, DROPDOWN } from './dropdown';
+import { DROPDOWN } from './dropdown';
 import { DROPDOWN_MENU } from './menu';
+import { Dropdown as ExportDropdown, DropdownMenu as ExportDropdownMenu } from '.';
 var typeDefs = {
   disabled: Boolean,
   hideOnSelect: Boolean,
@@ -64,11 +65,22 @@ export var DropdownItem = /*#__PURE__*/function (_Component) {
   };
 
   _proto.hasSubMenu = function hasSubMenu() {
-    // TODO: wrapped by Tooltip
+    // wrapped by Dropdown rather than DropdownMenu
     var parent = this.$senior;
 
-    if (parent instanceof Dropdown) {
-      return parent;
+    while (parent) {
+      // Tooltip extends Dropdown, it's also a instance of Dropdown
+      // so use constructor to detect
+      // if (parent instanceof DropdownMenu) {
+      if (parent.constructor === ExportDropdownMenu) {
+        return;
+      }
+
+      if (parent.constructor === ExportDropdown) {
+        return parent;
+      }
+
+      parent = parent.$senior;
     }
   };
 

package/es/components/dropdown/usePosition.js

@@ -17,7 +17,8 @@ export function usePosition() {
   ['of', 'position'].forEach(function (item) {
     instance.watch(item, function (newValue, oldValue) {
       // return if object is the same
-      if (isObject(newValue) && isObject(oldValue) && _JSON$stringify(newValue) === _JSON$stringify(oldValue)) {
+      if (isObject(newValue) && isObject(oldValue) && // is not event object
+      !(newValue instanceof Event) && _JSON$stringify(newValue) === _JSON$stringify(oldValue)) {
         return;
       }
 
@@ -67,7 +68,8 @@ export function usePosition() {
 
     position(findDomFromVNode(instance.menuVNode, true), _extends({
       my: 'left top+8',
-      at: 'left bottom'
+      at: 'left bottom',
+      collision: instance.get('collison')
     }, pos, {
       of: ofElement,
       using: function using(_feedback) {

package/es/components/form/index.spec.js

@@ -8,10 +8,11 @@ import BasicDemo, { data as basicDemoData } from '~/components/form/demos/basic'
 import CustomDemo from '~/components/form/demos/custom';
 import VariableDemo from '~/components/form/demos/variable';
 import RemoteDemo from '~/components/form/demos/remote';
-import { mount, dispatchEvent, wait } from '../../test/utils';
+import { mount, unmount, dispatchEvent, wait } from '../../test/utils';
 import { Component } from 'intact';
 import { Form, FormItem } from './';
 import { Input } from '../input';
+import { Select } from '../select';
 
 RemoteDemo.prototype.validateUserName = function (value) {
   // mock api
@@ -29,7 +30,9 @@ RemoteDemo.prototype.validateUserName = function (value) {
 };
 
 describe('Form', function () {
-  // afterEach(() => unmount());
+  afterEach(function () {
+    return unmount();
+  });
   it('validate', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
     var _mount, instance, element, form, item, input;
 
@@ -1315,4 +1318,48 @@ describe('Form', function () {
       }
     }, _callee7);
   })));
+  it('should not validate when select is disabled on init', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var Demo, _mount8, instance, element;
+
+    return _regeneratorRuntime.wrap(function _callee8$(_context11) {
+      while (1) {
+        switch (_context11.prev = _context11.next) {
+          case 0:
+            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.Form = Form;
+                _this3.FormItem = FormItem;
+                _this3.Select = Select;
+                return _this3;
+              }
+
+              return Demo;
+            }(Component);
+
+            Demo.template = "\n                const {Form, FormItem, Select} = this;\n                <Form ref=\"form\">\n                    <FormItem rules={{required: true}}>\n                        <Select disabled />\n                    </FormItem>\n                </Form>\n            ";
+            _mount8 = mount(Demo), instance = _mount8[0], element = _mount8[1];
+            _context11.next = 5;
+            return wait(500);
+
+          case 5:
+            expect(element.querySelector('.k-form-error')).to.be.null;
+
+          case 6:
+          case "end":
+            return _context11.stop();
+        }
+      }
+    }, _callee8);
+  })));
 });

package/es/components/menu/index.spec.js

@@ -4,6 +4,7 @@ import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/con
 import _includesInstanceProperty from "@babel/runtime-corejs3/core-js/instance/includes";
 import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
 import { Component } from 'intact';
+import BasicDemo from '~/components/menu/demos/basic';
 import CollapseDemo from '~/components/menu/demos/collapse';
 import AccordionDemo from '~/components/menu/demos/accordion';
 import { mount, unmount, dispatchEvent, getElement, wait } from '../../test/utils';
@@ -19,24 +20,29 @@ describe('Menu', function () {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _mount = mount(CollapseDemo), instance = _mount[0], element = _mount[1];
+            _mount = mount(BasicDemo), instance = _mount[0], element = _mount[1];
+            _context.next = 3;
+            return wait();
+
+          case 3:
+            // shrink
             title = element.querySelector('.k-expanded .k-menu-title');
             title.click();
-            _context.next = 5;
+            _context.next = 7;
             return wait(500);
 
-          case 5:
+          case 7:
             expect(element.outerHTML).to.matchSnapshot();
             expect(instance.get('expandedKeys')).to.eql([]);
             title.click();
-            _context.next = 10;
+            _context.next = 12;
             return wait(500);
 
-          case 10:
+          case 12:
             expect(element.outerHTML).to.matchSnapshot();
             expect(instance.get('expandedKeys')).to.eql(['3']);
 
-          case 12:
+          case 14:
           case "end":
             return _context.stop();
         }
@@ -51,39 +57,44 @@ describe('Menu', function () {
         switch (_context2.prev = _context2.next) {
           case 0:
             _mount2 = mount(CollapseDemo), instance = _mount2[0], element = _mount2[1];
+            instance.set('collapse', false);
+            _context2.next = 4;
+            return wait();
+
+          case 4:
             expect(element.innerHTML).to.matchSnapshot();
             _element$querySelecto = element.querySelectorAll('.k-menu-title'), title = _element$querySelecto[0], disabledTitle = _element$querySelecto[1];
             title.click();
-            _context2.next = 6;
+            _context2.next = 9;
             return wait();
 
-          case 6:
+          case 9:
             expect(element.outerHTML).to.matchSnapshot();
             expect(instance.get('selectedKey')).to.eql('1');
             disabledTitle.click();
-            _context2.next = 11;
+            _context2.next = 14;
             return wait();
 
-          case 11:
+          case 14:
             expect(element.outerHTML).to.matchSnapshot();
             expect(instance.get('selectedKey')).to.eql('1');
             subTitle = element.querySelector('.k-expanded .k-menu .k-menu-title');
             subTitle.click();
-            _context2.next = 17;
+            _context2.next = 20;
             return wait();
 
-          case 17:
+          case 20:
             expect(element.outerHTML).to.matchSnapshot();
             expect(instance.get('selectedKey')).to.eql('3-1'); // clear
 
             instance.set('selectedKey', '');
-            _context2.next = 22;
+            _context2.next = 25;
             return wait();
 
-          case 22:
+          case 25:
             expect(element.querySelector('.k-highlighted')).to.be.null;
 
-          case 23:
+          case 26:
           case "end":
             return _context2.stop();
         }

package/es/components/menu/item.d.ts

@@ -1,5 +1,6 @@
 import { Component, TypeDefs, Key } from 'intact';
 import { Menu } from './menu';
+import { Events } from '../types';
 export interface MenuItemProps {
     key: Key;
     to?: string | object;
@@ -14,6 +15,7 @@ export declare const MENU_ITEM = "MenuItem";
 export declare class MenuItem extends Component<MenuItemProps, MenuItemEvents> {
     static template: string | import("intact").Template<any>;
     static typeDefs: Required<TypeDefs<MenuItemProps>>;
+    static events: Events<MenuItemEvents>;
     rootMenu: Menu<Key>;
     parentMenu: Menu<Key>;
     parentMenuItem: MenuItem | null;

package/es/components/menu/item.js

@@ -19,6 +19,10 @@ var typeDefs = {
   dot: Boolean,
   disabled: Boolean
 };
+var events = {
+  click: true,
+  select: true
+};
 export var MENU_ITEM = 'MenuItem';
 export var MenuItem = /*#__PURE__*/function (_Component) {
   _inheritsLoose(MenuItem, _Component);
@@ -76,5 +80,6 @@ export var MenuItem = /*#__PURE__*/function (_Component) {
 }(Component);
 MenuItem.template = template;
 MenuItem.typeDefs = typeDefs;
+MenuItem.events = events;
 
 __decorate([bind], MenuItem.prototype, "onClick", null);

package/es/components/pagination/index.js

@@ -105,7 +105,10 @@ export var Pagination = /*#__PURE__*/function (_Component) {
 
     if (page > totalPages) {
       page = totalPages;
-    } else if (page < 1) {
+    } // perhaps totalPages is 0
+
+
+    if (page < 1) {
       page = 1;
     }
 

package/es/components/pagination/index.spec.js

@@ -1,10 +1,14 @@
+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/pagination/demos/basic';
 import GotoDemo from '~/components/pagination/demos/goto';
 import CurrentDemo from '~/components/pagination/demos/current';
 import DisableDemo from '~/components/pagination/demos/disable';
 import { mount, dispatchEvent, wait } from '../../test/utils';
+import { Component } from 'intact';
+import { Pagination } from '.';
 describe('Pagination', function () {
   // afterEach(() => unmount());
   it('basic test', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
@@ -167,4 +171,49 @@ describe('Pagination', function () {
       }
     }, _callee4);
   })));
+  it('should not set value to 0 when total is 0 on intialization', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var Demo, _mount5, instance;
+
+    return _regeneratorRuntime.wrap(function _callee5$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            Demo = /*#__PURE__*/function (_Component) {
+              _inheritsLoose(Demo, _Component);
+
+              function Demo() {
+                var _context5;
+
+                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(_context5 = [this]).call(_context5, args)) || this;
+                _this.Pagination = Pagination;
+                return _this;
+              }
+
+              Demo.defaults = function defaults() {
+                return {
+                  page: 1
+                };
+              };
+
+              return Demo;
+            }(Component);
+
+            Demo.template = "\n                const { Pagination } = this;\n                <Pagination total={0} v-model=\"page\" />\n            ";
+            _mount5 = mount(Demo), instance = _mount5[0]; // await wait();
+
+            expect(instance.get('page')).to.eql(1);
+
+          case 4:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee5);
+  })));
 });

package/es/components/tooltip/content.d.ts

@@ -12,6 +12,7 @@ export declare class TooltipContent extends DropdownMenu<TooltipContentProps, To
     private arrow;
     init(): void;
     private onEnter;
+    private onAfterLeave;
     protected onMouseEnter(e: MouseEvent): void;
     private ok;
     private cancel;

package/es/components/tooltip/content.js

@@ -5,6 +5,7 @@ import { DropdownMenu } from '../dropdown/menu';
 import template from './content.vdt';
 import { bind } from '../utils';
 import { useArrow } from './useArrow';
+import { tooltip as tooltipTheme } from './styles';
 export var TooltipContent = /*#__PURE__*/function (_DropdownMenu) {
   _inheritsLoose(TooltipContent, _DropdownMenu);
 
@@ -35,10 +36,24 @@ export var TooltipContent = /*#__PURE__*/function (_DropdownMenu) {
     });
   };
 
-  _proto.onEnter = function onEnter() {
+  _proto.onEnter = function onEnter(elem) {
+    // fix the width, https://github.com/ksc-fe/kpc/issues/873
+    var maxWidth = parseInt(tooltipTheme.maxWidth);
+    var width = elem.offsetWidth;
+
+    if (width === maxWidth) {
+      elem.style.width = width + "px";
+    }
+
     this.dropdown.position();
   };
 
+  _proto.onAfterLeave = function onAfterLeave(elem) {
+    // remove the position after leave, https://github.com/ksc-fe/kpc/issues/873
+    var style = elem.style;
+    style.left = style.top = style.width = '';
+  };
+
   _proto.onMouseEnter = function onMouseEnter(e) {
     var dropdown = this.dropdown;
 
@@ -67,6 +82,8 @@ TooltipContent.template = template;
 
 __decorate([bind], TooltipContent.prototype, "onEnter", null);
 
+__decorate([bind], TooltipContent.prototype, "onAfterLeave", null);
+
 __decorate([bind], TooltipContent.prototype, "onMouseEnter", null);
 
 __decorate([bind], TooltipContent.prototype, "ok", null);

package/es/components/tooltip/content.vdt.js

@@ -38,7 +38,9 @@ export default function ($props, $blocks, $__proto__) {
     'value': !!value && !this.isEmptyChildren,
     'transition': {
       name: 'k-fade',
-      onEnter: this.onEnter
+      onEnter: this.onEnter,
+      onAfterLeave: this.onAfterLeave,
+      onLeaveCancelled: this.onAfterLeave
     },
     'className': _$cn(classNameObj)
   }, function ($blocks) {

package/es/components/tooltip/index.spec.js

@@ -12,7 +12,10 @@ import ContentDemo from '~/components/tooltip/demos/content';
 import ConfirmDemo from '~/components/tooltip/demos/confirm';
 import AlwaysDemo from '~/components/tooltip/demos/always';
 import { Tooltip } from './';
+import { Dialog } from '../dialog';
 import { mount, unmount, dispatchEvent, getElement, wait } from '../../test/utils';
+import { tooltip as tooltipTheme } from './styles';
+import { Select, Option } from '../select';
 describe('Tooltip', function () {
   afterEach(function (done) {
     unmount();
@@ -577,4 +580,166 @@ describe('Tooltip', function () {
       }
     }, _callee9);
   })));
+  it('should add className', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+    var Demo, _mount10, instance, element, trigger, dropdown;
+
+    return _regeneratorRuntime.wrap(function _callee10$(_context13) {
+      while (1) {
+        switch (_context13.prev = _context13.next) {
+          case 0:
+            Demo = /*#__PURE__*/function (_Component3) {
+              _inheritsLoose(Demo, _Component3);
+
+              function Demo() {
+                var _context12;
+
+                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(_context12 = [this]).call(_context12, args)) || this;
+                _this3.Tooltip = Tooltip;
+                return _this3;
+              }
+
+              return Demo;
+            }(Component);
+
+            Demo.template = "\n                const Tooltip = this.Tooltip;\n                <div>\n                    <Tooltip content=\"hello\" class=\"a\">\n                        <div ref=\"test\" class=\"b\">test</div>\n                    </Tooltip>\n                </div>\n            ";
+            _mount10 = mount(Demo), instance = _mount10[0], element = _mount10[1];
+            trigger = instance.refs.test;
+            expect(trigger.className).to.eql('b a');
+            dispatchEvent(trigger, 'mouseenter');
+            _context13.next = 8;
+            return wait();
+
+          case 8:
+            dropdown = getElement('.k-tooltip-content');
+            expect(dropdown.classList.contains('a')).to.be.true;
+
+          case 10:
+          case "end":
+            return _context13.stop();
+        }
+      }
+    }, _callee10);
+  })));
+  it('should fix the width in small container', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+    var Demo, _mount11, instance, element, trigger, expecedWidth, content, width, newWidth;
+
+    return _regeneratorRuntime.wrap(function _callee11$(_context15) {
+      while (1) {
+        switch (_context15.prev = _context15.next) {
+          case 0:
+            Demo = /*#__PURE__*/function (_Component4) {
+              _inheritsLoose(Demo, _Component4);
+
+              function Demo() {
+                var _context14;
+
+                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(_context14 = [this]).call(_context14, args)) || this;
+                _this4.Tooltip = Tooltip;
+                _this4.Dialog = Dialog;
+                return _this4;
+              }
+
+              return Demo;
+            }(Component);
+
+            Demo.template = "\n                const {Tooltip, Dialog} = this;\n                <div style=\"text-align: right; position: relative; width: 300px;\">\n                    <Tooltip content=\"\u8FD9\u662F\u4E00\u6BB5\u5F88\u957F\u7684\u63CF\u8FF0\u6587\u5B57\uFF0C\u8FD9\u662F\u4E00\u6BB5\u5F88\u957F\u7684\u63CF\u8FF0\u6587\u5B57\" container={dom => dom}>\n                        <span class=\"trigger\">test</span>\n                    </Tooltip>\n                </div>\n            ";
+            _mount11 = mount(Demo), instance = _mount11[0], element = _mount11[1];
+            trigger = element.querySelector('.trigger');
+            expecedWidth = parseInt(tooltipTheme.maxWidth);
+            dispatchEvent(trigger, 'mouseenter');
+            _context15.next = 8;
+            return wait();
+
+          case 8:
+            content = getElement('.k-tooltip-content');
+            width = content.offsetWidth;
+            expect(width).to.eql(expecedWidth);
+            dispatchEvent(trigger, 'mouseleave');
+            _context15.next = 14;
+            return wait();
+
+          case 14:
+            dispatchEvent(trigger, 'mouseenter');
+            _context15.next = 17;
+            return wait();
+
+          case 17:
+            newWidth = content.offsetWidth;
+            expect(newWidth).to.eql(width);
+
+          case 19:
+          case "end":
+            return _context15.stop();
+        }
+      }
+    }, _callee11);
+  })));
+  it('should not impact select when wrap select with tooltip', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+    var Demo, _mount12, instance, element, menu;
+
+    return _regeneratorRuntime.wrap(function _callee12$(_context17) {
+      while (1) {
+        switch (_context17.prev = _context17.next) {
+          case 0:
+            Demo = /*#__PURE__*/function (_Component5) {
+              _inheritsLoose(Demo, _Component5);
+
+              function Demo() {
+                var _context16;
+
+                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(_context16 = [this]).call(_context16, args)) || this;
+                _this5.Tooltip = Tooltip;
+                _this5.Select = Select;
+                _this5.Option = Option;
+                return _this5;
+              }
+
+              return Demo;
+            }(Component);
+
+            Demo.template = "\n                const {Tooltip, Select, Option} = this;\n                <Tooltip>\n                    <Select>\n                        <Option value=\"1\">Option 1</Option>\n                        <Option value=\"2\">Option 2</Option>\n                    </Select>\n                </Tooltip>\n            ";
+            _mount12 = mount(Demo), instance = _mount12[0], element = _mount12[1];
+            dispatchEvent(element, 'mouseenter');
+            _context17.next = 6;
+            return wait();
+
+          case 6:
+            dispatchEvent(element, 'click');
+            _context17.next = 9;
+            return wait();
+
+          case 9:
+            menu = getElement(".k-select-menu");
+            dispatchEvent(element, 'mouseleave');
+            _context17.next = 13;
+            return wait(500);
+
+          case 13:
+            expect(menu.style.display).to.eql('');
+
+          case 14:
+          case "end":
+            return _context17.stop();
+        }
+      }
+    }, _callee12);
+  })));
 });

package/es/components/tooltip/styles.d.ts

@@ -1,4 +1,26 @@
 import '../../styles/global';
+declare const defaults: {
+    padding: string;
+    readonly color: string;
+    bgColor: string;
+    lineHeight: number;
+    maxWidth: string;
+    arrow: {
+        borderColor: string;
+        width: string;
+    };
+    confirm: {
+        gaps: string;
+    };
+    dark: {
+        readonly bgColor: string;
+        color: string;
+        readonly arrowBorderColor: string;
+    };
+    smallPadding: string;
+};
+export declare let tooltip: typeof defaults;
 export declare type Theme = 'dark' | 'light';
 export declare const themes: Theme[];
 export default function makeStyles(): string;
+export {};

package/es/components/tooltip/styles.js

@@ -38,7 +38,7 @@ var defaults = {
   },
   smallPadding: '4px'
 };
-var tooltip;
+export var tooltip;
 setDefault(function () {
   tooltip = deepDefaults(theme, {
     tooltip: defaults

package/es/components/tooltip/tooltip.d.ts

@@ -23,5 +23,6 @@ export declare class Tooltip<T extends TooltipProps = TooltipProps, E extends To
     static typeDefs: Required<TypeDefs<TooltipProps>>;
     static defaults: () => Partial<TooltipProps>;
     static events: Events<TooltipEvents>;
+    show(shouldFocus?: boolean): void;
     hide(immediately: boolean): void;
 }

package/es/components/tooltip/tooltip.js

@@ -25,6 +25,7 @@ var defaults = function defaults() {
       at: 'center top',
       collision: 'flipfit'
     },
+    collison: 'flipfit',
     hoverable: false,
     always: false,
     confirm: false,
@@ -48,12 +49,26 @@ export var Tooltip = /*#__PURE__*/function (_Dropdown) {
 
   var _proto = Tooltip.prototype;
 
+  _proto.show = function show(shouldFocus) {
+    if (shouldFocus === void 0) {
+      shouldFocus = false;
+    }
+
+    if (this.get('disabled')) return;
+    clearTimeout(this.timer);
+    this.set('value', true);
+  };
+
   _proto.hide = function hide(immediately) {
     if (this.get('always')) return;
 
     if (this.get('hoverable')) {
       return _Dropdown.prototype.hide.call(this, immediately);
-    }
+    } // tooltip can show any number sub-tooltips, we should not close the showed tooltip
+    // #885
+
+
+    this.showedDropdown = null;
 
     _Dropdown.prototype.hide.call(this, true);
   };