fix: fixes circular dependency between notation and configuration

extension.ts

@@ -210,7 +210,7 @@ export async function activate(context: vscode.ExtensionContext) {
       const mh = await getAndUpdateModeHandler();
       if (args.after) {
         for (const key of args.after) {
-          await mh.handleKeyEvent(Notation.NormalizeKey(key));
+          await mh.handleKeyEvent(Notation.NormalizeKey(key, Configuration.leader));
         }
         return;
       }

src/cmd_line/commands/file.ts

@@ -72,7 +72,6 @@ export class FileCommand extends node.CommandBase {
         await vscode.commands.executeCommand('workbench.action.files.newUntitledFile');
         await vscode.commands.executeCommand('workbench.action.closeOtherEditors');
       }
-
       return;
     } else if (this._arguments.name === '') {
       if (this._arguments.position === FilePosition.NewWindow) {

src/configuration/configuration.ts

@@ -85,11 +85,7 @@ class ConfigurationClass {
       }
     }
 
-    // resolve and normalize leader key
-    this.leader =
-      this.leader.toLocaleLowerCase() === '<leader>'
-        ? this.leaderDefault
-        : Notation.NormalizeKey(this.leader);
+    this.leader = Notation.NormalizeKey(this.leader, this.leaderDefault);
 
     // normalize keys
     const keybindingList: IKeyRemapping[][] = [
@@ -102,13 +98,13 @@ class ConfigurationClass {
       for (let remapping of keybindings) {
         if (remapping.before) {
           remapping.before.forEach(
-            (key, idx) => (remapping.before[idx] = Notation.NormalizeKey(key))
+            (key, idx) => (remapping.before[idx] = Notation.NormalizeKey(key, this.leader))
           );
         }
 
         if (remapping.after) {
           remapping.after.forEach(
-            (key, idx) => (remapping.after![idx] = Notation.NormalizeKey(key))
+            (key, idx) => (remapping.after![idx] = Notation.NormalizeKey(key, this.leader))
           );
         }
       }
@@ -129,7 +125,7 @@ class ConfigurationClass {
       }
 
       this.boundKeyCombinations.push({
-        key: Notation.NormalizeKey(key),
+        key: Notation.NormalizeKey(key, this.leader),
         command: keybinding.command,
       });
     }

src/configuration/notation.ts

@@ -1,7 +1,5 @@
 import * as _ from 'lodash';
 
-import { Configuration } from './configuration';
-
 export class Notation {
   // Mapping from the nomalized string to regex strings that could match it.
   private static _notationMap: { [key: string]: string[] } = {
@@ -17,7 +15,7 @@ export class Notation {
    * (e.g. <ctrl+x>, Ctrl+x, <c-x> normalized to <C-x>)
    * and resolves special cases such as '<leader>'
    */
-  public static NormalizeKey(key: string): string {
+  public static NormalizeKey(key: string, leaderKey: string): string {
     if (!this.isSurroundedByAngleBrackets(key) && key.length > 1) {
       key = `<${key.toLocaleLowerCase()}>`;
     }
@@ -32,7 +30,7 @@ export class Notation {
     }
 
     if (key.toLocaleLowerCase() === '<leader>') {
-      return Configuration.leader;
+      return leaderKey;
     }
 
     if (_.includes(['<up>', '<down>', '<left>', '<right>'], key.toLocaleLowerCase())) {

src/error.ts

@@ -18,8 +18,8 @@ export const ErrorMessage: IErrorMessage = {
   208: 'Error writing to file',
   348: 'No string under cursor',
   444: 'Cannot close last window',
-  492: 'Not an editor command',
   488: 'Trailing characters',
+  492: 'Not an editor command',
 };
 
 export class VimError extends Error {

test/notation.test.ts

@@ -4,18 +4,22 @@ import { Notation } from '../src/configuration/notation';
 
 suite('Notation', () => {
   test('Normalize', () => {
+    let leaderKey = '//';
     let testCases = {
       '<cTrL+w>': '<C-w>',
       'cTrL+x': '<C-x>',
       'CtRl+y': '<C-y>',
       'c-z': '<C-z>',
+      '<CmD+a>': '<D-a>',
+      eScapE: '<Esc>',
+      '<LeAder>': '//',
     };
 
     for (const test in testCases) {
       if (testCases.hasOwnProperty(test)) {
         let expected = testCases[test];
 
-        let actual = Notation.NormalizeKey(test);
+        let actual = Notation.NormalizeKey(test, leaderKey);
         assert.equal(actual, expected);
       }
     }