Debian Codegraph @

packages/widgets/tests/src/menu.spec.ts

raw
1 // Copyright (c) Jupyter Development Team.
2 // Distributed under the terms of the Modified BSD License.
3 /*-----------------------------------------------------------------------------
4 | Copyright (c) 2014-2017, PhosphorJS Contributors
5 |
6 | Distributed under the terms of the BSD 3-Clause License.
7 |
8 | The full license is in the file LICENSE, distributed with this software.
9 |----------------------------------------------------------------------------*/
10 import { expect } from 'chai';
11
12 import { CommandRegistry } from '@lumino/commands';
13
14 import { JSONObject } from '@lumino/coreutils';
15
16 import { Platform } from '@lumino/domutils';
17
18 import { Message } from '@lumino/messaging';
19
20 import { h, VirtualDOM } from '@lumino/virtualdom';
21
22 import { Menu, Widget } from '@lumino/widgets';
23
24 class LogMenu extends Menu {
25 events: string[] = [];
26
27 methods: string[] = [];
28
29 handleEvent(event: Event): void {
30 super.handleEvent(event);
31 this.events.push(event.type);
32 }
33
34 protected onBeforeAttach(msg: Message): void {
35 super.onBeforeAttach(msg);
36 this.methods.push('onBeforeAttach');
37 }
38
39 protected onAfterDetach(msg: Message): void {
40 super.onAfterDetach(msg);
41 this.methods.push('onAfterDetach');
42 }
43
44 protected onActivateRequest(msg: Message): void {
45 super.onActivateRequest(msg);
46 this.methods.push('onActivateRequest');
47 }
48
49 protected onUpdateRequest(msg: Message): void {
50 super.onUpdateRequest(msg);
51 this.methods.push('onUpdateRequest');
52 }
53
54 protected onCloseRequest(msg: Message): void {
55 super.onCloseRequest(msg);
56 this.methods.push('onCloseRequest');
57 }
58 }
59
60 const bubbles = true;
61
62 describe('@lumino/widgets', () => {
63 let commands = new CommandRegistry();
64 let logMenu: LogMenu = null!;
65 let menu: Menu = null!;
66 let executed = '';
67 const iconClass = 'foo';
68 const iconRenderer = {
69 render: (host: HTMLElement, options?: any) => {
70 const renderNode = document.createElement('div');
71 host.classList.add(iconClass);
72 host.appendChild(renderNode);
73 }
74 };
75
76 before(() => {
77 commands.addCommand('test', {
78 execute: (args: JSONObject) => {
79 executed = 'test';
80 },
81 label: 'Test Label',
82 icon: iconRenderer,
83 iconClass,
84 caption: 'Test Caption',
85 className: 'testClass',
86 mnemonic: 0
87 });
88 commands.addCommand('test-toggled', {
89 execute: (args: JSONObject) => {
90 executed = 'test-toggled';
91 },
92 label: 'Test Toggled Label',
93 icon: iconRenderer,
94 className: 'testClass',
95 isToggled: (args: JSONObject) => true,
96 mnemonic: 6
97 });
98 commands.addCommand('test-disabled', {
99 execute: (args: JSONObject) => {
100 executed = 'test-disabled';
101 },
102 label: 'Test Disabled Label',
103 icon: iconRenderer,
104 className: 'testClass',
105 isEnabled: (args: JSONObject) => false,
106 mnemonic: 5
107 });
108 commands.addCommand('test-hidden', {
109 execute: (args: JSONObject) => {
110 executed = 'test-hidden';
111 },
112 label: 'Hidden Label',
113 icon: iconRenderer,
114 className: 'testClass',
115 isVisible: (args: JSONObject) => false
116 });
117 commands.addCommand('test-zenith', {
118 execute: (args: JSONObject) => {
119 executed = 'test-zenith';
120 },
121 label: 'Zenith Label',
122 icon: iconRenderer,
123 className: 'testClass'
124 });
125 commands.addKeyBinding({
126 keys: ['Ctrl T'],
127 selector: 'body',
128 command: 'test'
129 });
130 });
131
132 beforeEach(() => {
133 executed = '';
134 menu = new Menu({ commands });
135 logMenu = new LogMenu({ commands });
136 });
137
138 afterEach(() => {
139 menu.dispose();
140 logMenu.dispose();
141 });
142
143 describe('Menu', () => {
144 describe('#constructor()', () => {
145 it('should take options for initializing the menu', () => {
146 let menu = new Menu({ commands });
147 expect(menu).to.be.an.instanceof(Menu);
148 });
149
150 it('should add the `lm-Menu` class', () => {
151 let menu = new Menu({ commands });
152 expect(menu.hasClass('lm-Menu')).to.equal(true);
153 });
154 });
155
156 describe('#dispose()', () => {
157 it('should dispose of the resources held by the menu', () => {
158 menu.addItem({});
159 expect(menu.items.length).to.equal(1);
160 menu.dispose();
161 expect(menu.items.length).to.equal(0);
162 expect(menu.isDisposed).to.equal(true);
163 });
164 });
165
166 describe('#aboutToClose', () => {
167 it('should be emitted just before the menu is closed', () => {
168 let called = false;
169 menu.open(0, 0);
170 menu.aboutToClose.connect((sender, args) => {
171 called = true;
172 });
173 menu.close();
174 expect(called).to.equal(true);
175 });
176
177 it('should not be emitted if the menu is not attached', () => {
178 let called = false;
179 menu.open(0, 0);
180 menu.aboutToClose.connect(() => {
181 called = true;
182 });
183 Widget.detach(menu);
184 menu.close();
185 expect(called).to.equal(false);
186 });
187 });
188
189 describe('menuRequested', () => {
190 it('should be emitted when a left arrow key is pressed and a submenu cannot be opened or closed', () => {
191 let called = false;
192 menu.open(0, 0);
193 menu.menuRequested.connect((sender, args) => {
194 expect(args).to.equal('previous');
195 called = true;
196 });
197 menu.node.dispatchEvent(
198 new KeyboardEvent('keydown', {
199 bubbles,
200 keyCode: 37 // Left arrow
201 })
202 );
203 expect(called).to.equal(true);
204 });
205
206 it('should be emitted when a right arrow key is pressed and a submenu cannot be opened or closed', () => {
207 let called = false;
208 menu.open(0, 0);
209 menu.menuRequested.connect((sender, args) => {
210 expect(args).to.equal('next');
211 called = true;
212 });
213 menu.node.dispatchEvent(
214 new KeyboardEvent('keydown', {
215 bubbles,
216 keyCode: 39 // Right arrow
217 })
218 );
219 expect(called).to.equal(true);
220 });
221
222 it('should only be emitted for the root menu in a hierarchy', () => {
223 let submenu = new Menu({ commands });
224 let item = menu.addItem({ type: 'submenu', submenu });
225 menu.open(0, 0);
226 menu.activeItem = item;
227 menu.triggerActiveItem();
228 let called = false;
229 let submenuCalled = false;
230 menu.menuRequested.connect((sender, args) => {
231 expect(args).to.equal('next');
232 called = true;
233 });
234 submenu.menuRequested.connect(() => {
235 submenuCalled = true;
236 });
237 submenu.node.dispatchEvent(
238 new KeyboardEvent('keydown', {
239 bubbles,
240 keyCode: 39 // Right arrow
241 })
242 );
243 expect(called).to.equal(true);
244 expect(submenuCalled).to.equal(false);
245 });
246 });
247
248 describe('#commands', () => {
249 it('should be the command registry for the menu', () => {
250 expect(menu.commands).to.equal(commands);
251 });
252 });
253
254 describe('#renderer', () => {
255 it('should default to the default renderer', () => {
256 expect(menu.renderer).to.equal(Menu.defaultRenderer);
257 });
258
259 it('should be the renderer for the menu', () => {
260 let renderer = Object.create(Menu.defaultRenderer);
261 let menu = new Menu({ commands, renderer });
262 expect(menu.renderer).to.equal(renderer);
263 });
264 });
265
266 describe('#parentMenu', () => {
267 it('should get the parent menu of the menu', () => {
268 let submenu = new Menu({ commands });
269 let item = menu.addItem({ type: 'submenu', submenu });
270 menu.open(0, 0);
271 menu.activeItem = item;
272 menu.triggerActiveItem();
273 expect(submenu.parentMenu).to.equal(menu);
274 });
275
276 it('should be `null` if the menu is not an open submenu', () => {
277 let submenu = new Menu({ commands });
278 menu.addItem({ type: 'submenu', submenu });
279 menu.open(0, 0);
280 expect(submenu.parentMenu).to.equal(null);
281 expect(menu.parentMenu).to.equal(null);
282 });
283 });
284
285 describe('#childMenu', () => {
286 it('should get the child menu of the menu', () => {
287 let submenu = new Menu({ commands });
288 let item = menu.addItem({ type: 'submenu', submenu });
289 menu.open(0, 0);
290 menu.activeItem = item;
291 menu.triggerActiveItem();
292 expect(menu.childMenu).to.equal(submenu);
293 });
294
295 it('should be `null` if the menu does not have an open submenu', () => {
296 let submenu = new Menu({ commands });
297 menu.addItem({ type: 'submenu', submenu });
298 menu.open(0, 0);
299 expect(menu.childMenu).to.equal(null);
300 });
301 });
302
303 describe('#rootMenu', () => {
304 it('should get the root menu of the menu hierarchy', () => {
305 let submenu1 = new Menu({ commands });
306 let submenu2 = new Menu({ commands });
307 let item1 = menu.addItem({ type: 'submenu', submenu: submenu1 });
308 let item2 = submenu1.addItem({ type: 'submenu', submenu: submenu2 });
309 menu.open(0, 0);
310 menu.activeItem = item1;
311 menu.triggerActiveItem();
312 submenu1.activeItem = item2;
313 submenu1.triggerActiveItem();
314 expect(submenu2.rootMenu).to.equal(menu);
315 });
316
317 it('should be itself if the menu is not an open submenu', () => {
318 let submenu1 = new Menu({ commands });
319 let submenu2 = new Menu({ commands });
320 menu.addItem({ type: 'submenu', submenu: submenu1 });
321 submenu1.addItem({ type: 'submenu', submenu: submenu2 });
322 menu.open(0, 0);
323 expect(menu.rootMenu).to.equal(menu);
324 expect(submenu1.rootMenu).to.equal(submenu1);
325 expect(submenu2.rootMenu).to.equal(submenu2);
326 });
327 });
328
329 describe('#leafMenu', () => {
330 it('should get the leaf menu of the menu hierarchy', () => {
331 let submenu1 = new Menu({ commands });
332 let submenu2 = new Menu({ commands });
333 let item1 = menu.addItem({ type: 'submenu', submenu: submenu1 });
334 let item2 = submenu1.addItem({ type: 'submenu', submenu: submenu2 });
335 menu.open(0, 0);
336 menu.activeItem = item1;
337 menu.triggerActiveItem();
338 submenu1.activeItem = item2;
339 submenu1.triggerActiveItem();
340 expect(menu.leafMenu).to.equal(submenu2);
341 });
342
343 it('should be itself if the menu does not have an open submenu', () => {
344 let submenu1 = new Menu({ commands });
345 let submenu2 = new Menu({ commands });
346 menu.addItem({ type: 'submenu', submenu: submenu1 });
347 submenu1.addItem({ type: 'submenu', submenu: submenu2 });
348 menu.open(0, 0);
349 expect(menu.leafMenu).to.equal(menu);
350 expect(submenu1.leafMenu).to.equal(submenu1);
351 expect(submenu2.leafMenu).to.equal(submenu2);
352 });
353 });
354
355 describe('#contentNode', () => {
356 it('should get the menu content node', () => {
357 let content = menu.contentNode;
358 expect(content.classList.contains('lm-Menu-content')).to.equal(true);
359 });
360 });
361
362 describe('#activeItem', () => {
363 it('should get the currently active menu item', () => {
364 let item = menu.addItem({ command: 'test' });
365 menu.activeIndex = 0;
366 expect(menu.activeItem).to.equal(item);
367 });
368
369 it('should be `null` if no menu item is active', () => {
370 expect(menu.activeItem).to.equal(null);
371 menu.addItem({ command: 'test' });
372 expect(menu.activeItem).to.equal(null);
373 });
374
375 it('should set the currently active menu item', () => {
376 expect(menu.activeItem).to.equal(null);
377 let item = (menu.activeItem = menu.addItem({ command: 'test' }));
378 expect(menu.activeItem).to.equal(item);
379 });
380
381 it('should set to `null` if the item cannot be activated', () => {
382 expect(menu.activeItem).to.equal(null);
383 menu.activeItem = menu.addItem({ command: 'test-disabled' });
384 expect(menu.activeItem).to.equal(null);
385 });
386 });
387
388 describe('#activeIndex', () => {
389 it('should get the index of the currently active menu item', () => {
390 menu.activeItem = menu.addItem({ command: 'test' });
391 expect(menu.activeIndex).to.equal(0);
392 });
393
394 it('should be `-1` if no menu item is active', () => {
395 expect(menu.activeIndex).to.equal(-1);
396 menu.addItem({ command: 'test' });
397 expect(menu.activeIndex).to.equal(-1);
398 });
399
400 it('should set the currently active menu item index', () => {
401 expect(menu.activeIndex).to.equal(-1);
402 menu.addItem({ command: 'test' });
403 menu.activeIndex = 0;
404 expect(menu.activeIndex).to.equal(0);
405 });
406
407 it('should set to `-1` if the item cannot be activated', () => {
408 menu.addItem({ command: 'test-disabled' });
409 menu.activeIndex = 0;
410 expect(menu.activeIndex).to.equal(-1);
411 });
412 });
413
414 describe('#items', () => {
415 it('should be a read-only array of the menu items in the menu', () => {
416 let item1 = menu.addItem({ command: 'foo' });
417 let item2 = menu.addItem({ command: 'bar' });
418 expect(menu.items).to.deep.equal([item1, item2]);
419 });
420 });
421
422 describe('#activateNextItem()', () => {
423 it('should activate the next selectable item in the menu', () => {
424 menu.addItem({ command: 'test-disabled' });
425 menu.addItem({ command: 'test' });
426 menu.activateNextItem();
427 expect(menu.activeIndex).to.equal(1);
428 });
429
430 it('should set the index to `-1` if no item is selectable', () => {
431 menu.addItem({ command: 'test-disabled' });
432 menu.addItem({ type: 'separator' });
433 menu.activateNextItem();
434 expect(menu.activeIndex).to.equal(-1);
435 });
436 });
437
438 describe('#activatePreviousItem()', () => {
439 it('should activate the next selectable item in the menu', () => {
440 menu.addItem({ command: 'test' });
441 menu.addItem({ command: 'test-disabled' });
442 menu.activatePreviousItem();
443 expect(menu.activeIndex).to.equal(0);
444 });
445
446 it('should set the index to `-1` if no item is selectable', () => {
447 menu.addItem({ command: 'test-disabled' });
448 menu.addItem({ type: 'separator' });
449 menu.activatePreviousItem();
450 expect(menu.activeIndex).to.equal(-1);
451 });
452 });
453
454 describe('#triggerActiveItem()', () => {
455 it('should execute a command if it is the active item', () => {
456 menu.addItem({ command: 'test' });
457 menu.open(0, 0);
458 menu.activeIndex = 0;
459 menu.triggerActiveItem();
460 expect(executed).to.equal('test');
461 });
462
463 it('should open a submenu and activate the first item', () => {
464 let submenu = new Menu({ commands });
465 submenu.addItem({ command: 'test' });
466 menu.addItem({ type: 'submenu', submenu });
467 menu.open(0, 0);
468 menu.activeIndex = 0;
469 menu.triggerActiveItem();
470 expect(submenu.parentMenu).to.equal(menu);
471 expect(submenu.activeIndex).to.equal(0);
472 });
473
474 it('should be a no-op if the menu is not attached', () => {
475 let submenu = new Menu({ commands });
476 submenu.addItem({ command: 'test' });
477 menu.addItem({ type: 'submenu', submenu });
478 menu.activeIndex = 0;
479 menu.triggerActiveItem();
480 expect(submenu.parentMenu).to.equal(null);
481 expect(submenu.activeIndex).to.equal(-1);
482 });
483
484 it('should be a no-op if there is no active item', () => {
485 let submenu = new Menu({ commands });
486 submenu.addItem({ command: 'test' });
487 menu.addItem({ type: 'submenu', submenu });
488 menu.open(0, 0);
489 menu.triggerActiveItem();
490 expect(submenu.parentMenu).to.equal(null);
491 expect(submenu.activeIndex).to.equal(-1);
492 });
493 });
494
495 describe('#addItem()', () => {
496 it('should add a menu item to the end of the menu', () => {
497 menu.addItem({});
498 let item = menu.addItem({ command: 'test' });
499 expect(menu.items[1]).to.equal(item);
500 });
501 });
502
503 describe('#insertItem()', () => {
504 it('should insert a menu item into the menu at the specified index', () => {
505 let item1 = menu.insertItem(0, { command: 'test' });
506 let item2 = menu.insertItem(0, { command: 'test-disabled' });
507 let item3 = menu.insertItem(0, { command: 'test-toggled' });
508 expect(menu.items[0]).to.equal(item3);
509 expect(menu.items[1]).to.equal(item2);
510 expect(menu.items[2]).to.equal(item1);
511 });
512
513 it('should clamp the index to the bounds of the items', () => {
514 let item1 = menu.insertItem(0, { command: 'test' });
515 let item2 = menu.insertItem(10, { command: 'test-disabled' });
516 let item3 = menu.insertItem(-10, { command: 'test-toggled' });
517 expect(menu.items[0]).to.equal(item3);
518 expect(menu.items[1]).to.equal(item1);
519 expect(menu.items[2]).to.equal(item2);
520 });
521
522 it('should close the menu if attached', () => {
523 menu.open(0, 0);
524 expect(menu.isAttached).to.equal(true);
525 menu.insertItem(0, { command: 'test' });
526 expect(menu.isAttached).to.equal(false);
527 });
528 });
529
530 describe('#removeItem()', () => {
531 it('should remove a menu item from the menu by value', () => {
532 menu.removeItem(menu.addItem({ command: 'test' }));
533 expect(menu.items.length).to.equal(0);
534 });
535
536 it('should close the menu if it is attached', () => {
537 let item = menu.addItem({ command: 'test' });
538 menu.open(0, 0);
539 expect(menu.isAttached).to.equal(true);
540 menu.removeItem(item);
541 expect(menu.isAttached).to.equal(false);
542 });
543
544 it('should be a no-op if the item is not in the menu', () => {
545 let item1 = menu.addItem({ command: 'test1' });
546 let item2 = menu.addItem({ command: 'test2' });
547 menu.removeItem(item1);
548 expect(menu.items.length).to.equal(1);
549 expect(menu.items[0]).to.equal(item2);
550 menu.removeItem(item1); // should be no-op
551 expect(menu.items.length).to.equal(1);
552 expect(menu.items[0]).to.equal(item2);
553 });
554 });
555
556 describe('#removeItemAt()', () => {
557 it('should remove a menu item from the menu by index', () => {
558 menu.addItem({ command: 'test' });
559 menu.removeItemAt(0);
560 expect(menu.items.length).to.equal(0);
561 });
562
563 it('should close the menu if it is attached', () => {
564 menu.addItem({ command: 'test' });
565 menu.open(0, 0);
566 expect(menu.isAttached).to.equal(true);
567 menu.removeItemAt(0);
568 expect(menu.isAttached).to.equal(false);
569 });
570 });
571
572 describe('#clearItems()', () => {
573 it('should remove all items from the menu', () => {
574 menu.addItem({ command: 'test-disabled' });
575 menu.addItem({ command: 'test' });
576 menu.activeIndex = 1;
577 menu.clearItems();
578 expect(menu.items.length).to.equal(0);
579 expect(menu.activeIndex).to.equal(-1);
580 });
581
582 it('should close the menu if it is attached', () => {
583 menu.addItem({ command: 'test-disabled' });
584 menu.addItem({ command: 'test' });
585 menu.open(0, 0);
586 expect(menu.isAttached).to.equal(true);
587 menu.clearItems();
588 expect(menu.isAttached).to.equal(false);
589 });
590 });
591
592 describe('#open()', () => {
593 it('should open the menu at the specified location', () => {
594 menu.addItem({ command: 'test' });
595 menu.open(10, 10);
596 expect(menu.node.style.transform).to.equal('translate(10px, 10px)');
597 });
598
599 it('should be adjusted to fit naturally on the screen', () => {
600 menu.addItem({ command: 'test' });
601 menu.open(-10, 10000);
602 expect(
603 menu.node.style.transform.startsWith('translate(0px, ')
604 ).to.equal(true);
605 expect(menu.node.style.transform.endsWith(', 10000px)')).to.equal(
606 false
607 );
608 });
609
610 it('should accept flags to force the location', () => {
611 menu.addItem({ command: 'test' });
612 menu.open(10000, 10000, { forceX: true, forceY: true });
613 expect(menu.node.style.transform).to.equal(
614 'translate(10000px, 10000px)'
615 );
616 });
617
618 it('should accept horizontalAlignment menu flags', () => {
619 menu.addItem({ command: 'test' });
620 menu.open(300, 300, { horizontalAlignment: 'right' });
621 let { width } = menu.node.getBoundingClientRect();
622 const expectedX = Math.floor(300 - width);
623 expect(
624 menu.node.style.transform.startsWith(`translate(${expectedX}`)
625 ).to.equal(true);
626 expect(menu.node.style.transform.endsWith('px, 300px)')).to.equal(true);
627 });
628
629 it('horizontalAlignment should default to `right` if language direction is `rtl`', () => {
630 document.documentElement.setAttribute('dir', 'rtl');
631 menu.addItem({ command: 'test' });
632 menu.open(300, 300);
633 let { width } = menu.node.getBoundingClientRect();
634 const expectedX = Math.floor(300 - width);
635 expect(
636 menu.node.style.transform.startsWith(`translate(${expectedX}`)
637 ).to.equal(true);
638 expect(menu.node.style.transform.endsWith('px, 300px)')).to.equal(true);
639 document.documentElement.removeAttribute('dir'); // Reset the direction
640 });
641
642 it('should bail if already attached', () => {
643 menu.addItem({ command: 'test' });
644 menu.open(10, 10);
645 menu.open(100, 100);
646 expect(menu.node.style.transform).to.equal('translate(10px, 10px)');
647 });
648
649 it('should insert as last child under document.body by default', () => {
650 const div = document.body.appendChild(document.createElement('div'));
651 menu.addItem({ command: 'test' });
652 menu.open(10, 10);
653 expect(menu.node.parentElement).to.equal(document.body);
654 expect(menu.node.previousElementSibling).to.equal(div);
655 expect(menu.node.nextElementSibling).to.be.null;
656 });
657
658 it('should insert as last child under specified host element', () => {
659 const div = document.body.appendChild(document.createElement('div'));
660 const child = div.appendChild(document.createElement('div'));
661 menu.addItem({ command: 'test' });
662 menu.open(10, 10, { host: div });
663 expect(menu.node.parentElement).to.equal(div);
664 expect(menu.node.previousElementSibling).to.equal(child);
665 expect(menu.node.nextElementSibling).to.be.null;
666 });
667
668 it('should insert before reference element under document.body', () => {
669 const div1 = document.body.appendChild(document.createElement('div'));
670 const div2 = document.body.appendChild(document.createElement('div'));
671 menu.addItem({ command: 'test' });
672 menu.open(10, 10, { ref: div2 });
673 expect(menu.node.parentElement).to.equal(document.body);
674 expect(menu.node.previousElementSibling).to.equal(div1);
675 expect(menu.node.nextElementSibling).to.equal(div2);
676 });
677
678 it('should insert before reference element under specified host element', () => {
679 const div = document.body.appendChild(document.createElement('div'));
680 const child1 = div.appendChild(document.createElement('div'));
681 const child2 = div.appendChild(document.createElement('div'));
682 menu.open(10, 10, { host: div, ref: child2 });
683 expect(menu.node.parentElement).to.equal(div);
684 expect(menu.node.previousElementSibling).to.equal(child1);
685 expect(menu.node.nextElementSibling).to.equal(child2);
686 });
687 });
688
689 describe('#handleEvent()', () => {
690 context('keydown', () => {
691 it('should trigger the active item on enter', () => {
692 menu.addItem({ command: 'test' });
693 menu.activeIndex = 0;
694 menu.open(0, 0);
695 menu.node.dispatchEvent(
696 new KeyboardEvent('keydown', {
697 bubbles,
698 keyCode: 13 // Enter
699 })
700 );
701 expect(executed).to.equal('test');
702 });
703
704 it('should close the menu on escape', () => {
705 menu.open(0, 0);
706 expect(menu.isAttached).to.equal(true);
707 menu.node.dispatchEvent(
708 new KeyboardEvent('keydown', {
709 bubbles,
710 keyCode: 27 // Escape
711 })
712 );
713 expect(menu.isAttached).to.equal(false);
714 });
715
716 it('should close the menu on left arrow if there is a parent menu', () => {
717 let submenu = new Menu({ commands });
718 submenu.addItem({ command: 'test' });
719 menu.addItem({ type: 'submenu', submenu });
720 menu.open(0, 0);
721 menu.activateNextItem();
722 menu.triggerActiveItem();
723 expect(menu.childMenu).to.equal(submenu);
724 submenu.node.dispatchEvent(
725 new KeyboardEvent('keydown', {
726 bubbles,
727 keyCode: 37 // Left arrow
728 })
729 );
730 expect(menu.childMenu).to.equal(null);
731 });
732
733 it('should activate the previous item on up arrow', () => {
734 menu.addItem({ command: 'test' });
735 menu.addItem({ command: 'test' });
736 menu.addItem({ command: 'test' });
737 menu.open(0, 0);
738 menu.node.dispatchEvent(
739 new KeyboardEvent('keydown', {
740 bubbles,
741 keyCode: 38 // Up arrow
742 })
743 );
744 expect(menu.activeIndex).to.equal(2);
745 });
746
747 it('should trigger the active item on right arrow if the item is a submenu', () => {
748 let submenu = new Menu({ commands });
749 submenu.addItem({ command: 'test' });
750 menu.addItem({ type: 'submenu', submenu });
751 menu.open(0, 0);
752 menu.activateNextItem();
753 expect(menu.childMenu).to.equal(null);
754 menu.node.dispatchEvent(
755 new KeyboardEvent('keydown', {
756 bubbles,
757 keyCode: 39 // Right arrow
758 })
759 );
760 expect(menu.childMenu).to.equal(submenu);
761 });
762
763 it('should activate the next item on down arrow', () => {
764 menu.addItem({ command: 'test' });
765 menu.addItem({ command: 'test' });
766 menu.open(0, 0);
767 menu.node.dispatchEvent(
768 new KeyboardEvent('keydown', {
769 bubbles,
770 keyCode: 40 // Down arrow
771 })
772 );
773 expect(menu.activeIndex).to.equal(0);
774 });
775
776 it('should activate the first matching mnemonic', () => {
777 let submenu1 = new Menu({ commands });
778 submenu1.title.label = 'foo';
779 submenu1.title.mnemonic = 0;
780 submenu1.addItem({ command: 'test' });
781
782 let submenu2 = new Menu({ commands });
783 submenu2.title.label = 'bar';
784 submenu2.title.mnemonic = 0;
785 submenu2.addItem({ command: 'test' });
786
787 menu.addItem({ type: 'submenu', submenu: submenu1 });
788 menu.addItem({ type: 'separator' });
789 menu.addItem({ type: 'submenu', submenu: submenu2 });
790
791 menu.open(0, 0);
792 menu.node.dispatchEvent(
793 new KeyboardEvent('keydown', {
794 bubbles,
795 keyCode: 70 // `F` key
796 })
797 );
798 expect(menu.activeIndex).to.equal(0);
799 });
800
801 it('should activate an item with no matching mnemonic, but matching first character', () => {
802 menu.addItem({ command: 'test' });
803 menu.addItem({ command: 'test-disabled' });
804 menu.addItem({ command: 'test-toggled' });
805 menu.addItem({ command: 'test-hidden' });
806 menu.addItem({ command: 'test-zenith' });
807 menu.open(0, 0);
808 expect(menu.activeIndex).to.equal(-1);
809 menu.node.dispatchEvent(
810 new KeyboardEvent('keydown', {
811 bubbles,
812 keyCode: 90 // `Z` key
813 })
814 );
815 expect(menu.activeIndex).to.equal(4);
816 });
817 });
818
819 context('mouseup', () => {
820 it('should trigger the active item', () => {
821 menu.addItem({ command: 'test' });
822 menu.activeIndex = 0;
823 menu.open(0, 0);
824 menu.node.dispatchEvent(new MouseEvent('mouseup', { bubbles }));
825 expect(executed).to.equal('test');
826 });
827
828 it('should bail if not a left mouse button', () => {
829 menu.addItem({ command: 'test' });
830 menu.activeIndex = 0;
831 menu.open(0, 0);
832 menu.node.dispatchEvent(
833 new MouseEvent('mouseup', {
834 bubbles,
835 button: 1
836 })
837 );
838 expect(executed).to.equal('');
839 });
840 });
841
842 context('mousemove', () => {
843 it('should set the active index', () => {
844 menu.addItem({ command: 'test' });
845 menu.open(0, 0);
846 let node = menu.node.getElementsByClassName('lm-Menu-item')[0];
847 let rect = node.getBoundingClientRect();
848 menu.node.dispatchEvent(
849 new MouseEvent('mousemove', {
850 bubbles,
851 clientX: rect.left + 1,
852 clientY: rect.top + 1
853 })
854 );
855 expect(menu.activeIndex).to.equal(0);
856 });
857
858 it('should open a child menu after a timeout', done => {
859 let submenu = new Menu({ commands });
860 submenu.addItem({ command: 'test' });
861 submenu.title.label = 'Test Label';
862 menu.addItem({ type: 'submenu', submenu });
863 menu.open(0, 0);
864 let node = menu.node.getElementsByClassName('lm-Menu-item')[0];
865 let rect = node.getBoundingClientRect();
866 menu.node.dispatchEvent(
867 new MouseEvent('mousemove', {
868 bubbles,
869 clientX: rect.left + 1,
870 clientY: rect.top + 1
871 })
872 );
873 expect(menu.activeIndex).to.equal(0);
874 expect(submenu.isAttached).to.equal(false);
875 setTimeout(() => {
876 expect(submenu.isAttached).to.equal(true);
877 done();
878 }, 500);
879 });
880
881 it('should close an open sub menu', done => {
882 let submenu = new Menu({ commands });
883 submenu.addItem({ command: 'test' });
884 submenu.title.label = 'Test Label';
885 menu.addItem({ command: 'test' });
886 menu.addItem({ type: 'submenu', submenu });
887 menu.open(0, 0);
888 menu.activeIndex = 1;
889 menu.triggerActiveItem();
890 let node = menu.node.getElementsByClassName('lm-Menu-item')[0];
891 let rect = node.getBoundingClientRect();
892 menu.node.dispatchEvent(
893 new MouseEvent('mousemove', {
894 bubbles,
895 clientX: rect.left,
896 clientY: rect.top
897 })
898 );
899 expect(menu.activeIndex).to.equal(0);
900 expect(submenu.isAttached).to.equal(true);
901 setTimeout(() => {
902 expect(submenu.isAttached).to.equal(false);
903 done();
904 }, 500);
905 });
906 });
907
908 context('mouseleave', () => {
909 it('should reset the active index', () => {
910 let submenu = new Menu({ commands });
911 submenu.addItem({ command: 'test' });
912 submenu.title.label = 'Test Label';
913 menu.addItem({ type: 'submenu', submenu });
914 menu.open(0, 0);
915 let node = menu.node.getElementsByClassName('lm-Menu-item')[0];
916 let rect = node.getBoundingClientRect();
917 menu.node.dispatchEvent(
918 new MouseEvent('mousemove', {
919 bubbles,
920 clientX: rect.left + 1,
921 clientY: rect.top + 1
922 })
923 );
924 expect(menu.activeIndex).to.equal(0);
925 menu.node.dispatchEvent(
926 new MouseEvent('mouseleave', {
927 bubbles,
928 clientX: rect.left,
929 clientY: rect.top
930 })
931 );
932 expect(menu.activeIndex).to.equal(-1);
933 menu.dispose();
934 });
935 });
936
937 context('mousedown', () => {
938 it('should not close the menu if on a child node', () => {
939 menu.addItem({ command: 'test' });
940 menu.open(0, 0);
941 expect(menu.isAttached).to.equal(true);
942 let rect = menu.node.getBoundingClientRect();
943 menu.node.dispatchEvent(
944 new MouseEvent('mousedown', {
945 bubbles,
946 clientX: rect.left + 1,
947 clientY: rect.top + 1
948 })
949 );
950 expect(menu.isAttached).to.equal(true);
951 });
952
953 it('should close the menu if not on a child node', () => {
954 menu.addItem({ command: 'test' });
955 menu.open(0, 0);
956 expect(menu.isAttached).to.equal(true);
957 menu.node.dispatchEvent(
958 new MouseEvent('mousedown', {
959 bubbles,
960 clientX: -10
961 })
962 );
963 expect(menu.isAttached).to.equal(false);
964 });
965 });
966 });
967
968 describe('#onBeforeAttach()', () => {
969 it('should add event listeners', () => {
970 let node = logMenu.node;
971 logMenu.open(0, 0);
972 expect(logMenu.methods).to.contain('onBeforeAttach');
973 node.dispatchEvent(new KeyboardEvent('keydown', { bubbles }));
974 expect(logMenu.events).to.contain('keydown');
975 node.dispatchEvent(new MouseEvent('mouseup', { bubbles }));
976 expect(logMenu.events).to.contain('mouseup');
977 node.dispatchEvent(new MouseEvent('mousemove', { bubbles }));
978 expect(logMenu.events).to.contain('mousemove');
979 node.dispatchEvent(new MouseEvent('mouseenter', { bubbles }));
980 expect(logMenu.events).to.contain('mouseenter');
981 node.dispatchEvent(new MouseEvent('mouseleave', { bubbles }));
982 expect(logMenu.events).to.contain('mouseleave');
983 node.dispatchEvent(new MouseEvent('contextmenu', { bubbles }));
984 expect(logMenu.events).to.contain('contextmenu');
985 document.body.dispatchEvent(new MouseEvent('mousedown', { bubbles }));
986 expect(logMenu.events).to.contain('mousedown');
987 });
988 });
989
990 describe('#onAfterDetach()', () => {
991 it('should remove event listeners', () => {
992 let node = logMenu.node;
993 logMenu.open(0, 0);
994 logMenu.close();
995 expect(logMenu.methods).to.contain('onAfterDetach');
996 node.dispatchEvent(new KeyboardEvent('keydown', { bubbles }));
997 expect(logMenu.events).to.not.contain('keydown');
998 node.dispatchEvent(new MouseEvent('mouseup', { bubbles }));
999 expect(logMenu.events).to.not.contain('mouseup');
1000 node.dispatchEvent(new MouseEvent('mousemove', { bubbles }));
1001 expect(logMenu.events).to.not.contain('mousemove');
1002 node.dispatchEvent(new MouseEvent('mouseenter', { bubbles }));
1003 expect(logMenu.events).to.not.contain('mouseenter');
1004 node.dispatchEvent(new MouseEvent('mouseleave', { bubbles }));
1005 expect(logMenu.events).to.not.contain('mouseleave');
1006 node.dispatchEvent(new MouseEvent('contextmenu', { bubbles }));
1007 expect(logMenu.events).to.not.contain('contextmenu');
1008 document.body.dispatchEvent(new MouseEvent('mousedown', { bubbles }));
1009 expect(logMenu.events).to.not.contain('mousedown');
1010 });
1011 });
1012
1013 describe('#onActivateRequest', () => {
1014 it('should focus the menu', done => {
1015 logMenu.open(0, 0);
1016 expect(document.activeElement).to.not.equal(logMenu.node);
1017 expect(logMenu.methods).to.not.contain('onActivateRequest');
1018 requestAnimationFrame(() => {
1019 expect(document.activeElement).to.equal(logMenu.node);
1020 expect(logMenu.methods).to.contain('onActivateRequest');
1021 done();
1022 });
1023 });
1024 });
1025
1026 describe('#onUpdateRequest()', () => {
1027 it('should be called prior to opening', () => {
1028 expect(logMenu.methods).to.not.contain('onUpdateRequest');
1029 logMenu.open(0, 0);
1030 expect(logMenu.methods).to.contain('onUpdateRequest');
1031 });
1032
1033 it('should collapse extra separators', () => {
1034 menu.addItem({ type: 'separator' });
1035 menu.addItem({ command: 'test' });
1036 menu.addItem({ type: 'separator' });
1037 menu.addItem({ type: 'separator' });
1038 menu.addItem({ type: 'submenu', submenu: new Menu({ commands }) });
1039 menu.addItem({ type: 'separator' });
1040 menu.open(0, 0);
1041 let elements = menu.node.querySelectorAll(
1042 '.lm-Menu-item[data-type="separator"'
1043 );
1044 expect(elements.length).to.equal(4);
1045 expect(elements[0].classList.contains('lm-mod-collapsed')).to.equal(
1046 true
1047 );
1048 expect(elements[1].classList.contains('lm-mod-collapsed')).to.equal(
1049 false
1050 );
1051 expect(elements[2].classList.contains('lm-mod-collapsed')).to.equal(
1052 true
1053 );
1054 expect(elements[3].classList.contains('lm-mod-collapsed')).to.equal(
1055 true
1056 );
1057 });
1058 });
1059
1060 describe('#onCloseRequest()', () => {
1061 it('should reset the active index', () => {
1062 menu.addItem({ command: 'test' });
1063 menu.activeIndex = 0;
1064 menu.open(0, 0);
1065 menu.close();
1066 expect(menu.activeIndex).to.equal(-1);
1067 });
1068
1069 it('should close any open child menu', () => {
1070 let submenu = new Menu({ commands });
1071 submenu.addItem({ command: 'test' });
1072 menu.addItem({ type: 'submenu', submenu });
1073 menu.open(0, 0);
1074 menu.activateNextItem();
1075 menu.triggerActiveItem();
1076 expect(menu.childMenu).to.equal(submenu);
1077 expect(submenu.isAttached).equal(true);
1078 menu.close();
1079 expect(menu.childMenu).to.equal(null);
1080 expect(submenu.isAttached).equal(false);
1081 });
1082
1083 it('should remove the menu from its parent and activate the parent', done => {
1084 let submenu = new Menu({ commands });
1085 submenu.addItem({ command: 'test' });
1086 menu.addItem({ type: 'submenu', submenu });
1087 menu.open(0, 0);
1088 menu.activateNextItem();
1089 menu.triggerActiveItem();
1090 expect(menu.childMenu).to.equal(submenu);
1091 expect(submenu.parentMenu).to.equal(menu);
1092 expect(submenu.isAttached).to.equal(true);
1093 submenu.close();
1094 expect(menu.childMenu).to.equal(null);
1095 expect(submenu.parentMenu).to.equal(null);
1096 expect(submenu.isAttached).to.equal(false);
1097 requestAnimationFrame(() => {
1098 expect(document.activeElement).to.equal(menu.node);
1099 done();
1100 });
1101 });
1102
1103 it('should emit the `aboutToClose` signal if attached', () => {
1104 let called = false;
1105 menu.open(0, 0);
1106 menu.aboutToClose.connect((sender, args) => {
1107 expect(sender).to.equal(menu);
1108 expect(args).to.equal(undefined);
1109 called = true;
1110 });
1111 menu.close();
1112 expect(called).to.equal(true);
1113 });
1114 });
1115
1116 describe('.IItem', () => {
1117 describe('#type', () => {
1118 it('should get the type of the menu item', () => {
1119 let item = menu.addItem({ type: 'separator' });
1120 expect(item.type).to.equal('separator');
1121 });
1122
1123 it("should default to `'command'`", () => {
1124 let item = menu.addItem({});
1125 expect(item.type).to.equal('command');
1126 });
1127 });
1128
1129 describe('#command', () => {
1130 it('should get the command to execute when the item is triggered', () => {
1131 let item = menu.addItem({ command: 'foo' });
1132 expect(item.command).to.equal('foo');
1133 });
1134
1135 it('should default to an empty string', () => {
1136 let item = menu.addItem({});
1137 expect(item.command).to.equal('');
1138 });
1139 });
1140
1141 describe('#args', () => {
1142 it('should get the arguments for the command', () => {
1143 let item = menu.addItem({ args: { foo: 1 } });
1144 expect(item.args).to.deep.equal({ foo: 1 });
1145 });
1146
1147 it('should default to an empty object', () => {
1148 let item = menu.addItem({});
1149 expect(item.args).to.deep.equal({});
1150 });
1151 });
1152
1153 describe('#submenu', () => {
1154 it('should get the submenu for the item', () => {
1155 let submenu = new Menu({ commands });
1156 let item = menu.addItem({ submenu });
1157 expect(item.submenu).to.equal(submenu);
1158 });
1159
1160 it('should default to `null`', () => {
1161 let item = menu.addItem({});
1162 expect(item.submenu).to.equal(null);
1163 });
1164 });
1165
1166 describe('#label', () => {
1167 it('should get the label of a command item for a `command` type', () => {
1168 let item = menu.addItem({ command: 'test' });
1169 expect(item.label).to.equal('Test Label');
1170 });
1171
1172 it('should get the title label of a submenu item for a `submenu` type', () => {
1173 let submenu = new Menu({ commands });
1174 submenu.title.label = 'foo';
1175 let item = menu.addItem({ type: 'submenu', submenu });
1176 expect(item.label).to.equal('foo');
1177 });
1178
1179 it('should default to an empty string', () => {
1180 let item = menu.addItem({});
1181 expect(item.label).to.equal('');
1182 item = menu.addItem({ type: 'separator' });
1183 expect(item.label).to.equal('');
1184 });
1185 });
1186
1187 describe('#mnemonic', () => {
1188 it('should get the mnemonic index of a command item for a `command` type', () => {
1189 let item = menu.addItem({ command: 'test' });
1190 expect(item.mnemonic).to.equal(0);
1191 });
1192
1193 it('should get the title mnemonic of a submenu item for a `submenu` type', () => {
1194 let submenu = new Menu({ commands });
1195 submenu.title.mnemonic = 1;
1196 let item = menu.addItem({ type: 'submenu', submenu });
1197 expect(item.mnemonic).to.equal(1);
1198 });
1199
1200 it('should default to `-1`', () => {
1201 let item = menu.addItem({});
1202 expect(item.mnemonic).to.equal(-1);
1203 item = menu.addItem({ type: 'separator' });
1204 expect(item.mnemonic).to.equal(-1);
1205 });
1206 });
1207
1208 describe('#icon', () => {
1209 it('should get the title icon of a submenu item for a `submenu` type', () => {
1210 let submenu = new Menu({ commands });
1211 submenu.title.iconClass = 'bar';
1212 let item = menu.addItem({ type: 'submenu', submenu });
1213 expect(item.iconClass).to.equal('bar');
1214 });
1215
1216 it('should default to undefined', () => {
1217 let item = menu.addItem({});
1218 expect(item.icon).to.equal(undefined);
1219 item = menu.addItem({ type: 'separator' });
1220 expect(item.icon).to.equal(undefined);
1221 });
1222 });
1223
1224 describe('#caption', () => {
1225 it('should get the caption of a command item for a `command` type', () => {
1226 let item = menu.addItem({ command: 'test' });
1227 expect(item.caption).to.equal('Test Caption');
1228 });
1229
1230 it('should get the title caption of a submenu item for a `submenu` type', () => {
1231 let submenu = new Menu({ commands });
1232 submenu.title.caption = 'foo caption';
1233 let item = menu.addItem({ type: 'submenu', submenu });
1234 expect(item.caption).to.equal('foo caption');
1235 });
1236
1237 it('should default to an empty string', () => {
1238 let item = menu.addItem({});
1239 expect(item.caption).to.equal('');
1240 item = menu.addItem({ type: 'separator' });
1241 expect(item.caption).to.equal('');
1242 });
1243 });
1244
1245 describe('#className', () => {
1246 it('should get the extra class name of a command item for a `command` type', () => {
1247 let item = menu.addItem({ command: 'test' });
1248 expect(item.className).to.equal('testClass');
1249 });
1250
1251 it('should get the title extra class name of a submenu item for a `submenu` type', () => {
1252 let submenu = new Menu({ commands });
1253 submenu.title.className = 'fooClass';
1254 let item = menu.addItem({ type: 'submenu', submenu });
1255 expect(item.className).to.equal('fooClass');
1256 });
1257
1258 it('should default to an empty string', () => {
1259 let item = menu.addItem({});
1260 expect(item.className).to.equal('');
1261 item = menu.addItem({ type: 'separator' });
1262 expect(item.className).to.equal('');
1263 });
1264 });
1265
1266 describe('#isEnabled', () => {
1267 it('should get whether the command is enabled for a `command` type', () => {
1268 let item = menu.addItem({ command: 'test-disabled' });
1269 expect(item.isEnabled).to.equal(false);
1270 item = menu.addItem({ type: 'command' });
1271 expect(item.isEnabled).to.equal(false);
1272 item = menu.addItem({ command: 'test' });
1273 expect(item.isEnabled).to.equal(true);
1274 });
1275
1276 it('should get whether there is a submenu for a `submenu` type', () => {
1277 let submenu = new Menu({ commands });
1278 let item = menu.addItem({ type: 'submenu', submenu });
1279 expect(item.isEnabled).to.equal(true);
1280 item = menu.addItem({ type: 'submenu' });
1281 expect(item.isEnabled).to.equal(false);
1282 });
1283
1284 it('should be `true` for a separator item', () => {
1285 let item = menu.addItem({ type: 'separator' });
1286 expect(item.isEnabled).to.equal(true);
1287 });
1288 });
1289
1290 describe('#isToggled', () => {
1291 it('should get whether the command is toggled for a `command` type', () => {
1292 let item = menu.addItem({ command: 'test-toggled' });
1293 expect(item.isToggled).to.equal(true);
1294 item = menu.addItem({ command: 'test' });
1295 expect(item.isToggled).to.equal(false);
1296 item = menu.addItem({ type: 'command' });
1297 expect(item.isToggled).to.equal(false);
1298 });
1299
1300 it('should be `false` for other item types', () => {
1301 let item = menu.addItem({ type: 'separator' });
1302 expect(item.isToggled).to.equal(false);
1303 item = menu.addItem({ type: 'submenu' });
1304 expect(item.isToggled).to.equal(false);
1305 });
1306 });
1307
1308 describe('#isVisible', () => {
1309 it('should get whether the command is visible for a `command` type', () => {
1310 let item = menu.addItem({ command: 'test-hidden' });
1311 expect(item.isVisible).to.equal(false);
1312 item = menu.addItem({ command: 'test' });
1313 expect(item.isVisible).to.equal(true);
1314 });
1315
1316 it('should get whether there is a submenu for a `submenu` type', () => {
1317 let submenu = new Menu({ commands });
1318 let item = menu.addItem({ type: 'submenu', submenu });
1319 expect(item.isVisible).to.equal(true);
1320 item = menu.addItem({ type: 'submenu' });
1321 expect(item.isVisible).to.equal(false);
1322 });
1323
1324 it('should be `true` for a separator item', () => {
1325 let item = menu.addItem({ type: 'separator' });
1326 expect(item.isVisible).to.equal(true);
1327 });
1328 });
1329
1330 describe('#keyBinding', () => {
1331 it('should get the key binding for the menu item', () => {
1332 let item = menu.addItem({ command: 'test' });
1333 expect(item.keyBinding!.keys).to.deep.equal(['Ctrl T']);
1334 });
1335
1336 it('should be `null` for submenus and separators', () => {
1337 let item = menu.addItem({ type: 'separator' });
1338 expect(item.keyBinding).to.equal(null);
1339 item = menu.addItem({ type: 'submenu' });
1340 expect(item.keyBinding).to.equal(null);
1341 });
1342 });
1343 });
1344
1345 describe('.Renderer', () => {
1346 let renderer = new Menu.Renderer();
1347
1348 describe('#renderItem()', () => {
1349 it('should render an item node for the menu', () => {
1350 let item = menu.addItem({ command: 'test' });
1351 let vNode = renderer.renderItem({
1352 item,
1353 active: false,
1354 collapsed: false
1355 });
1356 let node = VirtualDOM.realize(vNode);
1357 expect(node.classList.contains('lm-Menu-item')).to.equal(true);
1358 expect(node.classList.contains('lm-mod-hidden')).to.equal(false);
1359 expect(node.classList.contains('lm-mod-disabled')).to.equal(false);
1360 expect(node.classList.contains('lm-mod-toggled')).to.equal(false);
1361 expect(node.classList.contains('lm-mod-active')).to.equal(false);
1362 expect(node.classList.contains('lm-mod-collapsed')).to.equal(false);
1363 expect(node.getAttribute('data-command')).to.equal('test');
1364 expect(node.getAttribute('data-type')).to.equal('command');
1365 expect(node.querySelector('.lm-Menu-itemIcon')).to.not.equal(null);
1366 expect(node.querySelector('.lm-Menu-itemLabel')).to.not.equal(null);
1367 expect(node.querySelector('.lm-Menu-itemSubmenuIcon')).to.not.equal(
1368 null
1369 );
1370 });
1371
1372 it('should handle the hidden item state', () => {
1373 let item = menu.addItem({ command: 'test-hidden' });
1374 let vNode = renderer.renderItem({
1375 item,
1376 active: false,
1377 collapsed: false
1378 });
1379 let node = VirtualDOM.realize(vNode);
1380 expect(node.classList.contains('lm-mod-hidden')).to.equal(true);
1381 });
1382
1383 it('should handle the disabled item state', () => {
1384 let item = menu.addItem({ command: 'test-disabled' });
1385 let vNode = renderer.renderItem({
1386 item,
1387 active: false,
1388 collapsed: false
1389 });
1390 let node = VirtualDOM.realize(vNode);
1391 expect(node.classList.contains('lm-mod-disabled')).to.equal(true);
1392 });
1393
1394 it('should handle the toggled item state', () => {
1395 let item = menu.addItem({ command: 'test-toggled' });
1396 let vNode = renderer.renderItem({
1397 item,
1398 active: false,
1399 collapsed: false
1400 });
1401 let node = VirtualDOM.realize(vNode);
1402 expect(node.classList.contains('lm-mod-toggled')).to.equal(true);
1403 });
1404
1405 it('should handle the active item state', () => {
1406 let item = menu.addItem({ command: 'test' });
1407 let vNode = renderer.renderItem({
1408 item,
1409 active: true,
1410 collapsed: false
1411 });
1412 let node = VirtualDOM.realize(vNode);
1413 expect(node.classList.contains('lm-mod-active')).to.equal(true);
1414 });
1415
1416 it('should handle the collapsed item state', () => {
1417 let item = menu.addItem({ command: 'test-collapsed' });
1418 let vNode = renderer.renderItem({
1419 item,
1420 active: false,
1421 collapsed: true
1422 });
1423 let node = VirtualDOM.realize(vNode);
1424 expect(node.classList.contains('lm-mod-collapsed')).to.equal(true);
1425 });
1426 });
1427
1428 describe('#renderIcon()', () => {
1429 it('should render the icon node for the menu', () => {
1430 let item = menu.addItem({ command: 'test' });
1431 let vNode = renderer.renderIcon({
1432 item,
1433 active: false,
1434 collapsed: false
1435 });
1436 let node = VirtualDOM.realize(vNode);
1437 expect(node.classList.contains('lm-Menu-itemIcon')).to.equal(true);
1438 expect(node.classList.contains('foo')).to.equal(true);
1439 });
1440 });
1441
1442 describe('#renderLabel()', () => {
1443 it('should render the label node for the menu', () => {
1444 let item = menu.addItem({ command: 'test' });
1445 let vNode = renderer.renderLabel({
1446 item,
1447 active: false,
1448 collapsed: false
1449 });
1450 let node = VirtualDOM.realize(vNode);
1451 let span = '<span class="lm-Menu-itemMnemonic">T</span>est Label';
1452 expect(node.classList.contains('lm-Menu-itemLabel')).to.equal(true);
1453 expect(node.innerHTML).to.equal(span);
1454 });
1455 });
1456
1457 describe('#renderShortcut()', () => {
1458 it('should render the shortcut node for the menu', () => {
1459 let item = menu.addItem({ command: 'test' });
1460 let vNode = renderer.renderShortcut({
1461 item,
1462 active: false,
1463 collapsed: false
1464 });
1465 let node = VirtualDOM.realize(vNode);
1466 expect(node.classList.contains('lm-Menu-itemShortcut')).to.equal(
1467 true
1468 );
1469 if (Platform.IS_MAC) {
1470 expect(node.innerHTML).to.equal('\u2303 T');
1471 } else {
1472 expect(node.innerHTML).to.equal('Ctrl+T');
1473 }
1474 });
1475 });
1476
1477 describe('#renderSubmenu()', () => {
1478 it('should render the submenu icon node for the menu', () => {
1479 let item = menu.addItem({ command: 'test' });
1480 let vNode = renderer.renderSubmenu({
1481 item,
1482 active: false,
1483 collapsed: false
1484 });
1485 let node = VirtualDOM.realize(vNode);
1486 expect(node.classList.contains('lm-Menu-itemSubmenuIcon')).to.equal(
1487 true
1488 );
1489 });
1490 });
1491
1492 describe('#createItemClass()', () => {
1493 it('should create the full class name for the item node', () => {
1494 let item = menu.addItem({ command: 'test' });
1495
1496 let name = renderer.createItemClass({
1497 item,
1498 active: false,
1499 collapsed: false
1500 });
1501 let expected = 'lm-Menu-item testClass';
1502 expect(name).to.equal(expected);
1503
1504 name = renderer.createItemClass({
1505 item,
1506 active: true,
1507 collapsed: false
1508 });
1509 expected = 'lm-Menu-item lm-mod-active testClass';
1510 expect(name).to.equal(expected);
1511
1512 name = renderer.createItemClass({
1513 item,
1514 active: false,
1515 collapsed: true
1516 });
1517 expected = 'lm-Menu-item lm-mod-collapsed testClass';
1518 expect(name).to.equal(expected);
1519
1520 item = menu.addItem({ command: 'test-disabled' });
1521 name = renderer.createItemClass({
1522 item,
1523 active: false,
1524 collapsed: false
1525 });
1526 expected = 'lm-Menu-item lm-mod-disabled testClass';
1527 expect(name).to.equal(expected);
1528
1529 item = menu.addItem({ command: 'test-toggled' });
1530 name = renderer.createItemClass({
1531 item,
1532 active: false,
1533 collapsed: false
1534 });
1535 expected = 'lm-Menu-item lm-mod-toggled testClass';
1536 expect(name).to.equal(expected);
1537
1538 item = menu.addItem({ command: 'test-hidden' });
1539 name = renderer.createItemClass({
1540 item,
1541 active: false,
1542 collapsed: false
1543 });
1544 expected = 'lm-Menu-item lm-mod-hidden testClass';
1545 expect(name).to.equal(expected);
1546
1547 let submenu = new Menu({ commands });
1548 submenu.title.className = 'fooClass';
1549 item = menu.addItem({ type: 'submenu', submenu });
1550 name = renderer.createItemClass({
1551 item,
1552 active: false,
1553 collapsed: false
1554 });
1555 expected = 'lm-Menu-item fooClass';
1556 expect(name).to.equal(expected);
1557 });
1558 });
1559
1560 describe('#createItemDataset()', () => {
1561 it('should create the item dataset', () => {
1562 let item = menu.addItem({ command: 'test' });
1563 let dataset = renderer.createItemDataset({
1564 item,
1565 active: false,
1566 collapsed: false
1567 });
1568 expect(dataset).to.deep.equal({ type: 'command', command: 'test' });
1569
1570 item = menu.addItem({ type: 'separator' });
1571 dataset = renderer.createItemDataset({
1572 item,
1573 active: false,
1574 collapsed: false
1575 });
1576 expect(dataset).to.deep.equal({ type: 'separator' });
1577
1578 let submenu = new Menu({ commands });
1579 item = menu.addItem({ type: 'submenu', submenu });
1580 dataset = renderer.createItemDataset({
1581 item,
1582 active: false,
1583 collapsed: false
1584 });
1585 expect(dataset).to.deep.equal({ type: 'submenu' });
1586 });
1587 });
1588
1589 describe('#createIconClass()', () => {
1590 it('should create the icon class name', () => {
1591 let item = menu.addItem({ command: 'test' });
1592 let name = renderer.createIconClass({
1593 item,
1594 active: false,
1595 collapsed: false
1596 });
1597 let expected = 'lm-Menu-itemIcon foo';
1598 expect(name).to.equal(expected);
1599
1600 item = menu.addItem({ type: 'separator' });
1601 name = renderer.createIconClass({
1602 item,
1603 active: false,
1604 collapsed: false
1605 });
1606 expected = 'lm-Menu-itemIcon';
1607 expect(name).to.equal(expected);
1608
1609 let submenu = new Menu({ commands });
1610 submenu.title.iconClass = 'bar';
1611 item = menu.addItem({ type: 'submenu', submenu });
1612 name = renderer.createIconClass({
1613 item,
1614 active: false,
1615 collapsed: false
1616 });
1617 expected = 'lm-Menu-itemIcon bar';
1618 expect(name).to.equal(expected);
1619 });
1620 });
1621
1622 describe('#formatLabel()', () => {
1623 it('should format the item label', () => {
1624 let item = menu.addItem({ command: 'test' });
1625 let child = renderer.formatLabel({
1626 item,
1627 active: false,
1628 collapsed: false
1629 });
1630 let node = VirtualDOM.realize(h.div(child));
1631 let span = '<span class="lm-Menu-itemMnemonic">T</span>est Label';
1632 expect(node.innerHTML).to.equal(span);
1633
1634 item = menu.addItem({ type: 'separator' });
1635 child = renderer.formatLabel({
1636 item,
1637 active: false,
1638 collapsed: false
1639 });
1640 expect(child).to.equal('');
1641
1642 let submenu = new Menu({ commands });
1643 submenu.title.label = 'Submenu Label';
1644 item = menu.addItem({ type: 'submenu', submenu });
1645 child = renderer.formatLabel({
1646 item,
1647 active: false,
1648 collapsed: false
1649 });
1650 expect(child).to.equal('Submenu Label');
1651 });
1652 });
1653
1654 describe('#formatShortcut()', () => {
1655 it('should format the item shortcut', () => {
1656 let item = menu.addItem({ command: 'test' });
1657 let child = renderer.formatShortcut({
1658 item,
1659 active: false,
1660 collapsed: false
1661 });
1662 if (Platform.IS_MAC) {
1663 expect(child).to.equal('\u2303 T');
1664 } else {
1665 expect(child).to.equal('Ctrl+T');
1666 }
1667 });
1668 });
1669 });
1670 });
1671 });