diff --git a/.eslintrc.js b/.eslintrc.js index 86d7c3840..878ce7764 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -7,56 +7,56 @@ module.exports = { ecmaVersion: 2018, sourceType: 'module', ecmaFeatures: { - legacyDecorators: true - } + legacyDecorators: true, + }, }, - plugins: [ - 'ember' - ], + plugins: ['ember'], extends: [ 'eslint:recommended', 'plugin:ember/recommended', + 'plugin:prettier/recommended', ], env: { - browser: true + browser: true, }, rules: { 'ember/no-jquery': 'error', - 'ember/no-new-mixins': 'warn' + 'ember/no-new-mixins': 'warn', }, overrides: [ // node files { files: [ '.eslintrc.js', + '.prettierrc.js', '.template-lintrc.js', 'ember-cli-build.js', 'index.js', 'testem.js', 'blueprints/*/index.js', 'config/**/*.js', - 'tests/dummy/config/**/*.js' + 'tests/dummy/config/**/*.js', ], excludedFiles: [ 'addon/**', 'addon-test-support/**', 'app/**', - 'tests/dummy/app/**' + 'tests/dummy/app/**', ], parserOptions: { - sourceType: 'script' + sourceType: 'script', }, env: { browser: false, - node: true + node: true, }, plugins: ['node'], - extends: ['plugin:node/recommended'] + extends: ['plugin:node/recommended'], }, { // Test files: files: ['tests/**/*-test.{js,ts}'], extends: ['plugin:qunit/recommended'], - } - ] + }, + ], }; diff --git a/.gitignore b/.gitignore index 744f026cc..87fb30a80 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ # misc /.env* /.pnp* +/.prettierignore /.sass-cache /connect.lock /coverage/ diff --git a/.npmignore b/.npmignore index 2bb849347..25f85d4e4 100644 --- a/.npmignore +++ b/.npmignore @@ -15,6 +15,8 @@ /.git/ /.github/ /.gitignore +/.prettierignore +/.prettierrc.js /.template-lintrc.js /.watchmanconfig /bower.json diff --git a/.prettierrc.js b/.prettierrc.js new file mode 100644 index 000000000..534e6d35a --- /dev/null +++ b/.prettierrc.js @@ -0,0 +1,5 @@ +'use strict'; + +module.exports = { + singleQuote: true, +}; diff --git a/addon-test-support/key-event.js b/addon-test-support/key-event.js index db1a8223b..d4c9fa88e 100644 --- a/addon-test-support/key-event.js +++ b/addon-test-support/key-event.js @@ -14,12 +14,16 @@ export function keyEvent(keyCombo, type, element = document) { keyComboPart = keyComboPart === 'cmd' ? getCmdKey() : keyComboPart; eventProps[`${keyComboPart}Key`] = true; } - + if (type.startsWith('key') && !isValidModifier) { eventProps.code = keyComboPart; } - - if (type.startsWith('mouse') && !isValidModifier && validMouseButtons.indexOf(keyComboPart) > -1) { + + if ( + type.startsWith('mouse') && + !isValidModifier && + validMouseButtons.indexOf(keyComboPart) > -1 + ) { eventProps.button = getMouseCode(keyComboPart); } diff --git a/addon/decorators/key-responder.js b/addon/decorators/key-responder.js index 644588a87..8ac9c5567 100644 --- a/addon/decorators/key-responder.js +++ b/addon/decorators/key-responder.js @@ -6,21 +6,26 @@ function populateKeyboardHandlers(responder) { responder.keyboardHandlerNames = {}; for (let propertyName in responder) { let propertyValue = responder[propertyName]; - if ((typeof propertyValue === 'function') && propertyValue._emberKeyboardOnKeyDecoratorData) { - for (let listenerName of propertyValue._emberKeyboardOnKeyDecoratorData.listenerNames || []) { + if ( + typeof propertyValue === 'function' && + propertyValue._emberKeyboardOnKeyDecoratorData + ) { + for (let listenerName of propertyValue._emberKeyboardOnKeyDecoratorData + .listenerNames || []) { responder.keyboardHandlerNames[listenerName] = propertyName; } } } } - for (let [listenerName, methodName] of Object.entries(responder.keyboardHandlerNames || {})) { - responder.keyboardHandlers[listenerName] = responder[methodName].bind(responder); + for (let [listenerName, methodName] of Object.entries( + responder.keyboardHandlerNames || {} + )) { + responder.keyboardHandlers[listenerName] = + responder[methodName].bind(responder); } } export default function keyResponder(opts = {}) { - - const createClass = function(DecoratedClass) { - + const createClass = function (DecoratedClass) { if (opts.priority === undefined) { opts.priority = 0; } @@ -66,14 +71,14 @@ export default function keyResponder(opts = {}) { this.keyboard.unregister(this); super.willDestroy(...arguments); } - } - } + }; + }; - if (typeof opts === "function") { - return createClass(opts) + if (typeof opts === 'function') { + return createClass(opts); } else { - return function(DecoratedClass) { - return createClass(DecoratedClass) - } + return function (DecoratedClass) { + return createClass(DecoratedClass); + }; } } diff --git a/addon/decorators/on-key.js b/addon/decorators/on-key.js index e07fcddce..1b54cd7e4 100644 --- a/addon/decorators/on-key.js +++ b/addon/decorators/on-key.js @@ -17,21 +17,25 @@ export default function onKey(keyCombo, opts = {}) { function onKeyDecorator(keyCombo, opts) { // ES6 class - return function(target, property, descriptor) { + return function (target, property, descriptor) { if (!Object.prototype.hasOwnProperty.call(target, 'keyboardHandlerNames')) { let parentKeyboardHandlerNames = target.parentKeyboardHandlerNames; // we need to assign because of the way mixins copy actions down when inheriting - target.keyboardHandlerNames = parentKeyboardHandlerNames ? Object.assign({}, parentKeyboardHandlerNames) : {}; + target.keyboardHandlerNames = parentKeyboardHandlerNames + ? Object.assign({}, parentKeyboardHandlerNames) + : {}; } target.keyboardHandlerNames[listenerName(opts.event, keyCombo)] = property; return descriptor; - } + }; } function onKeyClassic(keyCombo, opts, handler) { if (!handler._emberKeyboardOnKeyDecoratorData) { handler._emberKeyboardOnKeyDecoratorData = { listenerNames: [] }; } - handler._emberKeyboardOnKeyDecoratorData.listenerNames.push(listenerName(opts.event, keyCombo)); + handler._emberKeyboardOnKeyDecoratorData.listenerNames.push( + listenerName(opts.event, keyCombo) + ); return handler; } diff --git a/addon/fixtures/key-maps.js b/addon/fixtures/key-maps.js index 1a4cd09c0..4a94598ff 100644 --- a/addon/fixtures/key-maps.js +++ b/addon/fixtures/key-maps.js @@ -1,41 +1,41 @@ export const SHIFT_KEY_MAP = { - 'A': 'a', - 'B': 'b', - 'C': 'c', - 'D': 'd', - 'E': 'e', - 'F': 'f', - 'G': 'g', - 'H': 'h', - 'I': 'i', - 'J': 'j', - 'K': 'k', - 'L': 'l', - 'M': 'm', - 'N': 'n', - 'O': 'o', - 'P': 'p', - 'Q': 'q', - 'R': 'r', - 'S': 's', - 'T': 't', - 'U': 'u', - 'V': 'v', - 'W': 'w', - 'X': 'x', - 'Y': 'y', - 'Z': 'z', + A: 'a', + B: 'b', + C: 'c', + D: 'd', + E: 'e', + F: 'f', + G: 'g', + H: 'h', + I: 'i', + J: 'j', + K: 'k', + L: 'l', + M: 'm', + N: 'n', + O: 'o', + P: 'p', + Q: 'q', + R: 'r', + S: 's', + T: 't', + U: 'u', + V: 'v', + W: 'w', + X: 'x', + Y: 'y', + Z: 'z', '!': '1', '@': '2', '#': '3', - '$': '4', + $: '4', '%': '5', '^': '6', '&': '7', '*': '8', '(': '9', ')': '0', - '_': '-', + _: '-', '+': '=', '<': ',', '>': '.', @@ -45,36 +45,36 @@ export const SHIFT_KEY_MAP = { '~': '`', '{': '[', '}': ']', - '|': '\\' + '|': '\\', }; export const MAC_ALT_KEY_MAP = { - 'å': 'a', - 'b': 'b', - 'ç': 'c', + å: 'a', + b: 'b', + ç: 'c', '∂': 'd', // 'Dead': 'e', - 'ƒ': 'f', + ƒ: 'f', '©': 'g', '˙': 'h', // 'Dead': 'i', '∆': 'j', '˚': 'k', '¬': 'l', - 'µ': 'm', + µ: 'm', // 'Dead': 'n', - 'ø': 'o', - 'π': 'p', - 'œ': 'q', + ø: 'o', + π: 'p', + œ: 'q', '®': 'r', - 'ß': 's', + ß: 's', '†': 't', // 'Dead': 'u', '√': 'v', '∑': 'w', '≈': 'x', '¥': 'y', - 'Ω': 'z', + Ω: 'z', '¡': '1', '™': '2', '£': '3', @@ -83,54 +83,54 @@ export const MAC_ALT_KEY_MAP = { '§': '6', '¶': '7', '•': '8', - 'ª': '9', - 'º': '0', + ª: '9', + º: '0', '–': '-', '≠': '=', '≤': ',', '≥': '.', '÷': '/', '…': ';', - 'æ': "'", + æ: "'", // 'Dead': '`', '“': '[', '‘': ']', - '«': '\\' + '«': '\\', }; export const MAC_SHIFT_ALT_KEY_MAP = { - 'Å': 'a', - 'ı': 'b', + Å: 'a', + ı: 'b', // 'Dead': 'c', - 'Î': 'd', + Î: 'd', // 'Dead': 'e', - 'Ï': 'f', + Ï: 'f', '˝': 'g', - 'Ó': 'h', - 'ˆ': 'i', - 'Ô': 'j', + Ó: 'h', + ˆ: 'i', + Ô: 'j', '': 'k', - 'Ò': 'l', - 'Â': 'm', + Ò: 'l', + Â: 'm', '˜': 'n', - 'Ø': 'o', + Ø: 'o', // 'Dead': 'p', - 'Œ': 'q', + Œ: 'q', '‰': 'r', - 'Í': 's', - 'ˇ': 't', + Í: 's', + ˇ: 't', '¨': 'u', '◊': 'v', '„': 'w', '˛': 'x', - 'Á': 'y', + Á: 'y', '¸': 'z', '⁄': '1', '€': '2', '‹': '3', '›': '4', - 'fi': '5', - 'fl': '6', + fi: '5', + fl: '6', '‡': '7', '°': '8', '·': '9', @@ -140,10 +140,10 @@ export const MAC_SHIFT_ALT_KEY_MAP = { '¯': ',', '˘': '.', '¿': '/', - 'Ú': ';', - 'Æ': "'", + Ú: ';', + Æ: "'", '`': '`', '”': '[', '’': ']', - '»': '\\' + '»': '\\', }; diff --git a/addon/helpers/if-key.js b/addon/helpers/if-key.js index a3a5a3053..d80ebb36b 100644 --- a/addon/helpers/if-key.js +++ b/addon/helpers/if-key.js @@ -3,8 +3,8 @@ import isKey from 'ember-keyboard/utils/is-key'; import listenerName from 'ember-keyboard/utils/listener-name'; import { assert } from '@ember/debug'; -export default helper(function ifKey([keyCombo, callback]/*, hash*/) { - return function(event) { +export default helper(function ifKey([keyCombo, callback] /*, hash*/) { + return function (event) { assert( 'ember-keyboard: You must pass a function as the second argument to the `if-key` helper', typeof callback === 'function' diff --git a/addon/helpers/on-key.js b/addon/helpers/on-key.js index 430d5c85f..b3a0a7169 100644 --- a/addon/helpers/on-key.js +++ b/addon/helpers/on-key.js @@ -12,7 +12,10 @@ export default class extends Helper { eventName = 'keydown'; keyboardHandlers; - compute([keyCombo, callback], { event = 'keydown', activated = true, priority = 0 }) { + compute( + [keyCombo, callback], + { event = 'keydown', activated = true, priority = 0 } + ) { assert( 'ember-keyboard: You must pass a function as the second argument to the `on-key` helper', typeof callback === 'function' diff --git a/addon/index.js b/addon/index.js index 88689cc5a..49ee2515d 100644 --- a/addon/index.js +++ b/addon/index.js @@ -9,11 +9,15 @@ import { default as keyResponder } from 'ember-keyboard/decorators/key-responder import { default as onKey } from 'ember-keyboard/decorators/on-key'; function getCode() { - throw new Error('ember-keyboard: `getCode` has been removed. There is no longer a need for this function as you can directly specify `key` and/or `code` values'); + throw new Error( + 'ember-keyboard: `getCode` has been removed. There is no longer a need for this function as you can directly specify `key` and/or `code` values' + ); } function getKeyCode() { - throw new Error('ember-keyboard: `getKeyCode` has been removed. There is no longer a need for this function as you can directly specify `key` and/or `code` values'); + throw new Error( + 'ember-keyboard: `getKeyCode` has been removed. There is no longer a need for this function as you can directly specify `key` and/or `code` values' + ); } export { @@ -21,17 +25,23 @@ export { EKFirstResponderOnFocusMixin, EKOnFocusMixin, EKOnInsertMixin, - EKOnInitMixin, + EKOnInitMixin, getCode, getKeyCode, getMouseCode, keyResponder, - onKey + onKey, }; - export { keyDown, keyUp, keyPress } from 'ember-keyboard/listeners/key-events'; -export { click, mouseDown, mouseUp } from 'ember-keyboard/listeners/mouse-events'; +export { + click, + mouseDown, + mouseUp, +} from 'ember-keyboard/listeners/mouse-events'; export { touchStart, touchEnd } from 'ember-keyboard/listeners/touch-events'; -export { triggerKeyDown, triggerKeyPress, triggerKeyUp } from 'ember-keyboard/utils/trigger-event'; - +export { + triggerKeyDown, + triggerKeyPress, + triggerKeyUp, +} from 'ember-keyboard/utils/trigger-event'; diff --git a/addon/mixins/activate-keyboard-on-focus.js b/addon/mixins/activate-keyboard-on-focus.js index 298aa68b1..5dc3b935b 100644 --- a/addon/mixins/activate-keyboard-on-focus.js +++ b/addon/mixins/activate-keyboard-on-focus.js @@ -10,22 +10,22 @@ export default Mixin.create({ '`EKOnFocusMixin` of ember-keyboard is deprecated. This behavior is now automatic when using the `on-key` modifier with a text field. For other use cases, implement manually.', false, { - id: 'ember-keyboard.activate-keyboard-on-focus-mixin', - for: 'ember-keyboard', - since: '6.0.2', - until: '7.0.0', - url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#activate-keyboard-on-focus-mixin' + id: 'ember-keyboard.activate-keyboard-on-focus-mixin', + for: 'ember-keyboard', + since: '6.0.2', + until: '7.0.0', + url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#activate-keyboard-on-focus-mixin', } ); return this._super(...args); }, - activateKeyboardWhenFocused: on('click', 'focusIn', function() { + activateKeyboardWhenFocused: on('click', 'focusIn', function () { set(this, 'keyboardActivated', true); }), - deactivateKeyboardWhenFocusOut: on('focusOut', function() { + deactivateKeyboardWhenFocusOut: on('focusOut', function () { set(this, 'keyboardActivated', false); - }) + }), }); diff --git a/addon/mixins/activate-keyboard-on-init.js b/addon/mixins/activate-keyboard-on-init.js index 963ad94c0..0a90c2f79 100644 --- a/addon/mixins/activate-keyboard-on-init.js +++ b/addon/mixins/activate-keyboard-on-init.js @@ -10,18 +10,18 @@ export default Mixin.create({ '`EKOnInitMixin` mixin of ember-keyboard is deprecated. This behavior is now the default when using the @keyResponder decorator.', false, { - id: 'ember-keyboard.activate-keyboard-on-init-mixin', - for: 'ember-keyboard', - since: '6.0.2', - until: '7.0.0', - url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#activate-keyboard-on-init-mixin' + id: 'ember-keyboard.activate-keyboard-on-init-mixin', + for: 'ember-keyboard', + since: '6.0.2', + until: '7.0.0', + url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#activate-keyboard-on-init-mixin', } ); return this._super(...args); }, - activateKeyboardWhenStarted: on('init', function() { + activateKeyboardWhenStarted: on('init', function () { set(this, 'keyboardActivated', true); - }) + }), }); diff --git a/addon/mixins/activate-keyboard-on-insert.js b/addon/mixins/activate-keyboard-on-insert.js index 56c57bb0b..664cc4173 100644 --- a/addon/mixins/activate-keyboard-on-insert.js +++ b/addon/mixins/activate-keyboard-on-insert.js @@ -10,18 +10,18 @@ export default Mixin.create({ '`EKOnInsertMixin` of ember-keyboard is deprecated. You can achieve this behavior by using the `on-key` helper, or by using `@keyResponder` in conjunction with a `did-insert` modifier.', false, { - id: 'ember-keyboard.activate-keyboard-on-insert-mixin', - for: 'ember-keyboard', - since: '6.0.2', - until: '7.0.0', - url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#activate-keyboard-on-insert-mixin' + id: 'ember-keyboard.activate-keyboard-on-insert-mixin', + for: 'ember-keyboard', + since: '6.0.2', + until: '7.0.0', + url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#activate-keyboard-on-insert-mixin', } ); return this._super(...args); }, - activateKeyboardWhenPresent: on('didInsertElement', function() { + activateKeyboardWhenPresent: on('didInsertElement', function () { set(this, 'keyboardActivated', true); - }) + }), }); diff --git a/addon/mixins/ember-keyboard.js b/addon/mixins/ember-keyboard.js index b5758fcb9..7cf57c730 100644 --- a/addon/mixins/ember-keyboard.js +++ b/addon/mixins/ember-keyboard.js @@ -2,7 +2,10 @@ import { inject as service } from '@ember/service'; import Evented from '@ember/object/evented'; import Mixin from '@ember/object/mixin'; -import { getListenerNames, triggerViaLegacyResponderApi } from 'ember-keyboard/utils/handle-key-event'; +import { + getListenerNames, + triggerViaLegacyResponderApi, +} from 'ember-keyboard/utils/handle-key-event'; import { deprecate } from '@ember/debug'; export default Mixin.create(Evented, { @@ -15,11 +18,11 @@ export default Mixin.create(Evented, { '`EKMixin` of ember-keyboard is deprecated. Please use the @keyResponder decorator instead.', false, { - id: 'ember-keyboard.ember-keyboard-mixin', - for: 'ember-keyboard', - since: '6.0.2', - until: '7.0.0', - url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#ember-keyboard-mixin' + id: 'ember-keyboard.ember-keyboard-mixin', + for: 'ember-keyboard', + since: '6.0.2', + until: '7.0.0', + url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#ember-keyboard-mixin', } ); this.keyboard.register(this); @@ -54,5 +57,5 @@ export default Mixin.create(Evented, { handleKeyboardEvent(event, ekEvent) { triggerViaLegacyResponderApi(this, event, ekEvent); - } + }, }); diff --git a/addon/mixins/keyboard-first-responder-on-focus.js b/addon/mixins/keyboard-first-responder-on-focus.js index a81167ccb..6142a531a 100644 --- a/addon/mixins/keyboard-first-responder-on-focus.js +++ b/addon/mixins/keyboard-first-responder-on-focus.js @@ -10,25 +10,25 @@ export default Mixin.create({ '`EKFirstResponderOnFocusMixin` of ember-keyboard is deprecated. This behavior is now the default when using the `on-key` modifier with a text field. For other use cases, implement manually.', false, { - id: 'ember-keyboard.keyboard-first-responder-on-focus-mixin', - for: 'ember-keyboard', - since: '6.0.2', - until: '7.0.0', - url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#keyboard-first-responder-on-focus-mixin' + id: 'ember-keyboard.keyboard-first-responder-on-focus-mixin', + for: 'ember-keyboard', + since: '6.0.2', + until: '7.0.0', + url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#keyboard-first-responder-on-focus-mixin', } ); return this._super(...args); }, - makeFirstResponderOnFocusIn: on('click', 'focusIn', function() { + makeFirstResponderOnFocusIn: on('click', 'focusIn', function () { setProperties(this, { keyboardActivated: true, - keyboardFirstResponder: true + keyboardFirstResponder: true, }); }), - resignFirstResponderOnFocusOut: on('focusOut', function() { + resignFirstResponderOnFocusOut: on('focusOut', function () { set(this, 'keyboardFirstResponder', false); - }) + }), }); diff --git a/addon/modifiers/on-key.js b/addon/modifiers/on-key.js index cebafa46d..d6ba62594 100644 --- a/addon/modifiers/on-key.js +++ b/addon/modifiers/on-key.js @@ -9,7 +9,6 @@ const ONLY_WHEN_FOCUSED_TAG_NAMES = ['input', 'select', 'textarea']; let Klass; if (gte('3.8.0')) { - /* This is an element modifier to trigger some behavior when * specified key combo is pressed. When used with a form element * (input, textarea, or select), the action fires only when element @@ -34,20 +33,25 @@ if (gte('3.8.0')) { onlyWhenFocused = true; listenerName; - didReceiveArguments() { - let [ keyCombo, callback ] = this.args.positional; + let [keyCombo, callback] = this.args.positional; let { activated, event, priority } = this.args.named; this.keyCombo = keyCombo; this.callback = callback; this.eventName = event || 'keydown'; - this.activatedParamValue = Object.keys(this.args.named).includes('activated') ? !!activated : undefined; + this.activatedParamValue = Object.keys(this.args.named).includes( + 'activated' + ) + ? !!activated + : undefined; this.keyboardPriority = priority ? parseInt(priority, 10) : 0; this.listenerName = listenerName(this.eventName, this.keyCombo); if (this.args.named.onlyWhenFocused !== undefined) { this.onlyWhenFocused = this.args.named.onlyWhenFocused; } else { - this.onlyWhenFocused = ONLY_WHEN_FOCUSED_TAG_NAMES.includes(this.element.tagName.toLowerCase()); + this.onlyWhenFocused = ONLY_WHEN_FOCUSED_TAG_NAMES.includes( + this.element.tagName.toLowerCase() + ); } } @@ -74,7 +78,7 @@ if (gte('3.8.0')) { } @action onFocusOut() { - this.isFocused=false; + this.isFocused = false; } get keyboardActivated() { @@ -107,14 +111,15 @@ if (gte('3.8.0')) { } } } - - } + }; } else { Klass = class OnKeyModifier extends Modifier { didInstall() { - throw new Error('ember-keyboard only supports the on-key element modifier in Ember 3.8 and higher.'); + throw new Error( + 'ember-keyboard only supports the on-key element modifier in Ember 3.8 and higher.' + ); } - } + }; } export default Klass; diff --git a/addon/services/keyboard.js b/addon/services/keyboard.js index 67f76549f..d367c56cd 100644 --- a/addon/services/keyboard.js +++ b/addon/services/keyboard.js @@ -3,9 +3,7 @@ import { getOwner } from '@ember/application'; import { action } from '@ember/object'; import { run } from '@ember/runloop'; import { keyDown, keyPress, keyUp } from 'ember-keyboard/listeners/key-events'; -import { - handleKeyEventWithPropagation -} from 'ember-keyboard/utils/handle-key-event'; +import { handleKeyEventWithPropagation } from 'ember-keyboard/utils/handle-key-event'; import { reverseCompareProp } from 'ember-keyboard/utils/sort'; export default class KeyboardService extends Service { @@ -13,7 +11,7 @@ export default class KeyboardService extends Service { get activeResponders() { let { registeredResponders } = this; - return Array.from(registeredResponders).filter(r => r.keyboardActivated); + return Array.from(registeredResponders).filter((r) => r.keyboardActivated); } get sortedResponders() { @@ -23,11 +21,11 @@ export default class KeyboardService extends Service { } get firstResponders() { - return this.sortedResponders.filter(r => r.keyboardFirstResponder); + return this.sortedResponders.filter((r) => r.keyboardFirstResponder); } get normalResponders() { - return this.sortedResponders.filter(r => !r.keyboardFirstResponder); + return this.sortedResponders.filter((r) => !r.keyboardFirstResponder); } constructor(...args) { @@ -37,10 +35,15 @@ export default class KeyboardService extends Service { return; } - const config = getOwner(this).resolveRegistration('config:environment') || {}; + const config = + getOwner(this).resolveRegistration('config:environment') || {}; let emberKeyboardConfig = config.emberKeyboard || {}; - this._listeners = emberKeyboardConfig.listeners || ['keyUp', 'keyDown', 'keyPress']; + this._listeners = emberKeyboardConfig.listeners || [ + 'keyUp', + 'keyDown', + 'keyPress', + ]; this._listeners = this._listeners.map((listener) => listener.toLowerCase()); this._listeners.forEach((type) => { @@ -64,7 +67,10 @@ export default class KeyboardService extends Service { _respond(event) { run(() => { let { firstResponders, normalResponders } = this; - handleKeyEventWithPropagation(event, { firstResponders, normalResponders }); + handleKeyEventWithPropagation(event, { + firstResponders, + normalResponders, + }); }); } diff --git a/addon/utils/get-cmd-key.js b/addon/utils/get-cmd-key.js index acc88405d..13770be1f 100644 --- a/addon/utils/get-cmd-key.js +++ b/addon/utils/get-cmd-key.js @@ -1,4 +1,4 @@ -export default function(platform) { +export default function (platform) { if (typeof FastBoot === 'undefined') { if (platform === undefined) { platform = navigator.platform; diff --git a/addon/utils/get-mouse-code.js b/addon/utils/get-mouse-code.js index 82b0b92c4..0fbc17b1e 100644 --- a/addon/utils/get-mouse-code.js +++ b/addon/utils/get-mouse-code.js @@ -4,8 +4,11 @@ export default function getMouseName(buttonCode) { if (isNone(buttonCode)) return; switch (buttonCode) { - case 'left': return 0; - case 'middle': return 1; - case 'right': return 2; + case 'left': + return 0; + case 'middle': + return 1; + case 'right': + return 2; } } diff --git a/addon/utils/get-mouse-name.js b/addon/utils/get-mouse-name.js index 393882666..d7df4c94a 100644 --- a/addon/utils/get-mouse-name.js +++ b/addon/utils/get-mouse-name.js @@ -4,8 +4,11 @@ export default function getMouseName(buttonCode) { if (isNone(buttonCode)) return; switch (buttonCode) { - case 0: return 'left'; - case 1: return 'middle'; - case 2: return 'right'; + case 0: + return 'left'; + case 1: + return 'middle'; + case 2: + return 'right'; } } diff --git a/addon/utils/handle-key-event.js b/addon/utils/handle-key-event.js index 987260256..f294a8d6c 100644 --- a/addon/utils/handle-key-event.js +++ b/addon/utils/handle-key-event.js @@ -3,7 +3,6 @@ import listenerName from 'ember-keyboard/utils/listener-name'; import isKey from 'ember-keyboard/utils/is-key'; import { deprecate } from '@ember/debug'; - function modifierStrings(event) { if (event instanceof KeyboardEvent) { return ['alt', 'ctrl', 'meta', 'shift'].reduce((result, keyName) => { @@ -18,11 +17,14 @@ function modifierStrings(event) { if (mouseButton) { return [mouseButton]; } - return [] + return []; } } -export function handleKeyEventWithPropagation(event, { firstResponders, normalResponders }) { +export function handleKeyEventWithPropagation( + event, + { firstResponders, normalResponders } +) { let isImmediatePropagationStopped = false; let isPropagationStopped = false; const ekEvent = { @@ -31,8 +33,8 @@ export function handleKeyEventWithPropagation(event, { firstResponders, normalRe }, stopPropagation() { isPropagationStopped = true; - } - } + }, + }; /* eslint-disable no-unused-vars */ for (const responder of firstResponders) { triggerResponderListener(responder, event, ekEvent); @@ -53,7 +55,10 @@ export function handleKeyEventWithPropagation(event, { firstResponders, normalRe for (const responder of normalResponders) { const currentPriorityLevel = Number(responder.keyboardPriority); - if (isImmediatePropagationStopped && currentPriorityLevel === previousPriorityLevel) { + if ( + isImmediatePropagationStopped && + currentPriorityLevel === previousPriorityLevel + ) { continue; } @@ -72,7 +77,10 @@ export function handleKeyEventWithPropagation(event, { firstResponders, normalRe function triggerResponderListener(responder, event, ekEvent = null) { if (responder.handleKeyboardEvent) { - if (responder.canHandleKeyboardEvent && !responder.canHandleKeyboardEvent(event)) { + if ( + responder.canHandleKeyboardEvent && + !responder.canHandleKeyboardEvent(event) + ) { return; } responder.handleKeyboardEvent(event, ekEvent); @@ -97,28 +105,40 @@ function triggerResponderListener(responder, event, ekEvent = null) { 'ember-keyboard registered responders handling events via `trigger(listenerName, event)` is deprecated. A responder should have either `keyboardHandlers` (a property returning a dictionary of listenerNames to handler functions), or `handleKeyboardEvent(event)`.', false, { - id: 'ember-keyboard.responder-trigger', - for: 'ember-keyboard', - since: '6.0.2', - until: '7.0.0', - url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#responder-trigger' + id: 'ember-keyboard.responder-trigger', + for: 'ember-keyboard', + since: '6.0.2', + until: '7.0.0', + url: 'https://adopted-ember-addons.github.io/ember-keyboard/deprecations#responder-trigger', } ); triggerViaLegacyResponderApi(responder, event, ekEvent); return; } - throw new Error('A responder registered with the ember-keyboard service must implement either `keyboardHandlers` (property returning a dictionary of listenerNames to handler functions), or `handleKeyboardEvent(event)`)'); + throw new Error( + 'A responder registered with the ember-keyboard service must implement either `keyboardHandlers` (property returning a dictionary of listenerNames to handler functions), or `handleKeyboardEvent(event)`)' + ); } export function getListenerNames(event) { let result = []; if (event instanceof KeyboardEvent) { if (event.key) { - result.push(listenerName(event.type, modifierStrings(event).concat([event.key]).join('+'))); + result.push( + listenerName( + event.type, + modifierStrings(event).concat([event.key]).join('+') + ) + ); } - if (event.code && (event.key !== event.code)) { - result.push(listenerName(event.type, modifierStrings(event).concat([event.code]).join('+'))); + if (event.code && event.key !== event.code) { + result.push( + listenerName( + event.type, + modifierStrings(event).concat([event.code]).join('+') + ) + ); } } else if (event instanceof MouseEvent) { let modifiers = modifierStrings(event); diff --git a/addon/utils/is-key.js b/addon/utils/is-key.js index e25b43969..7ec7a6215 100644 --- a/addon/utils/is-key.js +++ b/addon/utils/is-key.js @@ -1,19 +1,29 @@ -import KeyboardListener from "./keyboard-listener"; -import getPlatform from "./platform"; -import { SHIFT_KEY_MAP, MAC_ALT_KEY_MAP, MAC_SHIFT_ALT_KEY_MAP } from 'ember-keyboard/fixtures/key-maps'; +import KeyboardListener from './keyboard-listener'; +import getPlatform from './platform'; +import { + SHIFT_KEY_MAP, + MAC_ALT_KEY_MAP, + MAC_SHIFT_ALT_KEY_MAP, +} from 'ember-keyboard/fixtures/key-maps'; import ALL_MODIFIERS from 'ember-keyboard/fixtures/modifiers-array'; import getMouseName from 'ember-keyboard/utils/get-mouse-name'; const ALL_SYMBOL = '_all'; -export default function isKey(listenerOrListenerName, event, platform = getPlatform()) { +export default function isKey( + listenerOrListenerName, + event, + platform = getPlatform() +) { let listener; if (listenerOrListenerName instanceof KeyboardListener) { listener = listenerOrListenerName; } else if (typeof listenerOrListenerName === 'string') { listener = KeyboardListener.parse(listenerOrListenerName, platform); } else { - throw new Error('Expected a `string` or `KeyCombo` as `keyComboOrKeyComboString` argument to `isKey`'); + throw new Error( + 'Expected a `string` or `KeyCombo` as `keyComboOrKeyComboString` argument to `isKey`' + ); } if (listener.type !== event.type) { @@ -24,7 +34,10 @@ export default function isKey(listenerOrListenerName, event, platform = getPlatf return true; } - if (modifiersMatch(listener, event) && (keyOrCodeMatches(listener, event) || mouseButtonMatches(listener, event))) { + if ( + modifiersMatch(listener, event) && + (keyOrCodeMatches(listener, event) || mouseButtonMatches(listener, event)) + ) { return true; } @@ -32,19 +45,23 @@ export default function isKey(listenerOrListenerName, event, platform = getPlatf } function isAll(listener) { - return listener.keyOrCode === ALL_SYMBOL - && listener.altKey === false - && listener.ctrlKey === false - && listener.metaKey === false - && listener.shiftKey === false; + return ( + listener.keyOrCode === ALL_SYMBOL && + listener.altKey === false && + listener.ctrlKey === false && + listener.metaKey === false && + listener.shiftKey === false + ); } function modifiersMatch(listener, keyboardEvent) { - return listener.type === keyboardEvent.type - && listener.altKey === keyboardEvent.altKey - && listener.ctrlKey === keyboardEvent.ctrlKey - && listener.metaKey === keyboardEvent.metaKey - && listener.shiftKey === keyboardEvent.shiftKey; + return ( + listener.type === keyboardEvent.type && + listener.altKey === keyboardEvent.altKey && + listener.ctrlKey === keyboardEvent.ctrlKey && + listener.metaKey === keyboardEvent.metaKey && + listener.shiftKey === keyboardEvent.shiftKey + ); } function keyOrCodeMatches(listener, keyboardEvent) { @@ -54,7 +71,10 @@ function keyOrCodeMatches(listener, keyboardEvent) { if (listener.keyOrCode === ALL_SYMBOL) { return true; } - return listener.keyOrCode === keyboardEvent.code || listener.keyOrCode === keyboardEvent.key; + return ( + listener.keyOrCode === keyboardEvent.code || + listener.keyOrCode === keyboardEvent.key + ); } function mouseButtonMatches(listener, mouseEvent) { @@ -68,24 +88,42 @@ function mouseButtonMatches(listener, mouseEvent) { } function specialCaseMatches(keyboardListener, keyboardEvent, platform) { - if (onlyModifiers([], keyboardListener) && onlyModifiers(['shift'], keyboardEvent)) { + if ( + onlyModifiers([], keyboardListener) && + onlyModifiers(['shift'], keyboardEvent) + ) { return keyboardEvent.key === keyboardListener.keyOrCode; } - if (onlyModifiers(['shift'], keyboardListener) && onlyModifiers(['shift'], keyboardEvent)) { + if ( + onlyModifiers(['shift'], keyboardListener) && + onlyModifiers(['shift'], keyboardEvent) + ) { return rootKeyForShiftKey(keyboardEvent.key) === keyboardListener.keyOrCode; } - if (platform === 'Macintosh' && onlyModifiers(['alt'], keyboardListener) && onlyModifiers(['alt'], keyboardEvent)) { - return rootKeyForMacAltKey(keyboardEvent.key) === keyboardListener.keyOrCode; + if ( + platform === 'Macintosh' && + onlyModifiers(['alt'], keyboardListener) && + onlyModifiers(['alt'], keyboardEvent) + ) { + return ( + rootKeyForMacAltKey(keyboardEvent.key) === keyboardListener.keyOrCode + ); } - if (platform === 'Macintosh' && onlyModifiers(['shift','alt'], keyboardListener) && onlyModifiers(['shift','alt'], keyboardEvent)) { - return rootKeyForMacShiftAltKey(keyboardEvent.key) === keyboardListener.keyOrCode; + if ( + platform === 'Macintosh' && + onlyModifiers(['shift', 'alt'], keyboardListener) && + onlyModifiers(['shift', 'alt'], keyboardEvent) + ) { + return ( + rootKeyForMacShiftAltKey(keyboardEvent.key) === keyboardListener.keyOrCode + ); } return false; } -const ALL_MODIFIERS_EXCEPT_CMD = ALL_MODIFIERS.filter(m => m != 'cmd'); +const ALL_MODIFIERS_EXCEPT_CMD = ALL_MODIFIERS.filter((m) => m != 'cmd'); function onlyModifiers(names, obj) { for (let modifier of ALL_MODIFIERS_EXCEPT_CMD) { if (names.includes(modifier) && !obj[`${modifier}Key`]) { @@ -106,7 +144,6 @@ function rootKeyForMacAltKey(key) { return MAC_ALT_KEY_MAP[key] || key; } - function rootKeyForMacShiftAltKey(key) { return MAC_SHIFT_ALT_KEY_MAP[key] || key; } diff --git a/addon/utils/keyboard-listener.js b/addon/utils/keyboard-listener.js index 8feebe1c1..997b6bc8a 100644 --- a/addon/utils/keyboard-listener.js +++ b/addon/utils/keyboard-listener.js @@ -1,4 +1,4 @@ -import getPlatform from "./platform"; +import getPlatform from './platform'; const ALT_REGEX = /^alt$/i; const SHIFT_REGEX = /^shift$/i; @@ -52,16 +52,22 @@ export default class KeyboardListener { } createMatchingKeyboardEvent(opts = {}) { - return new KeyboardEvent(this.type, Object.assign({ - // one of these next two will be incorrect. For test usage, if usually - // doesn't matter, but you can pass in correct values via opts if needed. - key: this.keyOrCode, - code: this.keyOrCode, + return new KeyboardEvent( + this.type, + Object.assign( + { + // one of these next two will be incorrect. For test usage, if usually + // doesn't matter, but you can pass in correct values via opts if needed. + key: this.keyOrCode, + code: this.keyOrCode, - altKey: this.altKey, - ctrlKey: this.ctrlKey, - metaKey: this.metaKey, - shiftKey: this.shiftKey - }, opts)); + altKey: this.altKey, + ctrlKey: this.ctrlKey, + metaKey: this.metaKey, + shiftKey: this.shiftKey, + }, + opts + ) + ); } } diff --git a/addon/utils/platform.js b/addon/utils/platform.js index 7c5705ea6..e8f387364 100644 --- a/addon/utils/platform.js +++ b/addon/utils/platform.js @@ -9,13 +9,13 @@ export default function getPlatform(userAgent = navigator.userAgent) { }); if (!platform) { - let osName = "Unknown OS"; - if (userAgent.indexOf("Win") != -1) osName = "Windows"; - if (userAgent.indexOf("Mac") != -1) osName = "Macintosh"; - if (userAgent.indexOf("Linux") != -1) osName = "Linux"; - if (userAgent.indexOf("Android") != -1) osName = "Android"; - if (userAgent.indexOf("like Mac") != -1) osName = "iOS"; + let osName = 'Unknown OS'; + if (userAgent.indexOf('Win') != -1) osName = 'Windows'; + if (userAgent.indexOf('Mac') != -1) osName = 'Macintosh'; + if (userAgent.indexOf('Linux') != -1) osName = 'Linux'; + if (userAgent.indexOf('Android') != -1) osName = 'Android'; + if (userAgent.indexOf('like Mac') != -1) osName = 'iOS'; platform = osName; } return platform; -} \ No newline at end of file +} diff --git a/addon/utils/trigger-event.js b/addon/utils/trigger-event.js index e8c2be465..6b94758e1 100644 --- a/addon/utils/trigger-event.js +++ b/addon/utils/trigger-event.js @@ -18,8 +18,4 @@ const triggerKeyUp = function triggerKeyUp(keyCombo, element = document) { triggerKeyEvent('keyup', keyCombo, element); }; -export { - triggerKeyDown, - triggerKeyPress, - triggerKeyUp -}; +export { triggerKeyDown, triggerKeyPress, triggerKeyUp }; diff --git a/config/ember-try.js b/config/ember-try.js index 7e679a624..b640349ea 100644 --- a/config/ember-try.js +++ b/config/ember-try.js @@ -2,7 +2,7 @@ const getChannelURL = require('ember-source-channel-url'); -module.exports = async function() { +module.exports = async function () { return { useYarn: true, scenarios: [ @@ -14,8 +14,8 @@ module.exports = async function() { 'ember-on-modifier': '^1.0.1', 'ember-source': '~3.8.0', 'ember-test-selectors': '^5.5.0', - } - } + }, + }, }, { name: 'ember-lts-3.12', @@ -23,77 +23,77 @@ module.exports = async function() { devDependencies: { 'ember-cli': '~3.12.0', 'ember-source': '~3.12.0', - } - } + }, + }, }, { name: 'ember-lts-3.16', npm: { devDependencies: { - 'ember-source': '~3.16.0' - } - } + 'ember-source': '~3.16.0', + }, + }, }, { name: 'ember-lts-3.20', npm: { devDependencies: { - 'ember-source': '~3.20.5' - } - } + 'ember-source': '~3.20.5', + }, + }, }, { name: 'ember-lts-3.24', npm: { devDependencies: { - 'ember-source': '~3.24.6' - } - } + 'ember-source': '~3.24.6', + }, + }, }, { name: 'ember-lts-3.28', npm: { devDependencies: { - 'ember-source': '~3.28.6' - } - } + 'ember-source': '~3.28.6', + }, + }, }, { name: 'ember-release', npm: { devDependencies: { - 'ember-source': await getChannelURL('release') - } - } + 'ember-source': await getChannelURL('release'), + }, + }, }, { name: 'ember-beta', npm: { devDependencies: { 'ember-source': await getChannelURL('beta'), - } - } + }, + }, }, { name: 'ember-canary', npm: { devDependencies: { 'ember-source': await getChannelURL('canary'), - } - } + }, + }, }, { name: 'ember-default-with-jquery', env: { EMBER_OPTIONAL_FEATURES: JSON.stringify({ - 'jquery-integration': true - }) + 'jquery-integration': true, + }), }, npm: { devDependencies: { - '@ember/jquery': '^1.1.0' - } - } + '@ember/jquery': '^1.1.0', + }, + }, }, { name: 'ember-classic', @@ -101,15 +101,15 @@ module.exports = async function() { EMBER_OPTIONAL_FEATURES: JSON.stringify({ 'application-template-wrapper': true, 'default-async-observers': false, - 'template-only-glimmer-components': false - }) + 'template-only-glimmer-components': false, + }), }, npm: { ember: { - edition: 'classic' - } - } - } - ] + edition: 'classic', + }, + }, + }, + ], }; }; diff --git a/config/environment.js b/config/environment.js index 0dfaed472..331ab30df 100644 --- a/config/environment.js +++ b/config/environment.js @@ -1,5 +1,5 @@ 'use strict'; -module.exports = function(/* environment, appConfig */) { - return { }; +module.exports = function (/* environment, appConfig */) { + return {}; }; diff --git a/ember-cli-build.js b/ember-cli-build.js index 30d9935e4..ba537017b 100644 --- a/ember-cli-build.js +++ b/ember-cli-build.js @@ -2,20 +2,18 @@ const EmberAddon = require('ember-cli/lib/broccoli/ember-addon'); -module.exports = function(defaults) { +module.exports = function (defaults) { let app = new EmberAddon(defaults, { babel: { - plugins: ['@babel/plugin-proposal-object-rest-spread'] + plugins: ['@babel/plugin-proposal-object-rest-spread'], }, 'ember-cli-babel': { includePolyfill: true, - plugins: [ - '@babel/plugin-proposal-object-rest-spread' - ] + plugins: ['@babel/plugin-proposal-object-rest-spread'], }, 'ember-test-selectors': { - strip: false - } + strip: false, + }, }); app.import('node_modules/highlightjs/styles/github-gist.css'); diff --git a/index.js b/index.js index a2168f8eb..979a62839 100644 --- a/index.js +++ b/index.js @@ -6,14 +6,18 @@ module.exports = { config(environment, appConfig) { const addonConfig = appConfig['emberKeyboard'] || {}; - if ('disableInputsInitializer' in addonConfig && !this.disableInputsInitializerDeprecationPrinted) { + if ( + 'disableInputsInitializer' in addonConfig && + !this.disableInputsInitializerDeprecationPrinted + ) { // Do not print deprecation message multiple times // as this hook may be invoked more than once. this.disableInputsInitializerDeprecationPrinted = true; this.ui.writeDeprecateLine( '[ember-keyboard] The `emberKeyboard.disableInputsInitializer` option is obsolete. ' + - 'You can remove it from your `config/environment.js` file.', false + 'You can remove it from your `config/environment.js` file.', + false ); } @@ -24,7 +28,8 @@ module.exports = { this.ui.writeDeprecateLine( '[ember-keyboard] The `emberKeyboard.propagation` option is obsolete. ' + - 'You can remove it from your `config/environment.js` file.', false + 'You can remove it from your `config/environment.js` file.', + false ); } }, diff --git a/package.json b/package.json index e273f496e..6cb8674ed 100644 --- a/package.json +++ b/package.json @@ -64,12 +64,15 @@ "ember-template-lint": "^3.4.2", "ember-test-selectors": "^6.0.0", "ember-try": "^2.0.0", - "eslint": "^7.27.0", + "eslint": "^7.32.0", + "eslint-config-prettier": "^8.3.0", "eslint-plugin-ember": "^10.4.2", "eslint-plugin-node": "^11.1.0", + "eslint-plugin-prettier": "^4.0.0", "eslint-plugin-qunit": "^7.0.0", "highlightjs": "^9.16.2", "loader.js": "^4.7.0", + "prettier": "^2.4.1", "marked": "^4.0.4", "npm-run-all": "^4.1.5", "qunit": "^2.17.2", diff --git a/testem.js b/testem.js index 49f53feed..ed2f37124 100644 --- a/testem.js +++ b/testem.js @@ -3,12 +3,8 @@ module.exports = { test_page: 'tests/index.html?hidepassed', disable_watching: true, - launch_in_ci: [ - 'Chrome' - ], - launch_in_dev: [ - 'Chrome' - ], + launch_in_ci: ['Chrome'], + launch_in_dev: ['Chrome'], browser_start_timeout: 120, browser_args: { Chrome: { @@ -20,8 +16,8 @@ module.exports = { '--disable-software-rasterizer', '--mute-audio', '--remote-debugging-port=0', - '--window-size=1440,900' - ].filter(Boolean) - } - } + '--window-size=1440,900', + ].filter(Boolean), + }, + }, }; diff --git a/tests/acceptance/deprecated/keyboard-test.js b/tests/acceptance/deprecated/keyboard-test.js index 15a2c06ed..8d32d2005 100644 --- a/tests/acceptance/deprecated/keyboard-test.js +++ b/tests/acceptance/deprecated/keyboard-test.js @@ -2,65 +2,66 @@ import { visit } from '@ember/test-helpers'; import { setupApplicationTest } from 'ember-qunit'; import { module, test } from 'qunit'; -import { keyDown, keyUp, keyPress } from 'ember-keyboard/test-support/test-helpers'; +import { + keyDown, + keyUp, + keyPress, +} from 'ember-keyboard/test-support/test-helpers'; import { textChanged } from '../../helpers/text-changed'; // Test using deprecated APIs -module('Acceptance | ember keyboard | deprecated | keyboard', function(hooks) { +module('Acceptance | ember keyboard | deprecated | keyboard', function (hooks) { setupApplicationTest(hooks); - hooks.beforeEach(async function() { + hooks.beforeEach(async function () { await visit('/test-scenario/deprecated/keyboard'); }); - module('keyDown', function() { - module('Arrow keys', function() { - test('Left is pressed', async function(assert) { + module('keyDown', function () { + module('Arrow keys', function () { + test('Left is pressed', async function (assert) { assert.expect(2); - await textChanged(assert, - () => keyDown('ArrowLeft'), { - selectorName: 'counter-counter', - beforeValue: '0', - afterValue: '-1', - }); + await textChanged(assert, () => keyDown('ArrowLeft'), { + selectorName: 'counter-counter', + beforeValue: '0', + afterValue: '-1', + }); }); }); }); - module('keyUp', function() { - module('Letters are pressed', function() { - module('R is configured to reset the counter', function(hooks) { - hooks.beforeEach(async function() { + module('keyUp', function () { + module('Letters are pressed', function () { + module('R is configured to reset the counter', function (hooks) { + hooks.beforeEach(async function () { await keyDown('ArrowRight'); }); - test('the counter is cleared', async function(assert) { + test('the counter is cleared', async function (assert) { assert.expect(2); - await textChanged(assert, - () => keyUp('KeyR'), { - selectorName: 'counter-counter', - beforeValue: '1', - afterValue: '0' - }); + await textChanged(assert, () => keyUp('KeyR'), { + selectorName: 'counter-counter', + beforeValue: '1', + afterValue: '0', + }); }); }); }); }); - module('keyPress', function() { - module('Numbers are pressed', function() { - test('pressing 5 sets the the counter', async function(assert) { + module('keyPress', function () { + module('Numbers are pressed', function () { + test('pressing 5 sets the the counter', async function (assert) { assert.expect(2); - await textChanged(assert, - () => keyPress('Digit5'), { - selectorName: 'counter-counter', - beforeValue: '0', - afterValue: '5' - }); + await textChanged(assert, () => keyPress('Digit5'), { + selectorName: 'counter-counter', + beforeValue: '0', + afterValue: '5', + }); }); }); }); diff --git a/tests/acceptance/deprecated/mouse-down-test.js b/tests/acceptance/deprecated/mouse-down-test.js index 2348fc706..10d94c7ee 100644 --- a/tests/acceptance/deprecated/mouse-down-test.js +++ b/tests/acceptance/deprecated/mouse-down-test.js @@ -6,82 +6,91 @@ import { mouseDown } from 'ember-keyboard/test-support/test-helpers'; import { textChanged } from '../../helpers/text-changed'; -module('Acceptance | ember keyboard | deprecated | mouseDown', function(hooks) { - setupApplicationTest(hooks); +module( + 'Acceptance | ember keyboard | deprecated | mouseDown', + function (hooks) { + setupApplicationTest(hooks); - hooks.beforeEach(async function() { - await visit('/test-scenario/deprecated/mouse-down'); - }); - - module('left clicking', function() { - test('clicking once adjusts the counter by 1', async function(assert) { - assert.expect(2); - - await textChanged(assert, - () => mouseDown('left'), { - selectorName: 'mouse-down-counter', - beforeValue: '0', - afterValue: '1', - }); + hooks.beforeEach(async function () { + await visit('/test-scenario/deprecated/mouse-down'); }); - test('clicking twice adjusts the counter by 1', async function(assert) { - assert.expect(2); + module('left clicking', function () { + test('clicking once adjusts the counter by 1', async function (assert) { + assert.expect(2); - await textChanged(assert, - () => mouseDown('left') && mouseDown('left'), { + await textChanged(assert, () => mouseDown('left'), { selectorName: 'mouse-down-counter', beforeValue: '0', - afterValue: '2', + afterValue: '1', }); + }); + + test('clicking twice adjusts the counter by 1', async function (assert) { + assert.expect(2); + + await textChanged( + assert, + () => mouseDown('left') && mouseDown('left'), + { + selectorName: 'mouse-down-counter', + beforeValue: '0', + afterValue: '2', + } + ); + }); }); - }); - module('middle clicking', function() { - test('clicking once adjusts the counter by 1', async function(assert) { - assert.expect(2); + module('middle clicking', function () { + test('clicking once adjusts the counter by 1', async function (assert) { + assert.expect(2); - await textChanged(assert, - () => mouseDown('middle'), { + await textChanged(assert, () => mouseDown('middle'), { selectorName: 'mouse-down-counter', beforeValue: '0', afterValue: '-10', }); + }); + + test('clicking twice adjusts the counter by 1', async function (assert) { + assert.expect(2); + + await textChanged( + assert, + () => mouseDown('middle') && mouseDown('middle'), + { + selectorName: 'mouse-down-counter', + beforeValue: '0', + afterValue: '-20', + } + ); + }); }); - test('clicking twice adjusts the counter by 1', async function(assert) { - assert.expect(2); + module('right clicking', function () { + test('clicking once adjusts the counter by 1', async function (assert) { + assert.expect(2); - await textChanged(assert, - () => mouseDown('middle') && mouseDown('middle'), { - selectorName: 'mouse-down-counter', - beforeValue: '0', - afterValue: '-20', - }); - }); - }); - - module('right clicking', function() { - test('clicking once adjusts the counter by 1', async function(assert) { - assert.expect(2); - - await textChanged(assert, - () => mouseDown('right'), { + await textChanged(assert, () => mouseDown('right'), { selectorName: 'mouse-down-counter', beforeValue: '0', afterValue: '10', }); + }); + + test('clicking twice adjusts the counter by 1', async function (assert) { + assert.expect(2); + + await textChanged( + assert, + () => mouseDown('right') && mouseDown('right'), + { + selectorName: 'mouse-down-counter', + beforeValue: '0', + afterValue: '20', + } + ); + }); }); - - test('clicking twice adjusts the counter by 1', async function(assert) { - assert.expect(2); - - await textChanged(assert, - () => mouseDown('right') && mouseDown('right'), { - selectorName: 'mouse-down-counter', - beforeValue: '0', - afterValue: '20', - }); - }); - }); -}); + } +); diff --git a/tests/acceptance/deprecated/touch-test.js b/tests/acceptance/deprecated/touch-test.js index f3fb69b4e..f163cddc3 100644 --- a/tests/acceptance/deprecated/touch-test.js +++ b/tests/acceptance/deprecated/touch-test.js @@ -6,35 +6,32 @@ import { touchStart } from 'ember-keyboard/test-support/test-helpers'; import { textChanged } from '../../helpers/text-changed'; -module('Acceptance | ember keyboard | deprecated | touch', function(hooks) { +module('Acceptance | ember keyboard | deprecated | touch', function (hooks) { setupApplicationTest(hooks); - hooks.beforeEach(async function() { + hooks.beforeEach(async function () { await visit('/test-scenario/deprecated/touch'); }); - module('start touching', function() { - - test('increases the touch counter once', async function(assert) { + module('start touching', function () { + test('increases the touch counter once', async function (assert) { assert.expect(2); - await textChanged(assert, - () => touchStart(), { - selectorName: 'touch-start-counter', - beforeValue: '0', - afterValue: '1', - }); + await textChanged(assert, () => touchStart(), { + selectorName: 'touch-start-counter', + beforeValue: '0', + afterValue: '1', + }); }); - test('increases the touch counter twice', async function(assert) { + test('increases the touch counter twice', async function (assert) { assert.expect(2); - await textChanged(assert, - () => touchStart() && touchStart(), { - selectorName: 'touch-start-counter', - beforeValue: '0', - afterValue: '2', - }); + await textChanged(assert, () => touchStart() && touchStart(), { + selectorName: 'touch-start-counter', + beforeValue: '0', + afterValue: '2', + }); }); }); }); diff --git a/tests/acceptance/ember-keyboard-test.js b/tests/acceptance/ember-keyboard-test.js index 55532a86d..52b93724b 100644 --- a/tests/acceptance/ember-keyboard-test.js +++ b/tests/acceptance/ember-keyboard-test.js @@ -5,19 +5,24 @@ import { gte } from 'ember-compatibility-helpers'; import { mouseDown, - keyUp, keyDown, - touchStart + keyUp, + keyDown, + touchStart, } from 'ember-keyboard/test-support/test-helpers'; import { hook } from '../helpers/hook'; -import { getValues, getMouseValues, getTouchValues } from '../helpers/get-values'; +import { + getValues, + getMouseValues, + getTouchValues, +} from '../helpers/get-values'; -module('Acceptance | ember keyboard', function(hooks) { +module('Acceptance | ember keyboard', function (hooks) { setupApplicationTest(hooks); if (gte('3.10.0')) { - test('test standard functionality', async function(assert) { + test('test standard functionality', async function (assert) { assert.expect(8); await visit('/test-scenario'); @@ -37,10 +42,16 @@ module('Acceptance | ember keyboard', function(hooks) { await keyDown('ArrowRight'); assert.deepEqual(getValues(), [1, 1, 1], 'equal responders all respond'); - await click(`${hook('counter-first')} ${hook('counter-activated-toggle')}`); + await click( + `${hook('counter-first')} ${hook('counter-activated-toggle')}` + ); await keyDown('ArrowRight'); - assert.deepEqual(getValues(), [1, 2, 2], 'deactivating a responder removes it from the stack'); + assert.deepEqual( + getValues(), + [1, 2, 2], + 'deactivating a responder removes it from the stack' + ); await keyDown('ArrowRight+ctrl+shift'); assert.deepEqual(getValues(), [1, 102, 102], 'modifier keys work'); @@ -49,49 +60,104 @@ module('Acceptance | ember keyboard', function(hooks) { assert.deepEqual(getValues(), [1, 0, 0], 'keyUp works'); }); - test('test event propagation', async function(assert) { + test('test event propagation', async function (assert) { assert.expect(6); await visit('/test-scenario'); await keyDown('ArrowRight'); assert.deepEqual(getValues(), [1, 1, 1], 'equal responders all respond'); - await fillIn(`${hook('counter-first')} ${hook('counter-priority-input')}`, '1'); + await fillIn( + `${hook('counter-first')} ${hook('counter-priority-input')}`, + '1' + ); await blur(`${hook('counter-first')} ${hook('counter-priority-input')}`); await keyDown('ArrowRight'); - assert.deepEqual(getValues(), [2, 2, 2], 'highest responder responds first, lower responders follow'); - - await fillIn(`${hook('counter-second')} ${hook('counter-priority-input')}`, '1'); + assert.deepEqual( + getValues(), + [2, 2, 2], + 'highest responder responds first, lower responders follow' + ); + + await fillIn( + `${hook('counter-second')} ${hook('counter-priority-input')}`, + '1' + ); await blur(`${hook('counter-second')} ${hook('counter-priority-input')}`); - await click(`${hook('counter-first')} ${hook('counter-stop-immediate-propagation-toggle')}`); + await click( + `${hook('counter-first')} ${hook( + 'counter-stop-immediate-propagation-toggle' + )}` + ); await keyDown('ArrowRight'); - assert.deepEqual(getValues(), [3, 2, 3], 'highest responder responds first and stops immediate propagation, lower responders follow'); - - await click(`${hook('counter-first')} ${hook('counter-stop-immediate-propagation-toggle')}`); - await click(`${hook('counter-first')} ${hook('counter-stop-propagation-toggle')}`); + assert.deepEqual( + getValues(), + [3, 2, 3], + 'highest responder responds first and stops immediate propagation, lower responders follow' + ); + + await click( + `${hook('counter-first')} ${hook( + 'counter-stop-immediate-propagation-toggle' + )}` + ); + await click( + `${hook('counter-first')} ${hook('counter-stop-propagation-toggle')}` + ); await keyDown('ArrowRight'); - assert.deepEqual(getValues(), [4, 3, 3], 'highest responders responds first and block propagation to lower priority responders'); + assert.deepEqual( + getValues(), + [4, 3, 3], + 'highest responders responds first and block propagation to lower priority responders' + ); - await click(`${hook('counter-first')} ${hook('counter-activated-toggle')}`); + await click( + `${hook('counter-first')} ${hook('counter-activated-toggle')}` + ); await keyDown('ArrowRight'); - assert.deepEqual(getValues(), [4, 4, 4], 'deactivating a responder removes it from the stack, deactivated responders do not block propagation'); - - await fillIn(`${hook('counter-first')} ${hook('counter-priority-input')}`, '2'); + assert.deepEqual( + getValues(), + [4, 4, 4], + 'deactivating a responder removes it from the stack, deactivated responders do not block propagation' + ); + + await fillIn( + `${hook('counter-first')} ${hook('counter-priority-input')}`, + '2' + ); await blur(`${hook('counter-first')} ${hook('counter-priority-input')}`); - await click(`${hook('counter-first')} ${hook('counter-stop-propagation-toggle')}`); - await click(`${hook('counter-first')} ${hook('counter-activated-toggle')}`); - await click(`${hook('counter-first')} ${hook('counter-first-responder-toggle')}`); - await click(`${hook('counter-second')} ${hook('counter-first-responder-toggle')}`); - await click(`${hook('counter-second')} ${hook('counter-stop-immediate-propagation-toggle')}`); - - await click(`${hook('counter-third')} ${hook('counter-first-responder-toggle')}`); + await click( + `${hook('counter-first')} ${hook('counter-stop-propagation-toggle')}` + ); + await click( + `${hook('counter-first')} ${hook('counter-activated-toggle')}` + ); + await click( + `${hook('counter-first')} ${hook('counter-first-responder-toggle')}` + ); + await click( + `${hook('counter-second')} ${hook('counter-first-responder-toggle')}` + ); + await click( + `${hook('counter-second')} ${hook( + 'counter-stop-immediate-propagation-toggle' + )}` + ); + + await click( + `${hook('counter-third')} ${hook('counter-first-responder-toggle')}` + ); await keyDown('ArrowRight'); - assert.deepEqual(getValues(), [5, 5, 4], 'first responders get called in priority order.'); + assert.deepEqual( + getValues(), + [5, 5, 4], + 'first responders get called in priority order.' + ); }); } }); diff --git a/tests/acceptance/keyboard-test.js b/tests/acceptance/keyboard-test.js index 1c0fd24e7..141fe2a6b 100644 --- a/tests/acceptance/keyboard-test.js +++ b/tests/acceptance/keyboard-test.js @@ -1,66 +1,66 @@ import { visit } from '@ember/test-helpers'; import { setupApplicationTest } from 'ember-qunit'; import { module, test } from 'qunit'; -import { keyDown, keyUp, keyPress } from 'ember-keyboard/test-support/test-helpers'; +import { + keyDown, + keyUp, + keyPress, +} from 'ember-keyboard/test-support/test-helpers'; import { textChanged } from '../helpers/text-changed'; import { gte } from 'ember-compatibility-helpers'; -module('Acceptance | ember keyboard | keyboard', function(hooks) { +module('Acceptance | ember keyboard | keyboard', function (hooks) { setupApplicationTest(hooks); if (gte('3.10.0')) { - - hooks.beforeEach(async function() { + hooks.beforeEach(async function () { await visit('/test-scenario/keyboard'); }); - module('keyDown', function() { - module('Arrow keys', function() { - test('Left is pressed', async function(assert) { + module('keyDown', function () { + module('Arrow keys', function () { + test('Left is pressed', async function (assert) { assert.expect(2); - await textChanged(assert, - () => keyDown('ArrowLeft'), { - selectorName: 'counter-counter', - beforeValue: '0', - afterValue: '-1', - }); + await textChanged(assert, () => keyDown('ArrowLeft'), { + selectorName: 'counter-counter', + beforeValue: '0', + afterValue: '-1', + }); }); }); }); - module('keyUp', function() { - module('Letters are pressed', function() { - module('R is configured to reset the counter', function(hooks) { - hooks.beforeEach(async function() { + module('keyUp', function () { + module('Letters are pressed', function () { + module('R is configured to reset the counter', function (hooks) { + hooks.beforeEach(async function () { await keyDown('ArrowRight'); }); - test('the counter is cleared', async function(assert) { + test('the counter is cleared', async function (assert) { assert.expect(2); - await textChanged(assert, - () => keyUp('KeyR'), { - selectorName: 'counter-counter', - beforeValue: '1', - afterValue: '0' - }); + await textChanged(assert, () => keyUp('KeyR'), { + selectorName: 'counter-counter', + beforeValue: '1', + afterValue: '0', + }); }); }); }); }); - module('keyPress', function() { - module('Numbers are pressed', function() { - test('pressing 5 sets the the counter', async function(assert) { + module('keyPress', function () { + module('Numbers are pressed', function () { + test('pressing 5 sets the the counter', async function (assert) { assert.expect(2); - await textChanged(assert, - () => keyPress('Digit5'), { - selectorName: 'counter-counter', - beforeValue: '0', - afterValue: '5' - }); + await textChanged(assert, () => keyPress('Digit5'), { + selectorName: 'counter-counter', + beforeValue: '0', + afterValue: '5', + }); }); }); }); diff --git a/tests/acceptance/mouse-down-test.js b/tests/acceptance/mouse-down-test.js index c044dc155..01afcf396 100644 --- a/tests/acceptance/mouse-down-test.js +++ b/tests/acceptance/mouse-down-test.js @@ -5,84 +5,89 @@ import { mouseDown } from 'ember-keyboard/test-support/test-helpers'; import { textChanged } from '../helpers/text-changed'; import { gte } from 'ember-compatibility-helpers'; -module('Acceptance | ember keyboard | mouseDown', function(hooks) { +module('Acceptance | ember keyboard | mouseDown', function (hooks) { setupApplicationTest(hooks); if (gte('3.10.0')) { - - hooks.beforeEach(async function() { + hooks.beforeEach(async function () { await visit('/test-scenario/mouse-down'); }); - module('left clicking', function() { - test('clicking once adjusts the counter by 1', async function(assert) { + module('left clicking', function () { + test('clicking once adjusts the counter by 1', async function (assert) { assert.expect(2); - await textChanged(assert, - () => mouseDown('left'), { - selectorName: 'mouse-down-counter', - beforeValue: '0', - afterValue: '1', - }); + await textChanged(assert, () => mouseDown('left'), { + selectorName: 'mouse-down-counter', + beforeValue: '0', + afterValue: '1', + }); }); - test('clicking twice adjusts the counter by 1', async function(assert) { + test('clicking twice adjusts the counter by 1', async function (assert) { assert.expect(2); - await textChanged(assert, - () => mouseDown('left') && mouseDown('left'), { + await textChanged( + assert, + () => mouseDown('left') && mouseDown('left'), + { selectorName: 'mouse-down-counter', beforeValue: '0', afterValue: '2', - }); + } + ); }); }); - module('middle clicking', function() { - test('clicking once adjusts the counter by 1', async function(assert) { + module('middle clicking', function () { + test('clicking once adjusts the counter by 1', async function (assert) { assert.expect(2); - await textChanged(assert, - () => mouseDown('middle'), { - selectorName: 'mouse-down-counter', - beforeValue: '0', - afterValue: '-10', - }); + await textChanged(assert, () => mouseDown('middle'), { + selectorName: 'mouse-down-counter', + beforeValue: '0', + afterValue: '-10', + }); }); - test('clicking twice adjusts the counter by 1', async function(assert) { + test('clicking twice adjusts the counter by 1', async function (assert) { assert.expect(2); - await textChanged(assert, - () => mouseDown('middle') && mouseDown('middle'), { + await textChanged( + assert, + () => mouseDown('middle') && mouseDown('middle'), + { selectorName: 'mouse-down-counter', beforeValue: '0', afterValue: '-20', - }); + } + ); }); }); - module('right clicking', function() { - test('clicking once adjusts the counter by 1', async function(assert) { + module('right clicking', function () { + test('clicking once adjusts the counter by 1', async function (assert) { assert.expect(2); - await textChanged(assert, - () => mouseDown('right'), { - selectorName: 'mouse-down-counter', - beforeValue: '0', - afterValue: '10', - }); + await textChanged(assert, () => mouseDown('right'), { + selectorName: 'mouse-down-counter', + beforeValue: '0', + afterValue: '10', + }); }); - test('clicking twice adjusts the counter by 1', async function(assert) { + test('clicking twice adjusts the counter by 1', async function (assert) { assert.expect(2); - await textChanged(assert, - () => mouseDown('right') && mouseDown('right'), { + await textChanged( + assert, + () => mouseDown('right') && mouseDown('right'), + { selectorName: 'mouse-down-counter', beforeValue: '0', afterValue: '20', - }); + } + ); }); }); } diff --git a/tests/acceptance/on-key-helper-test.js b/tests/acceptance/on-key-helper-test.js index 0fb75d7c8..9c6e08e0e 100644 --- a/tests/acceptance/on-key-helper-test.js +++ b/tests/acceptance/on-key-helper-test.js @@ -3,39 +3,48 @@ import { setupApplicationTest } from 'ember-qunit'; import { module, test } from 'qunit'; import { textChanged } from '../helpers/text-changed'; -module('Acceptance | on-key helper ', function(hooks) { +module('Acceptance | on-key helper ', function (hooks) { setupApplicationTest(hooks); - hooks.beforeEach(async function(assert) { + hooks.beforeEach(async function (assert) { await visit('/test-scenario/on-key-helper-examples'); assert.equal(currentURL(), '/test-scenario/on-key-helper-examples'); }); - test('KeyS, no modifiers', async function(assert) { + test('KeyS, no modifiers', async function (assert) { assert.expect(3); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyS', key: 's' }), { + () => triggerEvent(document.body, 'keydown', { code: 'KeyS', key: 's' }), + { selectorName: 's', beforeValue: 'S not pressed', - afterValue: 'S pressed' - }); + afterValue: 'S pressed', + } + ); }); - test('Ctrl+k', async function(assert) { + test('Ctrl+k', async function (assert) { assert.expect(3); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyK', key: 'k', ctrlKey: true }), { + () => + triggerEvent(document.body, 'keydown', { + code: 'KeyK', + key: 'k', + ctrlKey: true, + }), + { selectorName: 'ctrl-k', beforeValue: 'Ctrl+K not pressed', - afterValue: 'Ctrl+K pressed' - }); + afterValue: 'Ctrl+K pressed', + } + ); }); - test('keydown: Ctrl+k on a Dvorak Keyboard', async function(assert) { + test('keydown: Ctrl+k on a Dvorak Keyboard', async function (assert) { assert.expect(3); const ctrlKDownProperties = { @@ -43,27 +52,36 @@ module('Acceptance | on-key helper ', function(hooks) { key: 'k', keyCode: 75, which: 75, - ctrlKey: true + ctrlKey: true, }; await textChanged( assert, - () => triggerEvent(document.body, 'keydown', ctrlKDownProperties), { + () => triggerEvent(document.body, 'keydown', ctrlKDownProperties), + { selectorName: 'ctrl-k', beforeValue: 'Ctrl+K not pressed', - afterValue: 'Ctrl+K pressed' - }); + afterValue: 'Ctrl+K pressed', + } + ); }); - test('shift+Slash', async function(assert) { + test('shift+Slash', async function (assert) { assert.expect(3); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'Slash', key: '?', shiftKey: true }), { + () => + triggerEvent(document.body, 'keydown', { + code: 'Slash', + key: '?', + shiftKey: true, + }), + { selectorName: 'question-mark', beforeValue: 'question mark not pressed', - afterValue: 'question mark pressed' - }); + afterValue: 'question mark pressed', + } + ); }); }); diff --git a/tests/acceptance/on-key-modifier-test.js b/tests/acceptance/on-key-modifier-test.js index 7e17d456d..87dcd2c23 100644 --- a/tests/acceptance/on-key-modifier-test.js +++ b/tests/acceptance/on-key-modifier-test.js @@ -1,113 +1,151 @@ -import { currentURL, click, fillIn, focus, triggerEvent, visit } from '@ember/test-helpers'; +import { + currentURL, + click, + fillIn, + focus, + triggerEvent, + visit, +} from '@ember/test-helpers'; import { setupApplicationTest } from 'ember-qunit'; import { module, test } from 'qunit'; import { gte } from 'ember-compatibility-helpers'; import { textChanged } from '../helpers/text-changed'; if (gte('3.8.0')) { - module('Acceptance | ember keyboard | on-key modifier', function(hooks) { + module('Acceptance | ember keyboard | on-key modifier', function (hooks) { setupApplicationTest(hooks); - hooks.beforeEach(async function(assert) { + hooks.beforeEach(async function (assert) { await visit('/test-scenario/on-key-modifier-examples'); assert.equal(currentURL(), '/test-scenario/on-key-modifier-examples'); }); - test('KeyB button shortcut', async function(assert) { + test('KeyB button shortcut', async function (assert) { assert.expect(3); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyB', key: 'b' }), { + () => + triggerEvent(document.body, 'keydown', { code: 'KeyB', key: 'b' }), + { selectorName: 'b-button', beforeValue: 'button press not triggered', - afterValue: 'button press triggered' - }); + afterValue: 'button press triggered', + } + ); }); - test('KeyC button shortcut should only fire when keyboard is activated', async function(assert) { + test('KeyC button shortcut should only fire when keyboard is activated', async function (assert) { assert.expect(5); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyC', key: 'c' }), { + () => + triggerEvent(document.body, 'keydown', { code: 'KeyC', key: 'c' }), + { selectorName: 'c-button', beforeValue: 'button press not triggered', - afterValue: 'button press not triggered' - }); + afterValue: 'button press not triggered', + } + ); - await click('[data-test-checkbox]') + await click('[data-test-checkbox]'); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyC', key: 'c' }), { + () => + triggerEvent(document.body, 'keydown', { code: 'KeyC', key: 'c' }), + { selectorName: 'c-button', beforeValue: 'button press not triggered', - afterValue: 'button press triggered' - }); + afterValue: 'button press triggered', + } + ); }); - test('KeyD button shortcut for keydown should fire', async function(assert) { + test('KeyD button shortcut for keydown should fire', async function (assert) { assert.expect(5); await textChanged( assert, - () => triggerEvent(document.body, 'keyup', { code: 'KeyD', key: 'd' }), { + () => triggerEvent(document.body, 'keyup', { code: 'KeyD', key: 'd' }), + { selectorName: 'd-button', beforeValue: 'button press not triggered', - afterValue: 'button press not triggered' - }); + afterValue: 'button press not triggered', + } + ); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyD', key: 'd' }), { + () => + triggerEvent(document.body, 'keydown', { code: 'KeyD', key: 'd' }), + { selectorName: 'd-button', beforeValue: 'button press not triggered', - afterValue: 'button press triggered' - }); + afterValue: 'button press triggered', + } + ); }); - test('KeyP button shortcut does not block other shortcuts', async function(assert) { + test('KeyP button shortcut does not block other shortcuts', async function (assert) { assert.expect(5); await fillIn('[data-test-priority]', 1); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyD', key: 'd' }), { + () => + triggerEvent(document.body, 'keydown', { code: 'KeyD', key: 'd' }), + { selectorName: 'd-button', beforeValue: 'button press not triggered', - afterValue: 'button press triggered' - }); + afterValue: 'button press triggered', + } + ); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'KeyP', key: 'p' }), { + () => + triggerEvent(document.body, 'keydown', { code: 'KeyP', key: 'p' }), + { selectorName: 'p-button', beforeValue: 'button press not triggered', - afterValue: 'button press triggered' - }); + afterValue: 'button press triggered', + } + ); }); - - test('Enter text input shortcut', async function(assert) { + test('Enter text input shortcut', async function (assert) { assert.expect(5); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'Enter', key: 'Enter' }), { + () => + triggerEvent(document.body, 'keydown', { + code: 'Enter', + key: 'Enter', + }), + { selectorName: 'text-field', beforeValue: 'enter not pressed while input focused', - afterValue: 'enter not pressed while input focused' - }); + afterValue: 'enter not pressed while input focused', + } + ); await focus('input[type="text"]'); await textChanged( assert, - () => triggerEvent(document.body, 'keydown', { code: 'Enter', key: 'Enter' }), { + () => + triggerEvent(document.body, 'keydown', { + code: 'Enter', + key: 'Enter', + }), + { selectorName: 'text-field', beforeValue: 'enter not pressed while input focused', - afterValue: 'enter pressed while input focused' - }); + afterValue: 'enter pressed while input focused', + } + ); }); }); } diff --git a/tests/acceptance/touch-test.js b/tests/acceptance/touch-test.js index 03a7872d2..4d0a93c3b 100644 --- a/tests/acceptance/touch-test.js +++ b/tests/acceptance/touch-test.js @@ -5,37 +5,33 @@ import { touchStart } from 'ember-keyboard/test-support/test-helpers'; import { textChanged } from '../helpers/text-changed'; import { gte } from 'ember-compatibility-helpers'; -module('Acceptance | ember keyboard | touch', function(hooks) { +module('Acceptance | ember keyboard | touch', function (hooks) { setupApplicationTest(hooks); if (gte('3.10.0')) { - - hooks.beforeEach(async function() { + hooks.beforeEach(async function () { await visit('/test-scenario/touch'); }); - module('start touching', function() { - - test('increases the touch counter once', async function(assert) { + module('start touching', function () { + test('increases the touch counter once', async function (assert) { assert.expect(2); - await textChanged(assert, - () => touchStart(), { - selectorName: 'touch-start-counter', - beforeValue: '0', - afterValue: '1', - }); + await textChanged(assert, () => touchStart(), { + selectorName: 'touch-start-counter', + beforeValue: '0', + afterValue: '1', + }); }); - test('increases the touch counter twice', async function(assert) { + test('increases the touch counter twice', async function (assert) { assert.expect(2); - await textChanged(assert, - () => touchStart() && touchStart(), { - selectorName: 'touch-start-counter', - beforeValue: '0', - afterValue: '2', - }); + await textChanged(assert, () => touchStart() && touchStart(), { + selectorName: 'touch-start-counter', + beforeValue: '0', + afterValue: '2', + }); }); }); } diff --git a/tests/blanket-options.js b/tests/blanket-options.js index 4f1ece5a9..ab4336c9b 100644 --- a/tests/blanket-options.js +++ b/tests/blanket-options.js @@ -12,12 +12,12 @@ var options = { lcovOptions: { outputFile: 'lcov.info', //provide a function to rename es6 modules to a file path - renamer: function(moduleName){ + renamer: function (moduleName) { var root = /^ember-keyboard/; return moduleName.replace(root, 'addon') + '.js'; - } - } - } + }, + }, + }, }; if (typeof exports === 'undefined') { blanket.options(options); diff --git a/tests/dummy/app/components/decorator-example1/component.js b/tests/dummy/app/components/decorator-example1/component.js index 6f558bff9..2bf85b35f 100644 --- a/tests/dummy/app/components/decorator-example1/component.js +++ b/tests/dummy/app/components/decorator-example1/component.js @@ -3,7 +3,6 @@ import { keyResponder, onKey } from 'ember-keyboard'; @keyResponder export default class extends Component { - @onKey('shift+c') onShiftCDown(e) { this.args.onTrigger(e); @@ -19,5 +18,4 @@ export default class extends Component { onAltLeftArrowOrRightArrowDown(e) { this.args.onTrigger(e); } - } diff --git a/tests/dummy/app/components/decorator-example3/component.js b/tests/dummy/app/components/decorator-example3/component.js index eabdf0ab4..71ec84d93 100644 --- a/tests/dummy/app/components/decorator-example3/component.js +++ b/tests/dummy/app/components/decorator-example3/component.js @@ -4,24 +4,27 @@ import Component from '@ember/component'; import { keyResponder, onKey } from 'ember-keyboard'; -export default keyResponder(Component.extend({ +export default keyResponder( + Component.extend({ + onShiftCDown: onKey('shift+c', function (e) { + if (this.onTrigger) { + this.onTrigger(e); + } + }), - onShiftCDown: onKey('shift+c', function(e) { - if (this.onTrigger) { - this.onTrigger(e); - } - }), + onCtrlAltKeyEUp: onKey('ctrl+alt+KeyE', { event: 'keyup' }, function (e) { + if (this.onTrigger) { + this.onTrigger(e); + } + }), - onCtrlAltKeyEUp: onKey('ctrl+alt+KeyE', { event: 'keyup' }, function(e) { - if (this.onTrigger) { - this.onTrigger(e); - } - }), - - onAltLeftArrowOrRightArrowDown: onKey('alt+ArrowLeft', onKey('alt+ArrowRight', function(e) { - if (this.onTrigger) { - this.onTrigger(e); - } - })) - -})); + onAltLeftArrowOrRightArrowDown: onKey( + 'alt+ArrowLeft', + onKey('alt+ArrowRight', function (e) { + if (this.onTrigger) { + this.onTrigger(e); + } + }) + ), + }) +); diff --git a/tests/dummy/app/components/decorator-example4/component.js b/tests/dummy/app/components/decorator-example4/component.js index 6ef8e5379..3df9ccec7 100644 --- a/tests/dummy/app/components/decorator-example4/component.js +++ b/tests/dummy/app/components/decorator-example4/component.js @@ -4,21 +4,23 @@ import Component from '@ember/component'; import { keyResponder, onKey } from 'ember-keyboard'; -export default keyResponder(Component.extend({ - get keyboardPriority() { - return this.priority || 0; - }, +export default keyResponder( + Component.extend({ + get keyboardPriority() { + return this.priority || 0; + }, - get keyboardActivated() { - if (this.activated === undefined) { - return super.keyboardActivated; - } - return this.activated; - }, + get keyboardActivated() { + if (this.activated === undefined) { + return super.keyboardActivated; + } + return this.activated; + }, - onDigit2Down: onKey('Digit2', function(keyboardEvent, emberKeyboardEvent) { - if (this.onTrigger) { - this.onTrigger(keyboardEvent, emberKeyboardEvent); - } + onDigit2Down: onKey('Digit2', function (keyboardEvent, emberKeyboardEvent) { + if (this.onTrigger) { + this.onTrigger(keyboardEvent, emberKeyboardEvent); + } + }), }) -})); +); diff --git a/tests/dummy/app/components/deprecated/key-down-counter.js b/tests/dummy/app/components/deprecated/key-down-counter.js index d920d63a3..4255408de 100644 --- a/tests/dummy/app/components/deprecated/key-down-counter.js +++ b/tests/dummy/app/components/deprecated/key-down-counter.js @@ -7,7 +7,7 @@ import Component from '@ember/component'; import { EKMixin, keyDown, keyUp, keyPress } from 'ember-keyboard'; function makeEventHandler(stepSize = 1) { - return function(_event, ekEvent) { + return function (_event, ekEvent) { if (this.stopImmediatePropagation) { ekEvent.stopImmediatePropagation(); } @@ -15,7 +15,7 @@ function makeEventHandler(stepSize = 1) { ekEvent.stopPropagation(); } this.incrementProperty('counter', stepSize); - } + }; } export default Component.extend(EKMixin, { @@ -25,13 +25,20 @@ export default Component.extend(EKMixin, { counter: 0, - keyboardActivated: computed('parentActivated', 'toggleActivated', 'activatedToggle', { - get() { - const toggleActivated = this.activatedToggle ? this.toggleActivated : true; - - return toggleActivated && this.parentActivated; + keyboardActivated: computed( + 'parentActivated', + 'toggleActivated', + 'activatedToggle', + { + get() { + const toggleActivated = this.activatedToggle + ? this.toggleActivated + : true; + + return toggleActivated && this.parentActivated; + }, } - }).readOnly(), + ).readOnly(), didInsertElement() { this._super(...arguments); @@ -43,14 +50,12 @@ export default Component.extend(EKMixin, { this.on(keyDown('ctrl+shift+ArrowLeft'), makeEventHandler(-100)); this.on(keyDown('ctrl+shift+ArrowRight'), makeEventHandler(100)); - this.on(keyUp('KeyR'), function() { + this.on(keyUp('KeyR'), function () { this.set('counter', 0); }); - this.on(keyPress('Digit5'), function() { + this.on(keyPress('Digit5'), function () { this.set('counter', 5); }); - } - - + }, }); diff --git a/tests/dummy/app/components/deprecated/mouse-down-counter.js b/tests/dummy/app/components/deprecated/mouse-down-counter.js index bbf6beef7..c079b9fb5 100644 --- a/tests/dummy/app/components/deprecated/mouse-down-counter.js +++ b/tests/dummy/app/components/deprecated/mouse-down-counter.js @@ -7,7 +7,7 @@ import Component from '@ember/component'; import { EKMixin, mouseDown } from 'ember-keyboard'; function makeEventHandler(stepSize = 1) { - return function(event, ekEvent) { + return function (event, ekEvent) { if (this.stopImmediatePropagation) { ekEvent.stopImmediatePropagation(); } @@ -15,7 +15,7 @@ function makeEventHandler(stepSize = 1) { ekEvent.stopPropagation(); } this.incrementProperty('counter', stepSize); - } + }; } export default Component.extend(EKMixin, { @@ -25,13 +25,20 @@ export default Component.extend(EKMixin, { counter: 0, - keyboardActivated: computed('parentActivated', 'toggleActivated', 'activatedToggle', { - get() { - const toggleActivated = this.activatedToggle ? this.toggleActivated : true; - - return toggleActivated && this.parentActivated; + keyboardActivated: computed( + 'parentActivated', + 'toggleActivated', + 'activatedToggle', + { + get() { + const toggleActivated = this.activatedToggle + ? this.toggleActivated + : true; + + return toggleActivated && this.parentActivated; + }, } - }).readOnly(), + ).readOnly(), didInsertElement() { this._super(...arguments); @@ -39,6 +46,5 @@ export default Component.extend(EKMixin, { this.on(mouseDown('left'), makeEventHandler(1)); this.on(mouseDown('right'), makeEventHandler(10)); this.on(mouseDown('middle'), makeEventHandler(-10)); - } - + }, }); diff --git a/tests/dummy/app/components/deprecated/touch-start-counter.js b/tests/dummy/app/components/deprecated/touch-start-counter.js index 175a9b9c6..b760eaee5 100644 --- a/tests/dummy/app/components/deprecated/touch-start-counter.js +++ b/tests/dummy/app/components/deprecated/touch-start-counter.js @@ -7,7 +7,7 @@ import Component from '@ember/component'; import { EKMixin, touchStart } from 'ember-keyboard'; function makeEventHandler(stepSize = 1) { - return function(event, ekEvent) { + return function (event, ekEvent) { if (this.stopImmediatePropagation) { ekEvent.stopImmediatePropagation(); } @@ -16,7 +16,7 @@ function makeEventHandler(stepSize = 1) { } this.incrementProperty('counter', stepSize); - } + }; } export default Component.extend(EKMixin, { @@ -26,18 +26,24 @@ export default Component.extend(EKMixin, { counter: 0, - keyboardActivated: computed('parentActivated', 'toggleActivated', 'activatedToggle', { - get() { - const toggleActivated = this.activatedToggle ? this.toggleActivated : true; - - return toggleActivated && this.parentActivated; + keyboardActivated: computed( + 'parentActivated', + 'toggleActivated', + 'activatedToggle', + { + get() { + const toggleActivated = this.activatedToggle + ? this.toggleActivated + : true; + + return toggleActivated && this.parentActivated; + }, } - }).readOnly(), + ).readOnly(), didInsertElement() { this._super(...arguments); - this.on(touchStart(), makeEventHandler(1)) - } - + this.on(touchStart(), makeEventHandler(1)); + }, }); diff --git a/tests/dummy/app/components/key-down-counter.js b/tests/dummy/app/components/key-down-counter.js index 9b8c8df93..5c341c4a7 100644 --- a/tests/dummy/app/components/key-down-counter.js +++ b/tests/dummy/app/components/key-down-counter.js @@ -3,7 +3,7 @@ import { keyResponder, onKey } from 'ember-keyboard'; import { tracked } from '@glimmer/tracking'; function makeEventHandler(stepSize = 1) { - return function(_event, ekEvent) { + return function (_event, ekEvent) { if (this.stopImmediatePropagation) { ekEvent.stopImmediatePropagation(); } @@ -11,7 +11,7 @@ function makeEventHandler(stepSize = 1) { ekEvent.stopPropagation(); } this.counter = this.counter + stepSize; - } + }; } @keyResponder @@ -25,7 +25,9 @@ export default class extends Component { @tracked keyboardFirstResponder = false; get keyboardActivated() { - let toggleActivated = this.args.activatedToggle ? this.toggleActivated : true; + let toggleActivated = this.args.activatedToggle + ? this.toggleActivated + : true; return toggleActivated && this.args.parentActivated; } diff --git a/tests/dummy/app/components/keyboard-propagation-widget.js b/tests/dummy/app/components/keyboard-propagation-widget.js index b6de68cd9..38a71c119 100644 --- a/tests/dummy/app/components/keyboard-propagation-widget.js +++ b/tests/dummy/app/components/keyboard-propagation-widget.js @@ -20,5 +20,5 @@ export default Component.extend(EnterableMixin, { this._super(...arguments); set(this, 'keyboard.isPropagationEnabled', false); - } + }, }); diff --git a/tests/dummy/app/components/mouse-down-counter.js b/tests/dummy/app/components/mouse-down-counter.js index 7df4f6812..f94d1f583 100644 --- a/tests/dummy/app/components/mouse-down-counter.js +++ b/tests/dummy/app/components/mouse-down-counter.js @@ -3,7 +3,7 @@ import { keyResponder, onKey } from 'ember-keyboard'; import { tracked } from '@glimmer/tracking'; function makeEventHandler(stepSize = 1) { - return function(_event, ekEvent) { + return function (_event, ekEvent) { if (this.stopImmediatePropagation) { ekEvent.stopImmediatePropagation(); } @@ -11,7 +11,7 @@ function makeEventHandler(stepSize = 1) { ekEvent.stopPropagation(); } this.counter = this.counter + stepSize; - } + }; } @keyResponder @@ -20,7 +20,9 @@ export default class extends Component { @tracked counter = 0; get keyboardActivated() { - let toggleActivated = this.args.activatedToggle ? this.toggleActivated : true; + let toggleActivated = this.args.activatedToggle + ? this.toggleActivated + : true; return toggleActivated && this.args.parentActivated; } diff --git a/tests/dummy/app/components/touch-start-counter.js b/tests/dummy/app/components/touch-start-counter.js index df0116581..fcfd88309 100644 --- a/tests/dummy/app/components/touch-start-counter.js +++ b/tests/dummy/app/components/touch-start-counter.js @@ -3,7 +3,7 @@ import { keyResponder, onKey } from 'ember-keyboard'; import { tracked } from '@glimmer/tracking'; function makeEventHandler(stepSize = 1) { - return function(_event, ekEvent) { + return function (_event, ekEvent) { if (this.stopImmediatePropagation) { ekEvent.stopImmediatePropagation(); } @@ -11,7 +11,7 @@ function makeEventHandler(stepSize = 1) { ekEvent.stopPropagation(); } this.counter = this.counter + stepSize; - } + }; } @keyResponder @@ -20,7 +20,9 @@ export default class extends Component { @tracked counter = 0; get keyboardActivated() { - let toggleActivated = this.args.activatedToggle ? this.toggleActivated : true; + let toggleActivated = this.args.activatedToggle + ? this.toggleActivated + : true; return toggleActivated && this.args.parentActivated; } diff --git a/tests/dummy/app/components/trigger-event-widget.js b/tests/dummy/app/components/trigger-event-widget.js index a98c82409..ef8911444 100644 --- a/tests/dummy/app/components/trigger-event-widget.js +++ b/tests/dummy/app/components/trigger-event-widget.js @@ -18,20 +18,17 @@ export default Component.extend(EKMixin, { didInsertElement() { this._super(...arguments); - this.on(keyDown('KeyA'), function() { + this.on(keyDown('KeyA'), function () { this.toggleProperty('keyDown'); }), - - this.on(keyDown('KeyA+cmd+shift'), function() { - this.toggleProperty('keyDownWithMods'); - }), - - this.on(keyPress('KeyA'), function() { - this.toggleProperty('keyPress'); - }), - - this.on(keyUp('KeyA'), function() { - this.toggleProperty('keyUp'); - }) - } + this.on(keyDown('KeyA+cmd+shift'), function () { + this.toggleProperty('keyDownWithMods'); + }), + this.on(keyPress('KeyA'), function () { + this.toggleProperty('keyPress'); + }), + this.on(keyUp('KeyA'), function () { + this.toggleProperty('keyUp'); + }); + }, }); diff --git a/tests/dummy/app/controllers/test-scenario/deprecated/element-modifiers.js b/tests/dummy/app/controllers/test-scenario/deprecated/element-modifiers.js index 4640755f8..090a77c8c 100644 --- a/tests/dummy/app/controllers/test-scenario/deprecated/element-modifiers.js +++ b/tests/dummy/app/controllers/test-scenario/deprecated/element-modifiers.js @@ -6,7 +6,7 @@ export default class extends Controller { constructor(...args) { super(...args); - this.priority = 0 + this.priority = 0; } @action diff --git a/tests/dummy/app/controllers/test-scenario/on-key-modifier-examples.js b/tests/dummy/app/controllers/test-scenario/on-key-modifier-examples.js index 4eea0582a..42d1cefcc 100644 --- a/tests/dummy/app/controllers/test-scenario/on-key-modifier-examples.js +++ b/tests/dummy/app/controllers/test-scenario/on-key-modifier-examples.js @@ -5,7 +5,7 @@ export default class extends Controller { constructor(...args) { super(...args); - this.priority = 0 + this.priority = 0; } @action diff --git a/tests/dummy/app/helpers/format-markdown.js b/tests/dummy/app/helpers/format-markdown.js index ae8867541..be84f2f88 100644 --- a/tests/dummy/app/helpers/format-markdown.js +++ b/tests/dummy/app/helpers/format-markdown.js @@ -1,7 +1,7 @@ import marked from 'marked'; import hljs from 'highlightjs'; -import { helper } from "@ember/component/helper"; -import { htmlSafe } from "@ember/string"; +import { helper } from '@ember/component/helper'; +import { htmlSafe } from '@ember/string'; export function formatMarkdown([value]) { if (!value) { @@ -9,9 +9,9 @@ export function formatMarkdown([value]) { } marked.setOptions({ - highlight: function(code) { + highlight: function (code) { return hljs.highlightAuto(code).value; - } + }, }); // highlight JS requires the following classes for code highlighting @@ -22,10 +22,9 @@ export function formatMarkdown([value]) { // input: ```javascript\nsomeJavascript()\n``` // will result in a class: // and after the following replace: ... - let parsedMarkdown = marked(value) - .replace(/lang-(\w+)/g, "lang-$1 hljs $1"); + let parsedMarkdown = marked(value).replace(/lang-(\w+)/g, 'lang-$1 hljs $1'); return new htmlSafe(parsedMarkdown); } -export default helper(formatMarkdown); \ No newline at end of file +export default helper(formatMarkdown); diff --git a/tests/dummy/app/helpers/pick.js b/tests/dummy/app/helpers/pick.js index 0f927878e..18f0aec15 100644 --- a/tests/dummy/app/helpers/pick.js +++ b/tests/dummy/app/helpers/pick.js @@ -1,8 +1,8 @@ import { helper } from '@ember/component/helper'; import { get } from '@ember/object'; -export default helper(function event([path, action]/*, hash*/) { - return function(event) { +export default helper(function event([path, action] /*, hash*/) { + return function (event) { let value = get(event, path); if (!action) { diff --git a/tests/dummy/app/mixins/enterable.js b/tests/dummy/app/mixins/enterable.js index 9c2dbee91..96c7c99d5 100644 --- a/tests/dummy/app/mixins/enterable.js +++ b/tests/dummy/app/mixins/enterable.js @@ -2,7 +2,7 @@ import { inject as service } from '@ember/service'; import Mixin from '@ember/object/mixin'; -export default Mixin.create( { +export default Mixin.create({ classNames: ['keyboard-widget'], classNameBindings: ['keyboardActivated:active'], keyboard: service(), @@ -31,5 +31,5 @@ export default Mixin.create( { if (this.oldPropagationModel) { this.keyboard.isPropagationEnabled = false; } - } + }, }); diff --git a/tests/dummy/app/mixins/reset-scroll-position.js b/tests/dummy/app/mixins/reset-scroll-position.js index e54870530..b263c8608 100644 --- a/tests/dummy/app/mixins/reset-scroll-position.js +++ b/tests/dummy/app/mixins/reset-scroll-position.js @@ -6,7 +6,7 @@ export default Mixin.create({ this._super(...args); if (typeof FastBoot === 'undefined') { - window.scrollTo(0,0); + window.scrollTo(0, 0); } - } + }, }); diff --git a/tests/dummy/app/router.js b/tests/dummy/app/router.js index c2847e9ac..f2d1cc3fc 100644 --- a/tests/dummy/app/router.js +++ b/tests/dummy/app/router.js @@ -6,19 +6,19 @@ export default class Router extends EmberRouter { rootURL = config.rootURL; } -Router.map(function() { - this.route('test-scenario', function() { +Router.map(function () { + this.route('test-scenario', function () { this.route('mouse-down'); this.route('touch'); this.route('keyboard'); this.route('on-key-helper-examples'); this.route('on-key-modifier-examples'); - this.route('deprecated', function() { + this.route('deprecated', function () { this.route('element-modifiers'); this.route('keyboard'); this.route('mouse-down'); this.route('touch'); - }); + }); }); this.route('deprecations'); diff --git a/tests/dummy/app/services/keyboard.js b/tests/dummy/app/services/keyboard.js index acb3f3b98..26188da1b 100644 --- a/tests/dummy/app/services/keyboard.js +++ b/tests/dummy/app/services/keyboard.js @@ -13,13 +13,19 @@ function handleKeyEventWithLaxPriorities(event, sortedResponders) { const keyboardFirstResponder = responder.keyboardFirstResponder; const keyboardPriority = responder.keyboardPriority; - if (keyboardFirstResponder || (noFirstResponders && keyboardPriority >= currentPriorityLevel) || isLax) { + if ( + keyboardFirstResponder || + (noFirstResponders && keyboardPriority >= currentPriorityLevel) || + isLax + ) { if (!responder.keyboardLaxPriority) { isLax = false; } if (keyboardFirstResponder) { - if (!isLax) { noFirstResponders = false; } + if (!isLax) { + noFirstResponders = false; + } } else { currentPriorityLevel = keyboardPriority; } @@ -35,7 +41,10 @@ function handleKeyEventWithLaxPriorities(event, sortedResponders) { function triggerResponderListener(responder, event, ekEvent = null) { if (responder.handleKeyboardEvent) { - if (responder.canHandleKeyboardEvent && !responder.canHandleKeyboardEvent(event)) { + if ( + responder.canHandleKeyboardEvent && + !responder.canHandleKeyboardEvent(event) + ) { return; } responder.handleKeyboardEvent(event, ekEvent); @@ -55,7 +64,9 @@ function triggerResponderListener(responder, event, ekEvent = null) { return; } - throw new Error('A responder registered with the ember-keyboard service must implement either `keyboardHandlers` (property returning a dictionary of listenerNames to handler functions), or `handleKeyboardEvent(event)`)'); + throw new Error( + 'A responder registered with the ember-keyboard service must implement either `keyboardHandlers` (property returning a dictionary of listenerNames to handler functions), or `handleKeyboardEvent(event)`)' + ); } /** @@ -72,7 +83,12 @@ export default class extends KeyboardService { } else { run(() => { const sortedResponders = this.activeResponders.sort((a, b) => { - let compareValue = reverseCompareProp(a, b, 'keyboardFirstResponder', Boolean); + let compareValue = reverseCompareProp( + a, + b, + 'keyboardFirstResponder', + Boolean + ); if (compareValue === 0) { return reverseCompareProp(a, b, 'keyboardPriority'); } diff --git a/tests/dummy/app/services/widget-manager.js b/tests/dummy/app/services/widget-manager.js index fc95486fe..6da0ea0ac 100644 --- a/tests/dummy/app/services/widget-manager.js +++ b/tests/dummy/app/services/widget-manager.js @@ -11,5 +11,5 @@ export default Service.extend({ } this.set('activeWidget', widget); - } + }, }); diff --git a/tests/dummy/config/environment.js b/tests/dummy/config/environment.js index 64152d96e..9628718e1 100644 --- a/tests/dummy/config/environment.js +++ b/tests/dummy/config/environment.js @@ -1,6 +1,6 @@ 'use strict'; -module.exports = function(environment) { +module.exports = function (environment) { let ENV = { modulePrefix: 'dummy', environment, @@ -13,8 +13,8 @@ module.exports = function(environment) { }, EXTEND_PROTOTYPES: { // Prevent Ember Data from overriding Date.parse. - Date: false - } + Date: false, + }, }, APP: { @@ -23,8 +23,17 @@ module.exports = function(environment) { }, emberKeyboard: { - listeners: ['keyUp', 'keyDown', 'keyPress', 'click', 'mouseDown', 'mouseUp', 'touchStart', 'touchEnd'] - } + listeners: [ + 'keyUp', + 'keyDown', + 'keyPress', + 'click', + 'mouseDown', + 'mouseUp', + 'touchStart', + 'touchEnd', + ], + }, }; if (environment === 'development') { diff --git a/tests/dummy/config/targets.js b/tests/dummy/config/targets.js index 498e438b3..e5e92faca 100644 --- a/tests/dummy/config/targets.js +++ b/tests/dummy/config/targets.js @@ -8,5 +8,5 @@ const browsers = [ module.exports = { browsers, - node: 'current' + node: 'current', }; diff --git a/tests/fastboot/rendering-test.js b/tests/fastboot/rendering-test.js index f2947271d..6feeacaea 100644 --- a/tests/fastboot/rendering-test.js +++ b/tests/fastboot/rendering-test.js @@ -1,10 +1,13 @@ import { module, test } from 'qunit'; -import { setup, visit, /* mockServer */ } from 'ember-cli-fastboot-testing/test-support'; +import { + setup, + visit /* mockServer */, +} from 'ember-cli-fastboot-testing/test-support'; -module('FastBoot | rendering test', function(hooks) { +module('FastBoot | rendering test', function (hooks) { setup(hooks); - test('renders', async function(assert) { + test('renders', async function (assert) { const res = await visit('/test-scenario'); assert.strictEqual(res.statusCode, 200); }); diff --git a/tests/helpers/get-service.js b/tests/helpers/get-service.js index ea9a8774d..558962745 100644 --- a/tests/helpers/get-service.js +++ b/tests/helpers/get-service.js @@ -1,4 +1,4 @@ -import { getContext } from "@ember/test-helpers"; +import { getContext } from '@ember/test-helpers'; export function getService(name) { const { owner } = getContext(); diff --git a/tests/helpers/get-values.js b/tests/helpers/get-values.js index 225755d1b..daf41a49d 100644 --- a/tests/helpers/get-values.js +++ b/tests/helpers/get-values.js @@ -2,21 +2,20 @@ import { findAll } from '@ember/test-helpers'; import { hook } from './hook'; - export function getValues() { - return findAll(`${hook('counter-counter')}`).map(function(element) { + return findAll(`${hook('counter-counter')}`).map(function (element) { return parseInt(element.innerText.trim(), 10); }); } export function getMouseValues() { - return findAll(`${hook('mouse-counter-counter')}`).map(function(element) { + return findAll(`${hook('mouse-counter-counter')}`).map(function (element) { return parseInt(element.innerText.trim(), 10); }); } export function getTouchValues() { - return findAll(`${hook('touch-counter-counter')}`).map(function(element) { + return findAll(`${hook('touch-counter-counter')}`).map(function (element) { return parseInt(element.innerText.trim(), 10); }); } diff --git a/tests/helpers/hook.js b/tests/helpers/hook.js index fde521f22..6007c171a 100644 --- a/tests/helpers/hook.js +++ b/tests/helpers/hook.js @@ -1,3 +1,3 @@ export function hook(value) { return `[data-test-${value}]`; -} \ No newline at end of file +} diff --git a/tests/helpers/text-changed.js b/tests/helpers/text-changed.js index deca1ceef..82fa7760b 100644 --- a/tests/helpers/text-changed.js +++ b/tests/helpers/text-changed.js @@ -4,12 +4,12 @@ const defaultOptions = { selectorName: undefined, beforeValue: undefined, afterValue: undefined, -} +}; export const textChanged = async (assert, testFn, passedOptions = {}) => { const options = { ...defaultOptions, - ...passedOptions + ...passedOptions, }; const { beforeValue, afterValue, selectorName } = options; @@ -26,4 +26,4 @@ export const textChanged = async (assert, testFn, passedOptions = {}) => { const afterResult = afterElement.innerText.trim(); assert.equal(afterResult, afterValue); -} \ No newline at end of file +}; diff --git a/tests/integration/decorators/decorators-test.js b/tests/integration/decorators/decorators-test.js index d6bb3bb44..cf20501ec 100644 --- a/tests/integration/decorators/decorators-test.js +++ b/tests/integration/decorators/decorators-test.js @@ -6,20 +6,20 @@ import { hbs } from 'ember-cli-htmlbars'; import { keyDown, keyUp } from 'ember-keyboard/test-support/test-helpers'; import { gte } from 'ember-compatibility-helpers'; -module('Integration | decorators', function(hooks) { +module('Integration | decorators', function (hooks) { setupRenderingTest(hooks); let onTriggerCalled; - hooks.beforeEach(function() { + hooks.beforeEach(function () { onTriggerCalled = false; - this.set('onTrigger', function() { + this.set('onTrigger', function () { onTriggerCalled = true; }); }); - module('decorators with an ES6 class', function(hooks) { - module('lifecycle', function(hooks) { - hooks.beforeEach(function() { + module('decorators with an ES6 class', function (hooks) { + module('lifecycle', function (hooks) { + hooks.beforeEach(function () { this.set('shouldRenderOnKeyHelper', false); this.renderWithConditional = () => { return render(hbs` @@ -27,20 +27,20 @@ module('Integration | decorators', function(hooks) { {{/if}} `); - } + }; }); - test('does not trigger if helper is not rendered', async function(assert) { + test('does not trigger if helper is not rendered', async function (assert) { await this.renderWithConditional(); await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('triggers if helper is rendered', async function(assert) { + test('triggers if helper is rendered', async function (assert) { await this.renderWithConditional(); this.set('shouldRenderOnKeyHelper', true); await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger if helper is no longer rendered', async function(assert) { + test('does not trigger if helper is no longer rendered', async function (assert) { this.set('shouldRenderOnKeyHelper', true); await this.renderWithConditional(); this.set('shouldRenderOnKeyHelper', false); @@ -48,7 +48,7 @@ module('Integration | decorators', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - test('with an event specified', async function(assert) { + test('with an event specified', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; @@ -56,15 +56,21 @@ module('Integration | decorators', function(hooks) { await render(hbs``); await keyUp('shift+c'); - assert.notOk(onTriggerCalledWith, 'not called in keyup if event is not specified'); + assert.notOk( + onTriggerCalledWith, + 'not called in keyup if event is not specified' + ); await keyDown('ctrl+alt+KeyE'); - assert.notOk(onTriggerCalledWith, 'not called in keydown if keyup is specified'); + assert.notOk( + onTriggerCalledWith, + 'not called in keydown if keyup is specified' + ); await keyUp('ctrl+alt+KeyE'); assert.ok(onTriggerCalledWith instanceof KeyboardEvent); }); - test('with multiple onKeys on one method', async function(assert) { + test('with multiple onKeys on one method', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; @@ -78,9 +84,9 @@ module('Integration | decorators', function(hooks) { await keyDown('alt+ArrowRight'); assert.ok(onTriggerCalledWith instanceof KeyboardEvent); }); - module('stopping propagation', function(hooks) { + module('stopping propagation', function (hooks) { let triggered; - hooks.beforeEach(function() { + hooks.beforeEach(function () { const keyboardService = this.owner.lookup('service:keyboard'); keyboardService.set('isPropagationEnabled', true); triggered = []; @@ -93,8 +99,8 @@ module('Integration | decorators', function(hooks) { ekEvent.stopImmediatePropagation(); } }); - }); - test('stopPropagation+stopImmediatePropagation', async function(assert) { + }); + test('stopPropagation+stopImmediatePropagation', async function (assert) { await render(hbs` @@ -104,7 +110,7 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a']); }); - test('stopPropagation', async function(assert) { + test('stopPropagation', async function (assert) { await render(hbs` @@ -114,7 +120,7 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a', 'A2b']); }); - test('stopImmediatePropagation', async function(assert) { + test('stopImmediatePropagation', async function (assert) { await render(hbs` @@ -124,7 +130,7 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a', 'A1']); }); - test('no stopping', async function(assert) { + test('no stopping', async function (assert) { await render(hbs` @@ -134,25 +140,27 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a', 'A2b', 'A1']); }); }); - module('activated param', function(hooks) { - hooks.beforeEach(function() { + module('activated param', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); this.renderWithActivated = () => { - return render(hbs``); - } + return render( + hbs`` + ); + }; }); - test('does not trigger if helper is not activated', async function(assert) { + test('does not trigger if helper is not activated', async function (assert) { await this.renderWithActivated(); await keyDown('Digit2'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('triggers if helper is activated', async function(assert) { + test('triggers if helper is activated', async function (assert) { await this.renderWithActivated(); this.set('isActivated', true); await keyDown('Digit2'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger if helper is no longer activated', async function(assert) { + test('does not trigger if helper is no longer activated', async function (assert) { this.set('shouldRenderOnKeyHelper', true); await this.renderWithActivated(); this.set('isActivated', false); @@ -163,9 +171,9 @@ module('Integration | decorators', function(hooks) { }); if (gte('3.10.0')) { - module('decorators with a classic component', function() { - module('lifecycle', function(hooks) { - hooks.beforeEach(function() { + module('decorators with a classic component', function () { + module('lifecycle', function (hooks) { + hooks.beforeEach(function () { this.set('shouldRenderOnKeyHelper', false); this.renderWithConditional = () => { return render(hbs` @@ -173,20 +181,20 @@ module('Integration | decorators', function(hooks) { {{/if}} `); - } + }; }); - test('does not trigger if helper is not rendered', async function(assert) { + test('does not trigger if helper is not rendered', async function (assert) { await this.renderWithConditional(); await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('triggers if helper is rendered', async function(assert) { + test('triggers if helper is rendered', async function (assert) { await this.renderWithConditional(); this.set('shouldRenderOnKeyHelper', true); await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger if helper is no longer rendered', async function(assert) { + test('does not trigger if helper is no longer rendered', async function (assert) { this.set('shouldRenderOnKeyHelper', true); await this.renderWithConditional(); this.set('shouldRenderOnKeyHelper', false); @@ -194,7 +202,7 @@ module('Integration | decorators', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - test('with an event specified', async function(assert) { + test('with an event specified', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; @@ -202,15 +210,21 @@ module('Integration | decorators', function(hooks) { await render(hbs``); await keyUp('shift+c'); - assert.notOk(onTriggerCalledWith, 'not called in keyup if event is not specified'); + assert.notOk( + onTriggerCalledWith, + 'not called in keyup if event is not specified' + ); await keyDown('ctrl+alt+KeyE'); - assert.notOk(onTriggerCalledWith, 'not called in keydown if keyup is specified'); + assert.notOk( + onTriggerCalledWith, + 'not called in keydown if keyup is specified' + ); await keyUp('ctrl+alt+KeyE'); assert.ok(onTriggerCalledWith instanceof KeyboardEvent); }); - test('with multiple onKeys on one method', async function(assert) { + test('with multiple onKeys on one method', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; @@ -224,9 +238,9 @@ module('Integration | decorators', function(hooks) { await keyDown('alt+ArrowRight'); assert.ok(onTriggerCalledWith instanceof KeyboardEvent); }); - module('stopping propagation', function(hooks) { + module('stopping propagation', function (hooks) { let triggered; - hooks.beforeEach(function() { + hooks.beforeEach(function () { const keyboardService = this.owner.lookup('service:keyboard'); keyboardService.set('isPropagationEnabled', true); triggered = []; @@ -240,7 +254,7 @@ module('Integration | decorators', function(hooks) { } }); }); - test('stopPropagation+stopImmediatePropagation', async function(assert) { + test('stopPropagation+stopImmediatePropagation', async function (assert) { await render(hbs` @@ -250,7 +264,7 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a']); }); - test('stopPropagation', async function(assert) { + test('stopPropagation', async function (assert) { await render(hbs` @@ -260,7 +274,7 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a', 'A2b']); }); - test('stopImmediatePropagation', async function(assert) { + test('stopImmediatePropagation', async function (assert) { await render(hbs` @@ -270,7 +284,7 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a', 'A1']); }); - test('no stopping', async function(assert) { + test('no stopping', async function (assert) { await render(hbs` @@ -280,25 +294,27 @@ module('Integration | decorators', function(hooks) { assert.deepEqual(triggered, ['A2a', 'A2b', 'A1']); }); }); - module('activated param', function(hooks) { - hooks.beforeEach(function() { + module('activated param', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); this.renderWithActivated = () => { - return render(hbs``); - } + return render( + hbs`` + ); + }; }); - test('does not trigger if helper is not activated', async function(assert) { + test('does not trigger if helper is not activated', async function (assert) { await this.renderWithActivated(); await keyDown('Digit2'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('triggers if helper is activated', async function(assert) { + test('triggers if helper is activated', async function (assert) { await this.renderWithActivated(); this.set('isActivated', true); await keyDown('Digit2'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger if helper is no longer activated', async function(assert) { + test('does not trigger if helper is no longer activated', async function (assert) { this.set('shouldRenderOnKeyHelper', true); await this.renderWithActivated(); this.set('isActivated', false); diff --git a/tests/integration/helpers/if-key-test.js b/tests/integration/helpers/if-key-test.js index b6cb1e130..2e65e63d6 100644 --- a/tests/integration/helpers/if-key-test.js +++ b/tests/integration/helpers/if-key-test.js @@ -1,60 +1,77 @@ import { module, skip, test } from 'qunit'; import { setupRenderingTest } from 'ember-qunit'; -import { click, render, resetOnerror, setupOnerror, triggerEvent } from '@ember/test-helpers'; +import { + click, + render, + resetOnerror, + setupOnerror, + triggerEvent, +} from '@ember/test-helpers'; import { hbs } from 'ember-cli-htmlbars'; -module('Integration | Helper | if-key', function(hooks) { +module('Integration | Helper | if-key', function (hooks) { setupRenderingTest(hooks); - module('error cases', function(hooks) { + module('error cases', function (hooks) { hooks.afterEach(() => resetOnerror()); // This doesn't work. I wish it did, but can't figure out why not. - skip('errors if invoked without a handler', async function(assert) { + skip('errors if invoked without a handler', async function (assert) { assert.expect(1); - setupOnerror(function(error) { + setupOnerror(function (error) { assert.strictEqual( error.message, - "Assertion Failed: ember-keyboard: The if-key helper must be provided a function as its second argument", + 'Assertion Failed: ember-keyboard: The if-key helper must be provided a function as its second argument', 'error is thrown' ); }); - await render(hbs`{{on-document "keydown" (if-key "alt+c" this.unknownEvent)}}`); + await render( + hbs`{{on-document "keydown" (if-key "alt+c" this.unknownEvent)}}` + ); await triggerEvent(document.body, 'keydown', { altKey: true, key: 'c' }); }); // This doesn't work. I wish it did, but can't figure out why not. - skip('warns if called without a keyboard event', async function(assert) { + skip('warns if called without a keyboard event', async function (assert) { assert.expect(1); - setupOnerror(function(error) { + setupOnerror(function (error) { assert.strictEqual( error.message, - "Assertion Failed: ember-keyboard: The if-key helper expects to be invoked with a KeyboardEvent", + 'Assertion Failed: ember-keyboard: The if-key helper expects to be invoked with a KeyboardEvent', 'error is thrown' ); }); - await render(hbs``); + await render( + hbs`` + ); await click('button'); }); }); - test('called with event', async function(assert) { + test('called with event', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; }); - await render(hbs`{{on-document "keydown" (if-key "alt+c" this.onTrigger)}}`); + await render( + hbs`{{on-document "keydown" (if-key "alt+c" this.onTrigger)}}` + ); await triggerEvent(document.body, 'keydown', { altKey: true, key: 'c' }); assert.ok(onTriggerCalledWith instanceof KeyboardEvent); }); - test('not called if key combo does not match', async function(assert) { + test('not called if key combo does not match', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; }); - await render(hbs`{{on-document "keydown" (if-key "alt+c" this.onTrigger)}}`); + await render( + hbs`{{on-document "keydown" (if-key "alt+c" this.onTrigger)}}` + ); await triggerEvent(document.body, 'keydown', { shiftKey: true, key: 'z' }); - assert.notOk(onTriggerCalledWith, 'trigger is on invoked if key does not match'); + assert.notOk( + onTriggerCalledWith, + 'trigger is on invoked if key does not match' + ); }); }); diff --git a/tests/integration/helpers/on-key-test.js b/tests/integration/helpers/on-key-test.js index 0ff6a23cd..30744e5a2 100644 --- a/tests/integration/helpers/on-key-test.js +++ b/tests/integration/helpers/on-key-test.js @@ -1,23 +1,32 @@ import { module, test } from 'qunit'; import { setupRenderingTest } from 'ember-qunit'; -import { render, resetOnerror, setupOnerror, triggerEvent } from '@ember/test-helpers'; +import { + render, + resetOnerror, + setupOnerror, + triggerEvent, +} from '@ember/test-helpers'; import { hbs } from 'ember-cli-htmlbars'; -import { keyDown, keyPress, keyUp } from 'ember-keyboard/test-support/test-helpers'; +import { + keyDown, + keyPress, + keyUp, +} from 'ember-keyboard/test-support/test-helpers'; import { gte } from 'ember-compatibility-helpers'; -module('Integration | Helper | on-key', function(hooks) { +module('Integration | Helper | on-key', function (hooks) { setupRenderingTest(hooks); let onTriggerCalled; - hooks.beforeEach(function() { + hooks.beforeEach(function () { onTriggerCalled = false; this.set('onTrigger', () => { onTriggerCalled = true; }); }); - module('lifecycle', function(hooks) { - hooks.beforeEach(function() { + module('lifecycle', function (hooks) { + hooks.beforeEach(function () { this.set('shouldRenderOnKeyHelper', false); this.renderWithConditional = () => { return render(hbs` @@ -25,20 +34,20 @@ module('Integration | Helper | on-key', function(hooks) { {{on-key 'shift+c' this.onTrigger}} {{/if}} `); - } + }; }); - test('does not trigger if helper is not rendered', async function(assert) { + test('does not trigger if helper is not rendered', async function (assert) { await this.renderWithConditional(); await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('triggers if helper is rendered', async function(assert) { + test('triggers if helper is rendered', async function (assert) { await this.renderWithConditional(); this.set('shouldRenderOnKeyHelper', true); await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger if helper is no longer rendered', async function(assert) { + test('does not trigger if helper is no longer rendered', async function (assert) { this.set('shouldRenderOnKeyHelper', true); await this.renderWithConditional(); await this.set('shouldRenderOnKeyHelper', false); @@ -47,7 +56,7 @@ module('Integration | Helper | on-key', function(hooks) { }); }); - test('called with event', async function(assert) { + test('called with event', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; @@ -57,9 +66,9 @@ module('Integration | Helper | on-key', function(hooks) { assert.ok(onTriggerCalledWith instanceof KeyboardEvent); }); - module('stopping propagation', function(hooks) { + module('stopping propagation', function (hooks) { let triggered; - hooks.beforeEach(function() { + hooks.beforeEach(function () { const keyboardService = this.owner.lookup('service:keyboard'); keyboardService.set('isPropagationEnabled', true); triggered = []; @@ -72,8 +81,8 @@ module('Integration | Helper | on-key', function(hooks) { ekEvent.stopImmediatePropagation(); } }); - }); - test('stopPropagation+stopImmediatePropagation', async function(assert) { + }); + test('stopPropagation+stopImmediatePropagation', async function (assert) { await render(hbs` {{on-key 'alt+a' (fn this.trigger 'A2a' true true) priority=2}} {{on-key 'alt+a' (fn this.trigger 'A2b' true true) priority=2}} @@ -82,7 +91,7 @@ module('Integration | Helper | on-key', function(hooks) { await triggerEvent(document.body, 'keydown', { altKey: true, key: 'a' }); assert.deepEqual(triggered, ['A2a']); }); - test('stopPropagation', async function(assert) { + test('stopPropagation', async function (assert) { await render(hbs` {{on-key 'alt+a' (fn this.trigger 'A2a' true false) priority=2}} {{on-key 'alt+a' (fn this.trigger 'A2b' true false) priority=2}} @@ -91,7 +100,7 @@ module('Integration | Helper | on-key', function(hooks) { await triggerEvent(document.body, 'keydown', { altKey: true, key: 'a' }); assert.deepEqual(triggered, ['A2a', 'A2b']); }); - test('stopImmediatePropagation', async function(assert) { + test('stopImmediatePropagation', async function (assert) { await render(hbs` {{on-key 'alt+a' (fn this.trigger 'A2a' false true) priority=2}} {{on-key 'alt+a' (fn this.trigger 'A2b' false true) priority=2}} @@ -100,7 +109,7 @@ module('Integration | Helper | on-key', function(hooks) { await triggerEvent(document.body, 'keydown', { altKey: true, key: 'a' }); assert.deepEqual(triggered, ['A2a', 'A1']); }); - test('no stopping', async function(assert) { + test('no stopping', async function (assert) { await render(hbs` {{on-key 'alt+a' (fn this.trigger 'A2a' false false) priority=2}} {{on-key 'alt+a' (fn this.trigger 'A2b' false false) priority=2}} @@ -111,16 +120,16 @@ module('Integration | Helper | on-key', function(hooks) { }); }); - module('unspecified event param', function(hooks) { - hooks.beforeEach(async function() { + module('unspecified event param', function (hooks) { + hooks.beforeEach(async function () { await render(hbs`{{on-key 'shift+c' this.onTrigger}}`); }); - test('triggers on keydown by default (affirmative)', async function(assert) { + test('triggers on keydown by default (affirmative)', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -129,16 +138,16 @@ module('Integration | Helper | on-key', function(hooks) { }); }); - module('with event="keydown"', function(hooks) { - hooks.beforeEach(async function() { + module('with event="keydown"', function (hooks) { + hooks.beforeEach(async function () { await render(hbs`{{on-key 'shift+c' this.onTrigger event='keydown'}}`); }); - test('triggers on keydown', async function(assert) { + test('triggers on keydown', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -147,16 +156,16 @@ module('Integration | Helper | on-key', function(hooks) { }); }); - module('with event="keyup"', function(hooks) { - hooks.beforeEach(async function() { + module('with event="keyup"', function (hooks) { + hooks.beforeEach(async function () { await render(hbs`{{on-key 'shift+c' this.onTrigger event='keyup'}}`); }); - test('triggers on keyup', async function(assert) { + test('triggers on keyup', async function (assert) { await keyUp('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keydown or keypress', async function(assert) { + test('does not trigger on keydown or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -165,16 +174,16 @@ module('Integration | Helper | on-key', function(hooks) { }); }); - module('with event="keypress"', function(hooks) { - hooks.beforeEach(async function() { + module('with event="keypress"', function (hooks) { + hooks.beforeEach(async function () { await render(hbs`{{on-key 'shift+c' this.onTrigger event='keypress'}}`); }); - test('triggers on keypress', async function(assert) { + test('triggers on keypress', async function (assert) { await keyPress('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keydown or keyup', async function(assert) { + test('does not trigger on keydown or keyup', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -183,25 +192,27 @@ module('Integration | Helper | on-key', function(hooks) { }); }); - module('activated param', function(hooks) { - hooks.beforeEach(function() { + module('activated param', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); this.renderWithActivated = () => { - return render(hbs`{{on-key 'shift+c' this.onTrigger activated=this.isActivated}}`); - } + return render( + hbs`{{on-key 'shift+c' this.onTrigger activated=this.isActivated}}` + ); + }; }); - test('does not trigger if helper is not activated', async function(assert) { + test('does not trigger if helper is not activated', async function (assert) { await this.renderWithActivated(); await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('triggers if helper is activated', async function(assert) { + test('triggers if helper is activated', async function (assert) { await this.renderWithActivated(); this.set('isActivated', true); await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger if helper is no longer activated', async function(assert) { + test('does not trigger if helper is no longer activated', async function (assert) { this.set('shouldRenderOnKeyHelper', true); await this.renderWithActivated(); await this.set('isActivated', false); @@ -210,21 +221,24 @@ module('Integration | Helper | on-key', function(hooks) { }); }); - module('error cases', function(hooks) { + module('error cases', function (hooks) { hooks.afterEach(() => resetOnerror()); if (gte('3.10.0')) { - test('errors if invoked without a handler', async function(assert) { + test('errors if invoked without a handler', async function (assert) { assert.expect(1); - setupOnerror(function(error) { + setupOnerror(function (error) { assert.strictEqual( error.message, - "Assertion Failed: ember-keyboard: You must pass a function as the second argument to the `on-key` helper", + 'Assertion Failed: ember-keyboard: You must pass a function as the second argument to the `on-key` helper', 'error is thrown' ); }); await render(hbs`{{on-key "alt+a" this.doesNotExist}}`); - await triggerEvent(document.body, 'keydown', { altKey: true, key: 'c' }); + await triggerEvent(document.body, 'keydown', { + altKey: true, + key: 'c', + }); }); } }); diff --git a/tests/integration/modifiers/on-key-test.js b/tests/integration/modifiers/on-key-test.js index bc4450c7e..4e94be6c3 100644 --- a/tests/integration/modifiers/on-key-test.js +++ b/tests/integration/modifiers/on-key-test.js @@ -2,41 +2,47 @@ import { module, test } from 'qunit'; import { setupRenderingTest } from 'ember-qunit'; import { focus, render, triggerEvent } from '@ember/test-helpers'; import { hbs } from 'ember-cli-htmlbars'; -import { keyDown, keyPress, keyUp } from 'ember-keyboard/test-support/test-helpers'; +import { + keyDown, + keyPress, + keyUp, +} from 'ember-keyboard/test-support/test-helpers'; -module('Integration | Modifier | on-key', function(hooks) { +module('Integration | Modifier | on-key', function (hooks) { setupRenderingTest(hooks); let onTriggerCalled; - hooks.beforeEach(function() { + hooks.beforeEach(function () { onTriggerCalled = false; this.set('onTrigger', () => { onTriggerCalled = true; }); }); - module('when used with an input element', function(/* hooks */) { - module('unspecified event param', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('when used with an input element', function (/* hooks */) { + module('unspecified event param', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('input[type="text"]'); }); - test('triggers on keydown by default', async function(assert) { + test('triggers on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); await keyPress('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('called with event', async function(assert) { + test('called with event', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; @@ -45,8 +51,8 @@ module('Integration | Modifier | on-key', function(hooks) { assert.ok(onTriggerCalledWith instanceof KeyboardEvent); }); }); - module('when element does not have focus', function(/* hooks */) { - test('does not trigger on keydown, keyup, or keypress', async function(assert) { + module('when element does not have focus', function (/* hooks */) { + test('does not trigger on keydown, keyup, or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -58,20 +64,22 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); }); - module('with event="keydown"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); - }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('with event="keydown"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); + }); + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('input[type="text"]'); }); - test('triggers on keydown', async function(assert) { + test('triggers on keydown', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -79,8 +87,8 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('when element does not have focus', function() { - test('does not trigger on keydown, keyup, or keypress', async function(assert) { + module('when element does not have focus', function () { + test('does not trigger on keydown, keyup, or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -92,20 +100,22 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); }); - module('with event="keyup"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); - }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('with event="keyup"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); + }); + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('input[type="text"]'); }); - test('triggers on keyup', async function(assert) { + test('triggers on keyup', async function (assert) { await keyUp('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keydown or keypress', async function(assert) { + test('does not trigger on keydown or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -113,8 +123,8 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('when element does not have focus', function(/* hooks */) { - test('does not trigger on keydown, keyup, or keypress', async function(assert) { + module('when element does not have focus', function (/* hooks */) { + test('does not trigger on keydown, keyup, or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -126,20 +136,22 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); }); - module('with event="keypress"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); - }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('with event="keypress"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); + }); + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('input[type="text"]'); }); - test('triggers on keypress', async function(assert) { + test('triggers on keypress', async function (assert) { await keyPress('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keydown or keyup', async function(assert) { + test('does not trigger on keydown or keyup', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -147,8 +159,8 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('when element does not have focus', function(/* hooks */) { - test('does not trigger on keydown, keyup, or keypress', async function(assert) { + module('when element does not have focus', function (/* hooks */) { + test('does not trigger on keydown, keyup, or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -160,23 +172,25 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); }); - module('activated param', function(hooks) { - hooks.beforeEach(function() { + module('activated param', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); this.renderWithActivated = () => { - return render(hbs``); - } + return render( + hbs`` + ); + }; }); - module('with activated=false', function(hooks) { - hooks.beforeEach(function() { + module('with activated=false', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); return this.renderWithActivated(); }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('input[type="text"]'); }); - test('does not trigger on keydown, keyup or keypress', async function(assert) { + test('does not trigger on keydown, keyup or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -187,11 +201,11 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('when element does not have focus', function(hooks) { - hooks.beforeEach(async function() { + module('when element does not have focus', function (hooks) { + hooks.beforeEach(async function () { await focus('input[type="text"]'); }); - test('does not trigger on keydown, keyup or keypress', async function(assert) { + test('does not trigger on keydown, keyup or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -203,21 +217,21 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); }); - module('with activated=true', function(hooks) { - hooks.beforeEach(function() { + module('with activated=true', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', true); return this.renderWithActivated(); }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('input[type="text"]'); }); - test('triggers on keydown by default', async function(assert) { + test('triggers on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -225,8 +239,8 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('when element does not have focus', function(/* hooks */) { - test('does not trigger on keydown, keyup or keypress', async function(assert) { + module('when element does not have focus', function (/* hooks */) { + test('does not trigger on keydown, keyup or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -241,22 +255,24 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); - module('when used with a textarea element', function(hooks) { + module('when used with a textarea element', function (hooks) { // Behavior is the same as with input element. That scenario has thorough // tests above. This is a basic smoketest. - hooks.beforeEach(async function() { - await render(hbs``); + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('textarea'); }); - test('triggers on keydown by default', async function(assert) { + test('triggers on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -264,8 +280,8 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('when element does not have focus', function(/* hooks */) { - test('does not trigger on keydown, keyup, or keypress', async function(assert) { + module('when element does not have focus', function (/* hooks */) { + test('does not trigger on keydown, keyup, or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -278,22 +294,22 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); - module('when used with a select element', function(hooks) { + module('when used with a select element', function (hooks) { // Behavior is the same as with input element. That scenario has thorough // tests above. This is a basic smoketest. - hooks.beforeEach(async function() { + hooks.beforeEach(async function () { await render(hbs``); }); - module('when element has focus', function(hooks) { - hooks.beforeEach(async function() { + module('when element has focus', function (hooks) { + hooks.beforeEach(async function () { await focus('select'); }); - test('triggers on keydown by default', async function(assert) { + test('triggers on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -301,8 +317,8 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('when element does not have focus', function(/* hooks */) { - test('does not trigger on keydown, keyup, or keypress', async function(assert) { + module('when element does not have focus', function (/* hooks */) { + test('does not trigger on keydown, keyup, or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -315,18 +331,20 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); - module('when used with a button element', function(/* hooks */) { - module('with no action specified', function(/* hooks */) { - module('unspecified event param', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('when used with a button element', function (/* hooks */) { + module('with no action specified', function (/* hooks */) { + module('unspecified event param', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers click on element on keydown by default', async function(assert) { + test('triggers click on element on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -334,7 +352,7 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('called without keyboard event', async function(assert) { + test('called without keyboard event', async function (assert) { let onTriggerCalledWith; this.set('onTrigger', (ev) => { onTriggerCalledWith = ev; @@ -343,16 +361,18 @@ module('Integration | Modifier | on-key', function(hooks) { assert.ok(onTriggerCalledWith instanceof MouseEvent); }); }); - module('with event="keydown"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('with event="keydown"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers click on keydown', async function(assert) { + test('triggers click on keydown', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger a click on keyup or keypress', async function(assert) { + test('does not trigger a click on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -360,16 +380,18 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('with event="keyup"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('with event="keyup"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers click on element on keyup', async function(assert) { + test('triggers click on element on keyup', async function (assert) { await keyUp('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keydown or keypress', async function(assert) { + test('does not trigger on keydown or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -377,16 +399,18 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('with event="keypress"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('with event="keypress"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers click on element on keypress', async function(assert) { + test('triggers click on element on keypress', async function (assert) { await keyPress('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keydown or keyup', async function(assert) { + test('does not trigger on keydown or keyup', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -394,19 +418,21 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('activated param', function(hooks) { - hooks.beforeEach(function() { + module('activated param', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); this.renderWithActivated = () => { - return render(hbs``); - } + return render( + hbs`` + ); + }; }); - module('with activated=false', function(hooks) { - hooks.beforeEach(function() { + module('with activated=false', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); return this.renderWithActivated(); }); - test('does not trigger on keydown, keyup or keypress', async function(assert) { + test('does not trigger on keydown, keyup or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -416,7 +442,7 @@ module('Integration | Modifier | on-key', function(hooks) { await keyPress('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); }); - test('after set activated back to true, triggers', async function(assert) { + test('after set activated back to true, triggers', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -426,17 +452,17 @@ module('Integration | Modifier | on-key', function(hooks) { assert.ok(onTriggerCalled, 'triggers action'); }); }); - module('with activated=true', function(hooks) { - hooks.beforeEach(function() { + module('with activated=true', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', true); return this.renderWithActivated(); }); - test('triggers element click on keydown by default', async function(assert) { + test('triggers element click on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -446,24 +472,26 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); }); - module('with an action specified', function(hooks) { + module('with an action specified', function (hooks) { let onTriggerClickCalled; - hooks.beforeEach(function() { + hooks.beforeEach(function () { onTriggerClickCalled = false; this.set('onTriggerClick', () => { onTriggerClickCalled = true; }); }); - module('unspecified event param', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('unspecified event param', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers action on keydown by default', async function(assert) { + test('triggers action on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -473,16 +501,18 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); }); - module('with event="keydown"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('with event="keydown"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers action on keydown', async function(assert) { + test('triggers action on keydown', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('does not trigger a click on keyup or keypress', async function(assert) { + test('does not trigger a click on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -492,16 +522,18 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); }); - module('with event="keyup"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('with event="keyup"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers action on keyup', async function(assert) { + test('triggers action on keyup', async function (assert) { await keyUp('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('does not trigger on keydown or keypress', async function(assert) { + test('does not trigger on keydown or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -511,16 +543,18 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); }); - module('with event="keypress"', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs``); + module('with event="keypress"', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`` + ); }); - test('triggers action on keypress', async function(assert) { + test('triggers action on keypress', async function (assert) { await keyPress('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('does not trigger on keydown or keyup', async function(assert) { + test('does not trigger on keydown or keyup', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -530,19 +564,21 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); }); - module('activated param', function(hooks) { - hooks.beforeEach(function() { + module('activated param', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); this.renderWithActivated = () => { - return render(hbs``); - } + return render( + hbs`` + ); + }; }); - module('with activated=false', function(hooks) { - hooks.beforeEach(function() { + module('with activated=false', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', false); return this.renderWithActivated(); }); - test('does not trigger on keydown, keyup or keypress', async function(assert) { + test('does not trigger on keydown, keyup or keypress', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -555,7 +591,7 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('after set activated back to true, triggers', async function(assert) { + test('after set activated back to true, triggers', async function (assert) { await keyDown('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -567,17 +603,17 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); }); - module('with activated=true', function(hooks) { - hooks.beforeEach(function() { + module('with activated=true', function (hooks) { + hooks.beforeEach(function () { this.set('isActivated', true); return this.renderWithActivated(); }); - test('triggers on keydown by default', async function(assert) { + test('triggers on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -588,9 +624,9 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); }); - module('stopping propagation', function(hooks) { + module('stopping propagation', function (hooks) { let triggered; - hooks.beforeEach(function() { + hooks.beforeEach(function () { const keyboardService = this.owner.lookup('service:keyboard'); keyboardService.set('isPropagationEnabled', true); triggered = []; @@ -603,60 +639,74 @@ module('Integration | Modifier | on-key', function(hooks) { ekEvent.stopImmediatePropagation(); } }); - }); - test('stopPropagation+stopImmediatePropagation', async function(assert) { + }); + test('stopPropagation+stopImmediatePropagation', async function (assert) { await render(hbs` `); - await triggerEvent(document.body, 'keydown', { altKey: true, key: 'a' }); + await triggerEvent(document.body, 'keydown', { + altKey: true, + key: 'a', + }); assert.deepEqual(triggered, ['A2a']); }); - test('stopPropagation', async function(assert) { + test('stopPropagation', async function (assert) { await render(hbs` `); - await triggerEvent(document.body, 'keydown', { altKey: true, key: 'a' }); + await triggerEvent(document.body, 'keydown', { + altKey: true, + key: 'a', + }); assert.deepEqual(triggered, ['A2a', 'A2b']); }); - test('stopImmediatePropagation', async function(assert) { + test('stopImmediatePropagation', async function (assert) { await render(hbs` `); - await triggerEvent(document.body, 'keydown', { altKey: true, key: 'a' }); + await triggerEvent(document.body, 'keydown', { + altKey: true, + key: 'a', + }); assert.deepEqual(triggered, ['A2a', 'A1']); }); - test('no stopping', async function(assert) { + test('no stopping', async function (assert) { await render(hbs` `); - await triggerEvent(document.body, 'keydown', { altKey: true, key: 'a' }); + await triggerEvent(document.body, 'keydown', { + altKey: true, + key: 'a', + }); assert.deepEqual(triggered, ['A2a', 'A2b', 'A1']); }); }); }); }); - module('when used with an `a` element', function() { + module('when used with an `a` element', function () { // Behavior is the same as with button element. That scenario has thorough // tests above. This is a basic smoketest. - module('with no action specified', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs`Hello`); + module('with no action specified', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`Hello` + ); }); - test('triggers click on element on keydown by default', async function(assert) { + test('triggers click on element on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -664,23 +714,25 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('with an action specified', function(hooks) { + module('with an action specified', function (hooks) { let onTriggerClickCalled; - hooks.beforeEach(function() { + hooks.beforeEach(function () { onTriggerClickCalled = false; this.set('onTriggerClick', () => { onTriggerClickCalled = true; }); }); - hooks.beforeEach(async function() { - await render(hbs`Hello`); + hooks.beforeEach(async function () { + await render( + hbs`Hello` + ); }); - test('triggers action on keydown by default', async function(assert) { + test('triggers action on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); @@ -692,19 +744,21 @@ module('Integration | Modifier | on-key', function(hooks) { }); }); - module('when used with a `div` element', function() { + module('when used with a `div` element', function () { // Behavior is the same as with button element. That scenario has thorough // tests above. This is a basic smoketest. - module('with no action specified', function(hooks) { - hooks.beforeEach(async function() { - await render(hbs`
`); + module('with no action specified', function (hooks) { + hooks.beforeEach(async function () { + await render( + hbs`
` + ); }); - test('triggers click on element on keydown by default', async function(assert) { + test('triggers click on element on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); @@ -712,24 +766,28 @@ module('Integration | Modifier | on-key', function(hooks) { assert.notOk(onTriggerCalled, 'does not trigger action'); }); }); - module('with an action specified', function(hooks) { + module('with an action specified', function (hooks) { let onTriggerClickCalled; - hooks.beforeEach(function() { + hooks.beforeEach(function () { onTriggerClickCalled = false; this.set('onTriggerClick', () => { onTriggerClickCalled = true; }); }); - hooks.beforeEach(async function() { - await render(hbs`
`); - await render(hbs`Hello`); + hooks.beforeEach(async function () { + await render( + hbs`
` + ); + await render( + hbs`Hello` + ); }); - test('triggers action on keydown by default', async function(assert) { + test('triggers action on keydown by default', async function (assert) { await keyDown('shift+c'); assert.ok(onTriggerCalled, 'triggers action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); }); - test('does not trigger on keyup or keypress', async function(assert) { + test('does not trigger on keyup or keypress', async function (assert) { await keyUp('shift+c'); assert.notOk(onTriggerCalled, 'does not trigger action'); assert.notOk(onTriggerClickCalled, 'does not trigger click'); diff --git a/tests/integration/utils/trigger-event-test.js b/tests/integration/utils/trigger-event-test.js index 29f160ffc..c81316acd 100644 --- a/tests/integration/utils/trigger-event-test.js +++ b/tests/integration/utils/trigger-event-test.js @@ -2,18 +2,14 @@ import { module, test } from 'qunit'; import { setupRenderingTest } from 'ember-qunit'; import { render } from '@ember/test-helpers'; import hbs from 'htmlbars-inline-precompile'; -import { - triggerKeyDown, - triggerKeyPress, - triggerKeyUp, -} from 'ember-keyboard'; +import { triggerKeyDown, triggerKeyPress, triggerKeyUp } from 'ember-keyboard'; import { hook } from '../../helpers/hook'; -module('Integration | Util | triggerEvent', function(hooks) { +module('Integration | Util | triggerEvent', function (hooks) { setupRenderingTest(hooks); - test('`keyDown` triggers a keydown event', async function(assert) { + test('`keyDown` triggers a keydown event', async function (assert) { assert.expect(4); await render(hbs``); @@ -21,12 +17,14 @@ module('Integration | Util | triggerEvent', function(hooks) { triggerKeyDown('KeyA'); assert.dom(hook('key_down')).hasText('true', 'keyDown was triggered'); - assert.dom(hook('key_down_with_mods')).hasText('false', 'keyDown was triggered with mods'); + assert + .dom(hook('key_down_with_mods')) + .hasText('false', 'keyDown was triggered with mods'); assert.dom(hook('key_press')).hasText('false', 'keyPress was triggered'); assert.dom(hook('key_up')).hasText('false', 'keyUp was triggered'); }); - test('`keyPress` triggers a keypress event', async function(assert) { + test('`keyPress` triggers a keypress event', async function (assert) { assert.expect(4); await render(hbs``); @@ -34,12 +32,14 @@ module('Integration | Util | triggerEvent', function(hooks) { triggerKeyPress('KeyA'); assert.dom(hook('key_down')).hasText('false', 'keyDown was triggered'); - assert.dom(hook('key_down_with_mods')).hasText('false', 'keyDown was triggered with mods'); + assert + .dom(hook('key_down_with_mods')) + .hasText('false', 'keyDown was triggered with mods'); assert.dom(hook('key_press')).hasText('true', 'keyPress was triggered'); assert.dom(hook('key_up')).hasText('false', 'keyUp was triggered'); }); - test('`keyUp` triggers a keyup event', async function(assert) { + test('`keyUp` triggers a keyup event', async function (assert) { assert.expect(4); await render(hbs``); @@ -47,12 +47,14 @@ module('Integration | Util | triggerEvent', function(hooks) { triggerKeyUp('KeyA'); assert.dom(hook('key_down')).hasText('false', 'keyDown was triggered'); - assert.dom(hook('key_down_with_mods')).hasText('false', 'keyDown was triggered with mods'); + assert + .dom(hook('key_down_with_mods')) + .hasText('false', 'keyDown was triggered with mods'); assert.dom(hook('key_press')).hasText('false', 'keyPress was triggered'); assert.dom(hook('key_up')).hasText('true', 'keyUp was triggered'); }); - test('modifiers can be added', async function(assert) { + test('modifiers can be added', async function (assert) { assert.expect(4); await render(hbs``); @@ -60,7 +62,9 @@ module('Integration | Util | triggerEvent', function(hooks) { triggerKeyDown('shift+KeyA+cmd'); assert.dom(hook('key_down')).hasText('false', 'keyDown was triggered'); - assert.dom(hook('key_down_with_mods')).hasText('true', 'keyDown was triggered with mods'); + assert + .dom(hook('key_down_with_mods')) + .hasText('true', 'keyDown was triggered with mods'); assert.dom(hook('key_press')).hasText('false', 'keyPress was triggered'); assert.dom(hook('key_up')).hasText('false', 'keyUp was triggered'); }); diff --git a/tests/unit/listeners/key-events-test.js b/tests/unit/listeners/key-events-test.js index ee34604ba..af83e3d1d 100644 --- a/tests/unit/listeners/key-events-test.js +++ b/tests/unit/listeners/key-events-test.js @@ -1,16 +1,24 @@ import { keyDown, keyUp } from 'ember-keyboard'; import { module, test } from 'qunit'; -module('Unit | Listener | key events', function() { - test('`keyDown` sorts the provided keys and prefixes `keydown:`', function(assert) { +module('Unit | Listener | key events', function () { + test('`keyDown` sorts the provided keys and prefixes `keydown:`', function (assert) { const result = keyDown('m+shift+ctrl'); - assert.strictEqual(result, 'keydown:ctrl+m+shift', 'it returns the correct value'); + assert.strictEqual( + result, + 'keydown:ctrl+m+shift', + 'it returns the correct value' + ); }); - test('`keyUp` sorts the provided keys and prefixes `keyup:`', function(assert) { + test('`keyUp` sorts the provided keys and prefixes `keyup:`', function (assert) { const result = keyUp('m+shift+ctrl'); - assert.strictEqual(result, 'keyup:ctrl+m+shift', 'it returns the correct value'); + assert.strictEqual( + result, + 'keyup:ctrl+m+shift', + 'it returns the correct value' + ); }); }); diff --git a/tests/unit/services/keyboard-test.js b/tests/unit/services/keyboard-test.js index 188b07580..2527ab2f9 100644 --- a/tests/unit/services/keyboard-test.js +++ b/tests/unit/services/keyboard-test.js @@ -1,15 +1,15 @@ import { module, test } from 'qunit'; import { setupTest } from 'ember-qunit'; -module('Unit | Service | keyboard', function(hooks) { +module('Unit | Service | keyboard', function (hooks) { setupTest(hooks); let service; - hooks.beforeEach(function() { + hooks.beforeEach(function () { service = this.owner.lookup('service:keyboard'); }); - hooks.afterEach(function() { + hooks.afterEach(function () { let { registeredResponders } = service; let responder; for (responder of registeredResponders) { @@ -17,89 +17,105 @@ module('Unit | Service | keyboard', function(hooks) { } }); - test('`activeResponders` is a filtered list of registeredResponders with keyboardActivated true', function(assert) { + test('`activeResponders` is a filtered list of registeredResponders with keyboardActivated true', function (assert) { service.register({ keyboardActivated: true }); service.register({ keyboardActivated: false }); service.register({ keyboardActivated: true }); - assert.strictEqual(service.activeResponders.length, 2, 'correct number of responders'); + assert.strictEqual( + service.activeResponders.length, + 2, + 'correct number of responders' + ); }); - test('`sortedResponders` sorts by keyboardPriority', function(assert) { + test('`sortedResponders` sorts by keyboardPriority', function (assert) { service.register({ keyboardActivated: true, - keyboardPriority: 0 + keyboardPriority: 0, }); service.register({ keyboardActivated: true, - keyboardPriority: -1 + keyboardPriority: -1, }); service.register({ keyboardActivated: false, - keyboardPriority: 50 + keyboardPriority: 50, }); service.register({ keyboardActivated: true, keyboardPriority: 0, - keyboardFirstResponder: true + keyboardFirstResponder: true, }); service.register({ keyboardActivated: true, - keyboardPriority: 1 + keyboardPriority: 1, }); - assert.deepEqual(service.sortedResponders.map(r => r.keyboardPriority), [1, 0, 0, -1], 'correct sorting'); + assert.deepEqual( + service.sortedResponders.map((r) => r.keyboardPriority), + [1, 0, 0, -1], + 'correct sorting' + ); }); - test('`firstResponders` sorts by keyboardPriority and filters by keyboardFirstResponder', function(assert) { + test('`firstResponders` sorts by keyboardPriority and filters by keyboardFirstResponder', function (assert) { service.register({ keyboardActivated: true, - keyboardPriority: 0 + keyboardPriority: 0, }); service.register({ keyboardActivated: true, - keyboardPriority: -1 + keyboardPriority: -1, }); service.register({ keyboardActivated: false, - keyboardPriority: 50 + keyboardPriority: 50, }); service.register({ keyboardActivated: true, keyboardPriority: 0, - keyboardFirstResponder: true + keyboardFirstResponder: true, }); service.register({ keyboardActivated: true, - keyboardPriority: 1 + keyboardPriority: 1, }); - assert.deepEqual(service.firstResponders.map(r => r.keyboardPriority), [0], 'correct sorting'); + assert.deepEqual( + service.firstResponders.map((r) => r.keyboardPriority), + [0], + 'correct sorting' + ); }); - test('`normalResponders` sorts by keyboardPriority and filter out by keyboardFirstResponder', function(assert) { + test('`normalResponders` sorts by keyboardPriority and filter out by keyboardFirstResponder', function (assert) { service.register({ keyboardActivated: true, - keyboardPriority: 0 + keyboardPriority: 0, }); service.register({ keyboardActivated: true, - keyboardPriority: -1 + keyboardPriority: -1, }); service.register({ keyboardActivated: false, - keyboardPriority: 50 + keyboardPriority: 50, }); service.register({ keyboardActivated: true, keyboardPriority: 0, - keyboardFirstResponder: true + keyboardFirstResponder: true, }); service.register({ keyboardActivated: true, - keyboardPriority: 1 + keyboardPriority: 1, }); - assert.deepEqual(service.normalResponders.map(r => r.keyboardPriority), [1, 0, -1], 'correct sorting'); + assert.deepEqual( + service.normalResponders.map((r) => r.keyboardPriority), + [1, 0, -1], + 'correct sorting' + ); }); // It would be nice to test that tearing down this service removes the installed diff --git a/tests/unit/utils/get-cmd-key-test.js b/tests/unit/utils/get-cmd-key-test.js index 35f18e350..0d8aa3b3a 100644 --- a/tests/unit/utils/get-cmd-key-test.js +++ b/tests/unit/utils/get-cmd-key-test.js @@ -1,23 +1,23 @@ import getCmdKey from 'ember-keyboard/utils/get-cmd-key'; import { module, test } from 'qunit'; -module('Unit | Utility | get cmd key', function() { - test('it returns ctrl for windows', function(assert) { +module('Unit | Utility | get cmd key', function () { + test('it returns ctrl for windows', function (assert) { const result = getCmdKey('Windows'); assert.strictEqual(result, 'ctrl'); }); - test('it returns ctrl for linux', function(assert) { + test('it returns ctrl for linux', function (assert) { const result = getCmdKey('Linux'); assert.strictEqual(result, 'ctrl'); }); - test('it defaults to ctlr for unexpected platform', function(assert) { + test('it defaults to ctlr for unexpected platform', function (assert) { const result = getCmdKey('NeXTSTEP'); assert.strictEqual(result, 'ctrl'); }); - test('it returns meta (command) for macOS', function(assert) { + test('it returns meta (command) for macOS', function (assert) { const result = getCmdKey('MacIntel'); assert.strictEqual(result, 'meta'); }); diff --git a/tests/unit/utils/is-key-test.js b/tests/unit/utils/is-key-test.js index ce7417c3b..489dca97d 100644 --- a/tests/unit/utils/is-key-test.js +++ b/tests/unit/utils/is-key-test.js @@ -1,12 +1,15 @@ import { module, skip, test } from 'qunit'; import isKey from 'ember-keyboard/utils/is-key'; -import getPlatform from "ember-keyboard/utils/platform"; +import getPlatform from 'ember-keyboard/utils/platform'; -const WINDOWS_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'; -const MAC_UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'; -const LINUX_UA = 'Mozilla/5.0 (X11; Datanyze; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36'; +const WINDOWS_UA = + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'; +const MAC_UA = + 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36'; +const LINUX_UA = + 'Mozilla/5.0 (X11; Datanyze; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36'; -module('Unit | Utility | isKey', function() { +module('Unit | Utility | isKey', function () { let table = ` | keydown event | result listenerName platform | alt ctrl meta shift key code | expected pending note @@ -53,22 +56,28 @@ module('Unit | Utility | isKey', function() { keydown:cmd+c win | F F F T c KeyC | F F keydown:+ win | F F F F + BracketRight | T F plus key with german language `; - for (let line of table.split("\n").map(line => line.trim().replace(/\|/g, ''))) { - if (line === '' || line.match(/^listenerName|keydown event|---/)) { continue; } // blank or header row + for (let line of table + .split('\n') + .map((line) => line.trim().replace(/\|/g, ''))) { + if (line === '' || line.match(/^listenerName|keydown event|---/)) { + continue; + } // blank or header row buildTestFromLine(line); } - test('should match mousedown event for alt+right with right button mousedown and modifiers alt on win', async function(assert) { + test('should match mousedown event for alt+right with right button mousedown and modifiers alt on win', async function (assert) { let fakeEvent = new MouseEvent('mousedown', { button: 2, altKey: true }); assert.ok(isKey('mousedown:alt+right', fakeEvent, getPlatform(WINDOWS_UA))); }); - test('should not match mousedown event for alt+right with left button mousedown and modifiers alt on win', async function(assert) { + test('should not match mousedown event for alt+right with left button mousedown and modifiers alt on win', async function (assert) { let fakeEvent = new MouseEvent('mousedown', { button: 0, altKey: true }); - assert.notOk(isKey('mousedown:alt+right', fakeEvent, getPlatform(WINDOWS_UA))); + assert.notOk( + isKey('mousedown:alt+right', fakeEvent, getPlatform(WINDOWS_UA)) + ); }); - test('should match mousedown event for cmd+middle with middle button mousedown and modifiers meta on mac', async function(assert) { + test('should match mousedown event for cmd+middle with middle button mousedown and modifiers meta on mac', async function (assert) { let fakeEvent = new MouseEvent('mouseup', { button: 1, metaKey: true }); assert.ok(isKey('mouseup:cmd+middle', fakeEvent, getPlatform(MAC_UA))); }); @@ -81,7 +90,19 @@ function stringToBoolean(s) { } function buildTestFromLine(line) { - let [listenerName,plat,alt,ctrl,meta,shift,key,code,expected,pending,...note] = line.split(/\s+/); + let [ + listenerName, + plat, + alt, + ctrl, + meta, + shift, + key, + code, + expected, + pending, + ...note + ] = line.split(/\s+/); let altKey = stringToBoolean(alt); let ctrlKey = stringToBoolean(ctrl); let metaKey = stringToBoolean(meta); @@ -109,7 +130,7 @@ function buildTestFromLine(line) { modifiers.push('shift'); } let userAgent; - switch(plat) { + switch (plat) { case 'win': userAgent = WINDOWS_UA; break; @@ -122,14 +143,29 @@ function buildTestFromLine(line) { } testDescription += modifiers.join('+') + ` on ${plat}`; let testFunc = isPending ? skip : test; - testFunc(testDescription, async function(assert) { - let fakeEvent = new KeyboardEvent('keydown', { key, code, altKey, ctrlKey, metaKey, shiftKey }); + testFunc(testDescription, async function (assert) { + let fakeEvent = new KeyboardEvent('keydown', { + key, + code, + altKey, + ctrlKey, + metaKey, + shiftKey, + }); if (expectedResult) { let expectedTriggerMessage = `should match${note ? ', ' + note : ''}`; - assert.ok(isKey(listenerName, fakeEvent, getPlatform(userAgent)), expectedTriggerMessage); + assert.ok( + isKey(listenerName, fakeEvent, getPlatform(userAgent)), + expectedTriggerMessage + ); } else { - let expectedNoTriggerMessage = `should not match${note ? ', ' + note : ''}`; - assert.ok(!isKey(listenerName, fakeEvent, getPlatform(userAgent)), expectedNoTriggerMessage); + let expectedNoTriggerMessage = `should not match${ + note ? ', ' + note : '' + }`; + assert.ok( + !isKey(listenerName, fakeEvent, getPlatform(userAgent)), + expectedNoTriggerMessage + ); } }); } diff --git a/tests/unit/utils/listener-name-test.js b/tests/unit/utils/listener-name-test.js index 8cf541097..0ec43c644 100644 --- a/tests/unit/utils/listener-name-test.js +++ b/tests/unit/utils/listener-name-test.js @@ -2,32 +2,40 @@ import { module, test } from 'qunit'; import listenerName from 'ember-keyboard/utils/listener-name'; import getCmdKey from 'ember-keyboard/utils/get-cmd-key'; -module('Unit | Utility | listener name', function() { - test('it returns a sorted list of keys (with modifier) after the event name', function(assert) { +module('Unit | Utility | listener name', function () { + test('it returns a sorted list of keys (with modifier) after the event name', function (assert) { const result = listenerName('keydown', ['c', 'alt', 'shift']); - assert.strictEqual(result, 'keydown:alt+c+shift', 'name is correctly formatted'); + assert.strictEqual( + result, + 'keydown:alt+c+shift', + 'name is correctly formatted' + ); }); - test('it can be passed a string instead of an array of keys', function(assert) { + test('it can be passed a string instead of an array of keys', function (assert) { const result = listenerName('keydown', 'shift+alt+c'); - assert.strictEqual(result, 'keydown:alt+c+shift', 'name is correctly formatted'); + assert.strictEqual( + result, + 'keydown:alt+c+shift', + 'name is correctly formatted' + ); }); - test('it returns a sorted list of keys after the event name', function(assert) { + test('it returns a sorted list of keys after the event name', function (assert) { const result = listenerName('keydown', ['c', 'a', 'b']); assert.strictEqual(result, 'keydown:a+b+c', 'name is correctly formatted'); }); - test('it returns `_all` if the keys array is empty', function(assert) { + test('it returns `_all` if the keys array is empty', function (assert) { const result = listenerName('keydown'); assert.strictEqual(result, 'keydown:_all', 'name is correctly formatted'); }); - test('it replaces cmd with the platform appropriate key', function(assert) { + test('it replaces cmd with the platform appropriate key', function (assert) { const result = listenerName('keydown', ['Enter', 'cmd']); assert.strictEqual(result, `keydown:Enter+${getCmdKey()}`); diff --git a/yarn.lock b/yarn.lock index 510a86888..a11b73616 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1233,15 +1233,15 @@ semver "^7.3.2" typescript-memoize "^1.0.0-alpha.3" -"@eslint/eslintrc@^0.4.1": - version "0.4.1" - resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.1.tgz#442763b88cecbe3ee0ec7ca6d6dd6168550cbf14" - integrity sha512-5v7TDE9plVhvxQeWLXDTvFvJBdH6pEsdnl2g/dAptmuFEPedQ4Erq5rsDsX+mvAM610IhNaO2W5V1dOOnDKxkQ== +"@eslint/eslintrc@^0.4.3": + version "0.4.3" + resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.3.tgz#9e42981ef035beb3dd49add17acb96e8ff6f394c" + integrity sha512-J6KFFz5QCYUJq3pf0mjEcCJVERbzv71PUIDczuh9JkwGEzced6CO5ADLHB1rbf/+oPBtoPfMYNOpGDzCANlbXw== dependencies: ajv "^6.12.4" debug "^4.1.1" espree "^7.3.0" - globals "^12.1.0" + globals "^13.9.0" ignore "^4.0.6" import-fresh "^3.2.1" js-yaml "^3.13.1" @@ -1438,6 +1438,20 @@ resolved "https://registry.yarnpkg.com/@handlebars/parser/-/parser-1.1.0.tgz#d6dbc7574774b238114582410e8fee0dc3532bdf" integrity sha512-rR7tJoSwJ2eooOpYGxGGW95sLq6GXUaS1UtWvN7pei6n2/okYvCGld9vsUTvkl2migxbkszsycwtMf/GEc1k1A== +"@humanwhocodes/config-array@^0.5.0": + version "0.5.0" + resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.5.0.tgz#1407967d4c6eecd7388f83acf1eaf4d0c6e58ef9" + integrity sha512-FagtKFz74XrTl7y6HCzQpwDfXP0yhxe9lHLD1UZxjvZIcbyRz8zTFF/yYNfSfzU414eDwZ1SrO0Qvtyf+wFMQg== + dependencies: + "@humanwhocodes/object-schema" "^1.2.0" + debug "^4.1.1" + minimatch "^3.0.4" + +"@humanwhocodes/object-schema@^1.2.0": + version "1.2.1" + resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45" + integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA== + "@iarna/toml@2.2.5": version "2.2.5" resolved "https://registry.yarnpkg.com/@iarna/toml/-/toml-2.2.5.tgz#b32366c89b43c6f8cefbdefac778b9c828e3ba8c" @@ -5869,6 +5883,11 @@ escodegen@^1.14.1: optionalDependencies: source-map "~0.6.1" +eslint-config-prettier@^8.3.0: + version "8.3.0" + resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-8.3.0.tgz#f7471b20b6fe8a9a9254cc684454202886a2dd7a" + integrity sha512-BgZuLUSeKzvlL/VUjx/Yb787VQ26RU3gGjA3iiFvdsp/2bMfVIWUVP7tjxtjS0e+HP409cPlPvNkQloz8C91ew== + eslint-plugin-ember@^10.4.2: version "10.5.7" resolved "https://registry.yarnpkg.com/eslint-plugin-ember/-/eslint-plugin-ember-10.5.7.tgz#132dcd139fc9e830b707910d1ee4a458b83ab9d4" @@ -5903,6 +5922,13 @@ eslint-plugin-node@^11.1.0: resolve "^1.10.1" semver "^6.1.0" +eslint-plugin-prettier@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-4.0.0.tgz#8b99d1e4b8b24a762472b4567992023619cb98e0" + integrity sha512-98MqmCJ7vJodoQK359bqQWaxOE0CS8paAz/GgjaZLyex4TTk3g9HugoO89EqWCrFiOqn9EVvcoo7gZzONCWVwQ== + dependencies: + prettier-linter-helpers "^1.0.0" + eslint-plugin-qunit@^7.0.0: version "7.1.0" resolved "https://registry.yarnpkg.com/eslint-plugin-qunit/-/eslint-plugin-qunit-7.1.0.tgz#d0d4f9f9f2b9623953a4b7f1ca8a71f4aa7df2b7" @@ -5951,13 +5977,14 @@ eslint-visitor-keys@^2.0.0: resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.0.0.tgz#21fdc8fbcd9c795cc0321f0563702095751511a8" integrity sha512-QudtT6av5WXels9WjIM7qz1XD1cWGvX4gGXvp/zBn9nXG02D0utdU3Em2m/QjTnrsk6bBjmCygl3rmj118msQQ== -eslint@^7.27.0: - version "7.27.0" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.27.0.tgz#665a1506d8f95655c9274d84bd78f7166b07e9c7" - integrity sha512-JZuR6La2ZF0UD384lcbnd0Cgg6QJjiCwhMD6eU4h/VGPcVGwawNNzKU41tgokGXnfjOOyI6QIffthhJTPzzuRA== +eslint@^7.32.0: + version "7.32.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.32.0.tgz#c6d328a14be3fb08c8d1d21e12c02fdb7a2a812d" + integrity sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA== dependencies: "@babel/code-frame" "7.12.11" - "@eslint/eslintrc" "^0.4.1" + "@eslint/eslintrc" "^0.4.3" + "@humanwhocodes/config-array" "^0.5.0" ajv "^6.10.0" chalk "^4.0.0" cross-spawn "^7.0.2" @@ -5974,7 +6001,7 @@ eslint@^7.27.0: fast-deep-equal "^3.1.3" file-entry-cache "^6.0.1" functional-red-black-tree "^1.0.1" - glob-parent "^5.0.0" + glob-parent "^5.1.2" globals "^13.6.0" ignore "^4.0.6" import-fresh "^3.0.0" @@ -6256,6 +6283,11 @@ fast-deep-equal@^3.1.3: resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== +fast-diff@^1.1.2: + version "1.2.0" + resolved "https://registry.yarnpkg.com/fast-diff/-/fast-diff-1.2.0.tgz#73ee11982d86caaf7959828d519cfe927fac5f03" + integrity sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w== + fast-glob@^3.0.3, fast-glob@^3.1.1: version "3.2.2" resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.2.tgz#ade1a9d91148965d4bf7c51f72e1ca662d32e63d" @@ -6937,13 +6969,20 @@ glob-parent@^3.1.0: is-glob "^3.1.0" path-dirname "^1.0.0" -glob-parent@^5.0.0, glob-parent@^5.1.0, glob-parent@~5.1.0: +glob-parent@^5.1.0, glob-parent@~5.1.0: version "5.1.1" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.1.tgz#b6c1ef417c4e5663ea498f1c45afac6916bbc229" integrity sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ== dependencies: is-glob "^4.0.1" +glob-parent@^5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + glob-to-regexp@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e" @@ -7014,13 +7053,6 @@ globals@^11.1.0: resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e" integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== -globals@^12.1.0: - version "12.4.0" - resolved "https://registry.yarnpkg.com/globals/-/globals-12.4.0.tgz#a18813576a41b00a24a97e7f815918c2e19925f8" - integrity sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg== - dependencies: - type-fest "^0.8.1" - globals@^13.6.0: version "13.9.0" resolved "https://registry.yarnpkg.com/globals/-/globals-13.9.0.tgz#4bf2bf635b334a173fb1daf7c5e6b218ecdc06cb" @@ -7028,6 +7060,13 @@ globals@^13.6.0: dependencies: type-fest "^0.20.2" +globals@^13.9.0: + version "13.12.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-13.12.0.tgz#4d733760304230a0082ed96e21e5c565f898089e" + integrity sha512-uS8X6lSKN2JumVoXrbUz+uG4BYG+eiawqm3qFcT7ammfbUHeCBoJMlHcec/S3krSk73/AE/f0szYFmgAA3kYZg== + dependencies: + type-fest "^0.20.2" + globals@^9.18.0: version "9.18.0" resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a" @@ -10357,6 +10396,18 @@ prepend-http@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897" +prettier-linter-helpers@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b" + integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w== + dependencies: + fast-diff "^1.1.2" + +prettier@^2.4.1: + version "2.4.1" + resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.4.1.tgz#671e11c89c14a4cfc876ce564106c4a6726c9f5c" + integrity sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA== + printf@^0.5.1: version "0.5.3" resolved "https://registry.yarnpkg.com/printf/-/printf-0.5.3.tgz#8b7eec278d886833312238b2bf42b2b6f250880a" @@ -12399,11 +12450,6 @@ type-fest@^0.4.1: resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.4.1.tgz#8bdf77743385d8a4f13ba95f610f5ccd68c728f8" integrity sha512-IwzA/LSfD2vC1/YDYMv/zHP4rDF1usCwllsDpbolT3D4fUepIO7f9K70jjmUewU/LmGUKJcwcVtDCpnKk4BPMw== -type-fest@^0.8.1: - version "0.8.1" - resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d" - integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA== - type-is@~1.6.17, type-is@~1.6.18: version "1.6.18" resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131"