jab2870
/
Vim-Vixen
Archived
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Make key class

Browse Source
jh-changes
Shin'ya UEOKA 5 years ago
parent 620d4bc03e
commit 62a86c5253
8 changed files with 192 additions and 166 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/content/InputDriver.ts
  2. 2
      src/content/client/FollowMasterClient.ts
  3. 129
      src/content/domains/Key.ts
  4. 6
      src/content/domains/KeySequence.ts
  5. 18
      test/content/InputDriver.test.ts
  6. 140
      test/content/domains/Key.test.ts
  7. 35
      test/content/domains/KeySequence.test.ts
  8. 24
      test/content/repositories/KeymapRepository.test.ts

4
src/content/InputDriver.ts
Unescape View File

@ -1,5 +1,5 @@
import * as dom from '../shared/utils/dom'; import * as dom from '../shared/utils/dom';
import Key, * as keys from './domains/Key'; import Key from './domains/Key';
const cancelKey = (e: KeyboardEvent): boolean => { const cancelKey = (e: KeyboardEvent): boolean => {
if (e.key === 'Escape') { if (e.key === 'Escape') {
@ -66,7 +66,7 @@ export default class InputDriver {
return; return;
} }
let key = keys.fromKeyboardEvent(e); let key = Key.fromKeyboardEvent(e);
for (let listener of this.onKeyListeners) { for (let listener of this.onKeyListeners) {
let stop = listener(key); let stop = listener(key);
if (stop) { if (stop) {

2
src/content/client/FollowMasterClient.ts
Unescape View File

@ -35,7 +35,7 @@ export class FollowMasterClientImpl implements FollowMasterClient {
this.postMessage({ this.postMessage({
type: messages.FOLLOW_KEY_PRESS, type: messages.FOLLOW_KEY_PRESS,
key: key.key, key: key.key,
ctrlKey: key.ctrlKey || false, ctrlKey: key.ctrl || false,
}); });
} }

129
src/content/domains/Key.ts
Unescape View File

@ -1,11 +1,3 @@
export default interface Key {
key: string;
shiftKey?: boolean;
ctrlKey?: boolean;
altKey?: boolean;
metaKey?: boolean;
}
const modifiedKeyName = (name: string): string => { const modifiedKeyName = (name: string): string => {
if (name === ' ') { if (name === ' ') {
return 'Space'; return 'Space';
@ -18,55 +10,84 @@ const modifiedKeyName = (name: string): string => {
return name; return name;
}; };
export const fromKeyboardEvent = (e: KeyboardEvent): Key => { export default class Key {
let key = modifiedKeyName(e.key); public readonly key: string;
let shift = e.shiftKey;
if (key.length === 1 && key.toUpperCase() === key.toLowerCase()) { public readonly shift: boolean;
// make shift false for symbols to enable key bindings by symbold keys.
// But this limits key bindings by symbol keys with Shift (such as Shift+$>. public readonly ctrl: boolean;
shift = false;
public readonly alt: boolean;
public readonly meta: boolean;
constructor({ key, shift, ctrl, alt, meta }: {
key: string;
shift: boolean;
ctrl: boolean;
alt: boolean;
meta: boolean;
}) {
this.key = key;
this.shift = shift;
this.ctrl = ctrl;
this.alt = alt;
this.meta = meta;
} }
return { static fromMapKey(str: string): Key {
key: modifiedKeyName(e.key), if (str.startsWith('<') && str.endsWith('>')) {
shiftKey: shift, let inner = str.slice(1, -1);
ctrlKey: e.ctrlKey, let shift = inner.includes('S-');
altKey: e.altKey, let base = inner.slice(inner.lastIndexOf('-') + 1);
metaKey: e.metaKey, if (shift && base.length === 1) {
}; base = base.toUpperCase();
}; } else if (!shift && base.length === 1) {
base = base.toLowerCase();
}
return new Key({
key: base,
shift: shift,
ctrl: inner.includes('C-'),
alt: inner.includes('A-'),
meta: inner.includes('M-'),
});
}
export const fromMapKey = (key: string): Key => { return new Key({
if (key.startsWith('<') && key.endsWith('>')) { key: str,
let inner = key.slice(1, -1); shift: str.toLowerCase() !== str,
let shift = inner.includes('S-'); ctrl: false,
let base = inner.slice(inner.lastIndexOf('-') + 1); alt: false,
if (shift && base.length === 1) { meta: false,
base = base.toUpperCase(); });
} else if (!shift && base.length === 1) { }
base = base.toLowerCase();
static fromKeyboardEvent(e: KeyboardEvent): Key {
let key = modifiedKeyName(e.key);
let shift = e.shiftKey;
if (key.length === 1 && key.toUpperCase() === key.toLowerCase()) {
// make shift false for symbols to enable key bindings by symbold keys.
// But this limits key bindings by symbol keys with Shift
// (such as Shift+$>.
shift = false;
} }
return {
key: base, return new Key({
shiftKey: inner.includes('S-'), key: modifiedKeyName(e.key),
ctrlKey: inner.includes('C-'), shift: shift,
altKey: inner.includes('A-'), ctrl: e.ctrlKey,
metaKey: inner.includes('M-'), alt: e.altKey,
}; meta: e.metaKey,
});
} }
return {
key: key,
shiftKey: key.toLowerCase() !== key,
ctrlKey: false,
altKey: false,
metaKey: false,
};
};
export const equals = (e1: Key, e2: Key): boolean => { equals(key: Key) {
return e1.key === e2.key && return this.key === key.key &&
e1.ctrlKey === e2.ctrlKey && this.ctrl === key.ctrl &&
e1.metaKey === e2.metaKey && this.meta === key.meta &&
e1.altKey === e2.altKey && this.alt === key.alt &&
e1.shiftKey === e2.shiftKey; this.shift === key.shift;
}; }
}

6
src/content/domains/KeySequence.ts
Unescape View File

@ -1,4 +1,4 @@
import Key, * as keyUtils from './Key'; import Key from './Key';
export default class KeySequence { export default class KeySequence {
private keys: Key[]; private keys: Key[];
@ -24,7 +24,7 @@ export default class KeySequence {
return false; return false;
} }
for (let i = 0; i < o.keys.length; ++i) { for (let i = 0; i < o.keys.length; ++i) {
if (!keyUtils.equals(this.keys[i], o.keys[i])) { if (!this.keys[i].equals(o.keys[i])) {
return false; return false;
} }
} }
@ -54,7 +54,7 @@ export const fromMapKeys = (keys: string): KeySequence => {
return fromMapKeysRecursive( return fromMapKeysRecursive(
remainings.slice(nextPos), remainings.slice(nextPos),
mappedKeys.concat([keyUtils.fromMapKey(remainings.slice(0, nextPos))]) mappedKeys.concat([Key.fromMapKey(remainings.slice(0, nextPos))])
); );
}; };

18
test/content/InputDriver.test.ts
Unescape View File

@ -21,10 +21,10 @@ describe('InputDriver', () => {
it('register callbacks', (done) => { it('register callbacks', (done) => {
driver.onKey((key: Key): boolean => { driver.onKey((key: Key): boolean => {
expect(key.key).to.equal('a'); expect(key.key).to.equal('a');
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
done(); done();
return true; return true;
}); });
@ -68,15 +68,15 @@ describe('InputDriver', () => {
it('propagates and stop handler chain', () => { it('propagates and stop handler chain', () => {
let a = 0, b = 0, c = 0; let a = 0, b = 0, c = 0;
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
a++; a++;
return false; return false;
}); });
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
b++; b++;
return true; return true;
}); });
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
c++; c++;
return true; return true;
}); });
@ -89,7 +89,7 @@ describe('InputDriver', () => {
}) })
it('does not invoke only meta keys', () => { it('does not invoke only meta keys', () => {
driver.onKey((key: Key): boolean=> { driver.onKey((_key: Key): boolean=> {
expect.fail(); expect.fail();
return false; return false;
}); });
@ -115,7 +115,7 @@ describe('InputDriver', () => {
it('ignores events from contenteditable elements', () => { it('ignores events from contenteditable elements', () => {
let div = window.document.createElement('div'); let div = window.document.createElement('div');
let driver = new InputDriver(div); let driver = new InputDriver(div);
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
expect.fail(); expect.fail();
return false; return false;
}); });

140
test/content/domains/Key.test.ts
Unescape View File

@ -1,137 +1,139 @@
import Key, * as keys from '../../../src/content/domains/Key'; import Key from '../../../src/content/domains/Key';
import { expect } from 'chai' import { expect } from 'chai'
describe("Key", () => { describe("Key", () => {
describe('fromKeyboardEvent', () => { describe('fromKeyboardEvent', () => {
it('returns from keyboard input Ctrl+X', () => { it('returns from keyboard input Ctrl+X', () => {
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: 'x', shiftKey: false, ctrlKey: true, altKey: false, metaKey: true, key: 'x', shiftKey: false, ctrlKey: true, altKey: false, metaKey: true,
})); }));
expect(k.key).to.equal('x'); expect(k.key).to.equal('x');
expect(k.shiftKey).to.be.false; expect(k.shift).to.be.false;
expect(k.ctrlKey).to.be.true; expect(k.ctrl).to.be.true;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.true; expect(k.meta).to.be.true;
}); });
it('returns from keyboard input Shift+Esc', () => { it('returns from keyboard input Shift+Esc', () => {
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: 'Escape', shiftKey: true, ctrlKey: false, altKey: false, metaKey: true key: 'Escape', shiftKey: true, ctrlKey: false, altKey: false, metaKey: true
})); }));
expect(k.key).to.equal('Esc'); expect(k.key).to.equal('Esc');
expect(k.shiftKey).to.be.true; expect(k.shift).to.be.true;
expect(k.ctrlKey).to.be.false; expect(k.ctrl).to.be.false;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.true; expect(k.meta).to.be.true;
}); });
it('returns from keyboard input Ctrl+$', () => { it('returns from keyboard input Ctrl+$', () => {
// $ required shift pressing on most keyboards // $ required shift pressing on most keyboards
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: '$', shiftKey: true, ctrlKey: true, altKey: false, metaKey: false key: '$', shiftKey: true, ctrlKey: true, altKey: false, metaKey: false
})); }));
expect(k.key).to.equal('$'); expect(k.key).to.equal('$');
expect(k.shiftKey).to.be.false; expect(k.shift).to.be.false;
expect(k.ctrlKey).to.be.true; expect(k.ctrl).to.be.true;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.false; expect(k.meta).to.be.false;
}); });
it('returns from keyboard input Crtl+Space', () => { it('returns from keyboard input Crtl+Space', () => {
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: ' ', shiftKey: false, ctrlKey: true, altKey: false, metaKey: false key: ' ', shiftKey: false, ctrlKey: true, altKey: false, metaKey: false
})); }));
expect(k.key).to.equal('Space'); expect(k.key).to.equal('Space');
expect(k.shiftKey).to.be.false; expect(k.shift).to.be.false;
expect(k.ctrlKey).to.be.true; expect(k.ctrl).to.be.true;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.false; expect(k.meta).to.be.false;
}); });
}); });
describe('fromMapKey', () => { describe('fromMapKey', () => {
it('return for X', () => { it('return for X', () => {
let key = keys.fromMapKey('x'); let key = Key.fromMapKey('x');
expect(key.key).to.equal('x'); expect(key.key).to.equal('x');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.false; expect(key.ctrl).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('return for Shift+X', () => { it('return for Shift+X', () => {
let key = keys.fromMapKey('X'); let key = Key.fromMapKey('X');
expect(key.key).to.equal('X'); expect(key.key).to.equal('X');
expect(key.shiftKey).to.be.true; expect(key.shift).to.be.true;
expect(key.ctrlKey).to.be.false; expect(key.ctrl).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('return for Ctrl+X', () => { it('return for Ctrl+X', () => {
let key = keys.fromMapKey('<C-X>'); let key = Key.fromMapKey('<C-X>');
expect(key.key).to.equal('x'); expect(key.key).to.equal('x');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Ctrl+Meta+X', () => { it('returns for Ctrl+Meta+X', () => {
let key = keys.fromMapKey('<C-M-X>'); let key = Key.fromMapKey('<C-M-X>');
expect(key.key).to.equal('x'); expect(key.key).to.equal('x');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.true; expect(key.meta).to.be.true;
}); });
it('returns for Ctrl+Shift+x', () => { it('returns for Ctrl+Shift+x', () => {
let key = keys.fromMapKey('<C-S-x>'); let key = Key.fromMapKey('<C-S-x>');
expect(key.key).to.equal('X'); expect(key.key).to.equal('X');
expect(key.shiftKey).to.be.true; expect(key.shift).to.be.true;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Shift+Esc', () => { it('returns for Shift+Esc', () => {
let key = keys.fromMapKey('<S-Esc>'); let key = Key.fromMapKey('<S-Esc>');
expect(key.key).to.equal('Esc'); expect(key.key).to.equal('Esc');
expect(key.shiftKey).to.be.true; expect(key.shift).to.be.true;
expect(key.ctrlKey).to.be.false; expect(key.ctrl).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Ctrl+Esc', () => { it('returns for Ctrl+Esc', () => {
let key = keys.fromMapKey('<C-Esc>'); let key = Key.fromMapKey('<C-Esc>');
expect(key.key).to.equal('Esc'); expect(key.key).to.equal('Esc');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Ctrl+Esc', () => { it('returns for Ctrl+Esc', () => {
let key = keys.fromMapKey('<C-Space>'); let key = Key.fromMapKey('<C-Space>');
expect(key.key).to.equal('Space'); expect(key.key).to.equal('Space');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
}); });
describe('equals', () => { describe('equals', () => {
expect(keys.equals( expect(new Key({
{ key: 'x', ctrlKey: true, }, key: 'x', shift: false, ctrl: true, alt: false, meta: false,
{ key: 'x', ctrlKey: true, }, }).equals(new Key({
)).to.be.true; key: 'x', shift: false, ctrl: true, alt: false, meta: false,
}))).to.be.true;
expect(keys.equals( expect(new Key({
{ key: 'X', shiftKey: true, }, key: 'x', shift: false, ctrl: false, alt: false, meta: false,
{ key: 'x', ctrlKey: true, }, }).equals(new Key({
)).to.be.false; key: 'X', shift: true, ctrl: false, alt: false, meta: false,
}))).to.be.false;
}); });
}); });

35
test/content/domains/KeySequence.test.ts
Unescape View File

@ -1,48 +1,50 @@
import KeySequence, * as utils from '../../../src/content/domains/KeySequence'; import KeySequence, * as utils from '../../../src/content/domains/KeySequence';
import Key from '../../../src/content/domains/Key';
import { expect } from 'chai' import { expect } from 'chai'
describe("KeySequence", () => { describe("KeySequence", () => {
describe('#push', () => { describe('#push', () => {
it('append a key to the sequence', () => { it('append a key to the sequence', () => {
let seq = KeySequence.from([]); let seq = KeySequence.from([]);
seq.push({ key: 'g' }); seq.push(Key.fromMapKey('g'));
seq.push({ key: 'u', shiftKey: true }); seq.push(Key.fromMapKey('<S-U>'));
let array = seq.getKeyArray(); let array = seq.getKeyArray();
expect(array[0]).to.deep.equal({ key: 'g' }); expect(array[0].key).to.equal('g');
expect(array[1]).to.deep.equal({ key: 'u', shiftKey: true }); expect(array[1].key).to.equal('U');
expect(array[1].shift).to.be.true;
}) })
}); });
describe('#startsWith', () => { describe('#startsWith', () => {
it('returns true if the key sequence starts with param', () => { it('returns true if the key sequence starts with param', () => {
let seq = KeySequence.from([ let seq = KeySequence.from([
{ key: 'g' }, Key.fromMapKey('g'),
{ key: 'u', shiftKey: true }, Key.fromMapKey('<S-U>'),
]); ]);
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
]))).to.be.true; ]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'g' }, Key.fromMapKey('g'),
]))).to.be.true; ]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'g' }, { key: 'u', shiftKey: true }, Key.fromMapKey('g'), Key.fromMapKey('<S-U>'),
]))).to.be.true; ]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'g' }, { key: 'u', shiftKey: true }, { key: 'x' }, Key.fromMapKey('g'), Key.fromMapKey('<S-U>'), Key.fromMapKey('x'),
]))).to.be.false; ]))).to.be.false;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'h' }, Key.fromMapKey('h'),
]))).to.be.false; ]))).to.be.false;
}) });
it('returns true if the empty sequence starts with an empty sequence', () => { it('returns true if the empty sequence starts with an empty sequence', () => {
let seq = KeySequence.from([]); let seq = KeySequence.from([]);
expect(seq.startsWith(KeySequence.from([]))).to.be.true; expect(seq.startsWith(KeySequence.from([]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'h' }, Key.fromMapKey('h'),
]))).to.be.false; ]))).to.be.false;
}) })
}); });
@ -52,21 +54,20 @@ describe("KeySequence", () => {
let keyArray = utils.fromMapKeys('<S-Esc>').getKeyArray(); let keyArray = utils.fromMapKeys('<S-Esc>').getKeyArray();
expect(keyArray).to.have.lengthOf(1); expect(keyArray).to.have.lengthOf(1);
expect(keyArray[0].key).to.equal('Esc'); expect(keyArray[0].key).to.equal('Esc');
expect(keyArray[0].shiftKey).to.be.true; expect(keyArray[0].shift).to.be.true;
}); });
it('returns mapped keys for a<C-B><A-C>d<M-e>', () => { it('returns mapped keys for a<C-B><A-C>d<M-e>', () => {
let keyArray = utils.fromMapKeys('a<C-B><A-C>d<M-e>').getKeyArray(); let keyArray = utils.fromMapKeys('a<C-B><A-C>d<M-e>').getKeyArray();
expect(keyArray).to.have.lengthOf(5); expect(keyArray).to.have.lengthOf(5);
expect(keyArray[0].key).to.equal('a'); expect(keyArray[0].key).to.equal('a');
expect(keyArray[1].ctrlKey).to.be.true; expect(keyArray[1].ctrl).to.be.true;
expect(keyArray[1].key).to.equal('b'); expect(keyArray[1].key).to.equal('b');
expect(keyArray[2].altKey).to.be.true; expect(keyArray[2].alt).to.be.true;
expect(keyArray[2].key).to.equal('c'); expect(keyArray[2].key).to.equal('c');
expect(keyArray[3].key).to.equal('d'); expect(keyArray[3].key).to.equal('d');
expect(keyArray[4].metaKey).to.be.true; expect(keyArray[4].meta).to.be.true;
expect(keyArray[4].key).to.equal('e'); expect(keyArray[4].key).to.equal('e');
}); });
}) })
}); });

24
test/content/repositories/KeymapRepository.test.ts
Unescape View File

@ -1,5 +1,6 @@
import KeymapRepository, { KeymapRepositoryImpl } import KeymapRepository, { KeymapRepositoryImpl }
from '../../../src/content/repositories/KeymapRepository'; from '../../../src/content/repositories/KeymapRepository';
import Key from '../../../src/content/domains/Key'
import { expect } from 'chai'; import { expect } from 'chai';
describe('KeymapRepositoryImpl', () => { describe('KeymapRepositoryImpl', () => {
@ -11,24 +12,25 @@ describe('KeymapRepositoryImpl', () => {
describe('#enqueueKey()', () => { describe('#enqueueKey()', () => {
it('enqueues keys', () => { it('enqueues keys', () => {
sut.enqueueKey({ key: 'a' }); sut.enqueueKey(Key.fromMapKey('a');
sut.enqueueKey({ key: 'b' }); sut.enqueueKey(Key.fromMapKey('b');
let sequence = sut.enqueueKey({ key: 'c' }); let sequence = sut.enqueueKey(Key.fromMapKey('c'));
expect(sequence.getKeyArray()).deep.equals([ let keys = sequence.getKeyArray();
{ key: 'a' }, { key: 'b' }, { key: 'c' }, expect(keys[0].equals(Key.fromMapKey('a'))).to.be.true;
]); expect(keys[1].equals(Key.fromMapKey('b'))).to.be.true;
expect(keys[2].equals(Key.fromMapKey('c'))).to.be.true;
}); });
}); });
describe('#clear()', () => { describe('#clear()', () => {
it('clears keys', () => { it('clears keys', () => {
sut.enqueueKey({ key: 'a' }); sut.enqueueKey(Key.fromMapKey('a');
sut.enqueueKey({ key: 'b' }); sut.enqueueKey(Key.fromMapKey('b');
sut.enqueueKey({ key: 'c' }); sut.enqueueKey(Key.fromMapKey('c');
sut.clear(); sut.clear();
let sequence = sut.enqueueKey({ key: 'a' }); let sequence = sut.enqueueKey(Key.fromMapKey('a'));
expect(sequence.length()).to.equal(1); expect(sequence.length()).to.equal(1);
}); });
}); });