first auto-type emitter implementation

app/scripts/auto-type/auto-type-emitter-factory.js

@@ -1,10 +1,15 @@
 import { Launcher } from 'comp/launcher';
+import { AppSettingsModel } from 'models/app-settings-model';
+import { AutoTypeEmitter } from 'auto-type/auto-type-emitter';
 
 const AutoTypeEmitterFactory = {
     create(callback, windowId) {
         if (Launcher && Launcher.autoTypeSupported) {
-            const { AutoTypeEmitter } = require('./emitter/auto-type-emitter-' +
-                Launcher.platform());
+            if (AppSettingsModel.useLegacyAutoType) {
+                const { AutoTypeEmitter } = require('./emitter/auto-type-emitter-' +
+                    Launcher.platform());
+                return new AutoTypeEmitter(callback, windowId);
+            }
             return new AutoTypeEmitter(callback, windowId);
         }
         return null;

app/scripts/auto-type/auto-type-emitter.js

@@ -0,0 +1,133 @@
+import { Features } from 'util/features';
+import { NativeModules } from 'comp/launcher/native-modules';
+import { CopyPaste } from 'comp/browser/copy-paste';
+import { Logger } from 'util/logger';
+
+const logger = new Logger('auto-type-emitter');
+
+const KeyMap = {
+    tab: 'Tab',
+    enter: 'Return',
+    space: 'Space',
+    up: 'UpArrow',
+    down: 'DownArrow',
+    left: 'LeftArrow',
+    right: 'RightArrow',
+    home: 'Home',
+    end: 'End',
+    pgup: 'PageUp',
+    pgdn: 'PageDown',
+    ins: 'Insert',
+    del: 'ForwardDelete',
+    bs: 'BackwardDelete',
+    esc: 'Escape',
+    win: 'Meta',
+    rwin: 'RightMeta',
+    f1: 'F1',
+    f2: 'F2',
+    f3: 'F3',
+    f4: 'F4',
+    f5: 'F5',
+    f6: 'F6',
+    f7: 'F7',
+    f8: 'F8',
+    f9: 'F9',
+    f10: 'F10',
+    f11: 'F11',
+    f12: 'F12',
+    f13: 'F13',
+    f14: 'F14',
+    f15: 'F15',
+    f16: 'F16',
+    add: 'KeypadPlus',
+    subtract: 'KeypadMinus',
+    multiply: 'KeypadMultiply',
+    divide: 'KeypadDivide',
+    n0: 'D0',
+    n1: 'D1',
+    n2: 'D2',
+    n3: 'D3',
+    n4: 'D4',
+    n5: 'D5',
+    n6: 'D6',
+    n7: 'D7',
+    n8: 'D8',
+    n9: 'D9'
+};
+
+const ModMap = {
+    '^': Features.isMac ? 'Command' : 'Ctrl',
+    '+': 'Shift',
+    '%': 'Alt',
+    '^^': 'Ctrl'
+};
+
+class AutoTypeEmitter {
+    constructor(callback, windowId) {
+        this.callback = callback;
+        this.windowId = windowId;
+        this.mod = {};
+    }
+
+    setMod(mod, enabled) {
+        // TODO: press the modifier
+        if (enabled) {
+            this.mod[ModMap[mod]] = true;
+        } else {
+            delete this.mod[ModMap[mod]];
+        }
+    }
+
+    text(str) {
+        this.withCallback(NativeModules.kbdText(str)); // TODO: how to handle modifiers?
+    }
+
+    key(key) {
+        if (typeof key === 'number') {
+            // TODO
+        } else {
+            if (!KeyMap[key]) {
+                return this.callback('Bad key: ' + key);
+            }
+            const code = KeyMap[key];
+            this.withCallback(NativeModules.kbdKeyPress(code)); // TODO: modifier
+        }
+    }
+
+    copyPaste(text) {
+        CopyPaste.copy(text);
+        this.withCallback(NativeModules.kbdShortcut('V'));
+    }
+
+    wait(time) {
+        setTimeout(() => this.withCallback(Promise.resolve()), time);
+    }
+
+    waitComplete() {
+        this.withCallback(Promise.resolve());
+    }
+
+    setDelay(delay) {
+        // TODO
+    }
+
+    withCallback(promise) {
+        promise
+            .then(() => {
+                try {
+                    this.callback();
+                } catch (err) {
+                    logger.error('Callback error', err);
+                }
+            })
+            .catch((err) => {
+                try {
+                    this.callback(err);
+                } catch (err) {
+                    logger.error('Callback error', err);
+                }
+            });
+    }
+}
+
+export { AutoTypeEmitter };

app/scripts/auto-type/auto-type-runner.js

@@ -2,11 +2,12 @@ import { AutoTypeEmitterFactory } from 'auto-type/auto-type-emitter-factory';
 import { AutoTypeObfuscator } from 'auto-type/auto-type-obfuscator';
 import { StringFormat } from 'util/formatting/string-format';
 import { Logger } from 'util/logger';
+import { AppSettingsModel } from 'models/app-settings-model';
 
 const emitterLogger = new Logger(
     'auto-type-emitter',
     undefined,
-    localStorage.debugAutoType ? Logger.Level.All : Logger.Level.Warn
+    localStorage.debugAutoType ? Logger.Level.All : Logger.Level.Info
 );
 
 const AutoTypeRunner = function (ops) {
@@ -432,6 +433,8 @@ AutoTypeRunner.prototype.obfuscateOp = function (op) {
 };
 
 AutoTypeRunner.prototype.run = function (callback, windowId) {
+    const emitterType = AppSettingsModel.useLegacyAutoType ? 'legacy' : 'native';
+    emitterLogger.info(`Using ${emitterType} auto-type emitter`);
     this.emitter = AutoTypeEmitterFactory.create(this.emitNext.bind(this), windowId);
     this.emitterState = {
         callback,