Swich to a combo of TS and CLJS toolchains

.vscode/tasks.json

@@ -4,14 +4,36 @@
     "version": "2.0.0",
     "tasks": [
         {
-            "label": "Watch",
+            "label": "Watch CLJS",
             "type": "npm",
-            "script": "watch",
-            "problemMatcher": [],
+            "script": "watch-cljs",
             "group": {
                 "kind": "build",
                 "isDefault": true
-            }
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Watch TS",
+            "type": "npm",
+            "script": "watch-ts",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "problemMatcher": []
+        },
+        {
+            "label": "Compile",
+            "type": "npm",
+            "script": "compile",
+            "problemMatcher": []
+        },
+        {
+            "label": "Release",
+            "type": "npm",
+            "script": "release",
+            "problemMatcher": []
         }
     ]
 }

src/main/calva/connector.js → calva/connector.ts

@@ -1,14 +1,14 @@
-import vscode from 'vscode';
-import _ from 'lodash';
-import fs from 'fs';
+import * as vscode from 'vscode';
+import * as _ from 'lodash';
+import * as fs from 'fs';
 import * as state from './state';
 import repl from './repl/client';
-import message from 'goog:calva.repl.message';
 import * as util from './utilities';
 import shadow from './shadow';
 import status from './status';
 import terminal from './terminal';
 //const evaluate = require('./repl/middleware/evaluate');
+const { message } = require('../lib/calva');
 
 function nreplPortFile() {
     if (fs.existsSync(shadow.shadowNReplPortFile())) {
@@ -144,7 +144,8 @@ function makeCljsSessionClone(hostname, port, session, shadowBuild, callback) {
                 let cljsSession = _.find(results, 'new-session')['new-session'];
                 if (cljsSession) {
                     let client = repl.create({ hostname, port }).once('connect', () => {
-                        let msg = shadowBuild ? message.startShadowCljsReplMsg(cljsSession, shadowBuild) : message.startCljsReplMsg(cljsSession);
+                        let msg = shadowBuild ? message.startShadowCljsReplMsg(cljsSession, shadowBuild) :
+                            message.evalCode(cljsSession, util.getCljsReplStartCode());
                         client.send(msg, cljsResults => {
                             client.end();
                             let valueResult = _.find(cljsResults, 'value'),

src/main/calva/extension.js → calva/extension.ts

@@ -1,10 +1,9 @@
-import vscode from 'vscode';
+import * as vscode from 'vscode';
 import * as state from './state';
 import status from './status';
 import connector from './connector';
-import greet from 'goog:calva.greet';
 import terminal from './terminal';
-import CompletionItemProvider from './providers/completion';
+import CalvaCompletionItemProvider from './providers/completion';
 import TextDocumentContentProvider from './providers/content';
 import HoverProvider from './providers/hover';
 import DefinitionProvider from './providers/definition';
@@ -13,6 +12,9 @@ import LintMiddleWare from './repl/middleware/lint';
 import TestRunnerMiddleWare from './repl/middleware/testRunner';
 import select from './repl/middleware/select';
 
+const { greetings } = require('../lib/calva');
+
+
 function onDidSave(document) {
     let {
         evaluate,
@@ -51,7 +53,8 @@ function activate(context) {
     let chan = state.deref().get('outputChannel');
     chan.appendLine("Calva activated.");
     let {
-        autoConnect
+        autoConnect,
+        lint
     } = state.config();
 
     status.update();
@@ -81,7 +84,7 @@ function activate(context) {
     context.subscriptions.push(vscode.commands.registerCommand('calva.evalCurrentTopLevelFormInREPLTerminal', terminal.evalCurrentTopLevelFormInREPLTerminalCommand));
 
     // PROVIDERS
-    context.subscriptions.push(vscode.languages.registerCompletionItemProvider(state.mode, new CompletionItemProvider()));
+    context.subscriptions.push(vscode.languages.registerCompletionItemProvider(state.mode, new CalvaCompletionItemProvider()));
     context.subscriptions.push(vscode.languages.registerHoverProvider(state.mode, new HoverProvider()));
     context.subscriptions.push(vscode.languages.registerDefinitionProvider(state.mode, new DefinitionProvider()));
 
@@ -95,7 +98,7 @@ function activate(context) {
         onDidSave(document);
     }));
     context.subscriptions.push(vscode.window.onDidChangeActiveTextEditor((editor) => {
-        status.update(editor);
+        status.update();
     }));
     context.subscriptions.push(new vscode.Disposable(() => {
         connector.disconnect();
@@ -108,7 +111,7 @@ function activate(context) {
 
     vscode.commands.executeCommand('setContext', 'calva:activated', true);
 
-    greet.activationGreetings(chan);
+    greetings.activationGreetings(chan, lint);
 
     //Try to connect using an existing .nrepl-port file, searching the root-directory
     if (autoConnect) {

src/main/calva/providers/annotations.js → calva/providers/annotations.ts

@@ -1,4 +1,4 @@
-import vscode from 'vscode';
+import * as vscode from 'vscode';
 
 const evalResultsDecorationType = vscode.window.createTextEditorDecorationType({
     before: {
@@ -44,7 +44,7 @@ function clearEvaluationDecorations(editor) {
 
 function decorateResults(resultString, hasError, codeSelection, editor) {
     let decoration = evaluated(resultString, hasError)
-    decoration.range = new vscode.Selection(codeSelection.end, codeSelection.end);
+    decoration["range"] = new vscode.Selection(codeSelection.end, codeSelection.end);
     editor.setDecorations(evalResultsDecorationType, [decoration]);
     setTimeout(() => {
         let subscription = vscode.window.onDidChangeTextEditorSelection(() => {

src/main/calva/providers/completion.js → calva/providers/completion.ts

@@ -1,32 +1,35 @@
-import vscode from 'vscode';
+import { TextDocument, Position, CancellationToken, CompletionContext, Hover, CompletionItemKind, window, CompletionList, CompletionItemProvider, CompletionItem } from 'vscode';
 import * as state from '../state';
 import repl from '../repl/client';
-import message from 'goog:calva.repl.message';
 import * as util from '../utilities';
+import { Context } from 'vm';
+const { message } = require('../../lib/calva');
 
-export default class CompletionItemProvider {
+export default class CalvaCompletionItemProvider implements CompletionItemProvider {
+    state: any;
+    mappings: any;
     constructor() {
         this.state = state;
         this.mappings = {
-            'nil': vscode.CompletionItemKind.Value,
-            'macro': vscode.CompletionItemKind.Value,
-            'class': vscode.CompletionItemKind.Class,
-            'keyword': vscode.CompletionItemKind.Keyword,
-            'namespace': vscode.CompletionItemKind.Module,
-            'function': vscode.CompletionItemKind.Function,
-            'special-form': vscode.CompletionItemKind.Keyword,
-            'var': vscode.CompletionItemKind.Variable,
-            'method': vscode.CompletionItemKind.Method
+            'nil': CompletionItemKind.Value,
+            'macro': CompletionItemKind.Value,
+            'class': CompletionItemKind.Class,
+            'keyword': CompletionItemKind.Keyword,
+            'namespace': CompletionItemKind.Module,
+            'function': CompletionItemKind.Function,
+            'special-form': CompletionItemKind.Keyword,
+            'var': CompletionItemKind.Variable,
+            'method': CompletionItemKind.Method
         };
     }
 
-    provideCompletionItems(document, position, _) {
+    provideCompletionItems(document: TextDocument, position: Position, token: CancellationToken, context: CompletionContext) {
         let text = util.getWordAtPosition(document, position),
             scope = this,
             filetypeIndex = (document.fileName.lastIndexOf('.') + 1),
             filetype = document.fileName.substr(filetypeIndex, document.fileName.length);
         if (this.state.deref().get("connected")) {
-            return new Promise((resolve, reject) => {
+            return new Promise<CompletionList>((resolve, reject) => {
                 let current = this.state.deref(),
                     client = repl.create()
                         .once('connect', () => {
@@ -41,14 +44,14 @@ export default class CompletionItemProvider {
                                             let item = result.completions[c];
                                             completions.push({
                                                 label: item.candidate,
-                                                kind: scope.mappings[item.type] || vscode.CompletionItemKind.Text,
+                                                kind: scope.mappings[item.type] || CompletionItemKind.Text,
                                                 insertText: item[0] === '.' ? item.slice(1) : item
                                             });
                                         }
                                     }
                                 }
                                 if (completions.length > 0) {
-                                    resolve(new vscode.CompletionList(completions, false));
+                                    resolve(new CompletionList(completions, false));
                                 } else {
                                     reject("No completions found");
                                 }
@@ -57,19 +60,19 @@ export default class CompletionItemProvider {
                         });
             });
         } else {
-            return new vscode.Hover("Connect to repl for auto-complete..");
+            return [new CompletionItem("Connect to repl for auto-complete..")];
         }
     }
 
-    resolveCompletionItem(item, _) {
-        let editor = vscode.window.activeTextEditor,
+    resolveCompletionItem(item: CompletionItem, token: CancellationToken) {
+        let editor = window.activeTextEditor,
             filetypeIndex = (editor.document.fileName.lastIndexOf('.') + 1),
             filetype = editor.document.fileName.substr(filetypeIndex, editor.document.fileName.length);
-        return new Promise((resolve, reject) => {
+        return new Promise<CompletionItem>((resolve, reject) => {
             let current = this.state.deref();
             if (current.get('connected')) {
                 let client = repl.create().once('connect', () => {
-                    let document = vscode.window.activeTextEditor.document,
+                    let document = window.activeTextEditor.document,
                         msg = message.infoMsg(util.getSession(filetype),
                             util.getNamespace(document.getText()), item.label);
                     client.send(msg, function (results) {

src/main/calva/providers/content.js → calva/providers/content.ts

@@ -1,17 +1,20 @@
+import * as vscode from 'vscode';
 import * as state from '../state';
-import os from 'os';
-import fs from 'fs';
-import JSZip from 'jszip';
+import * as os from 'os';
+import * as fs from 'fs';
+import * as JSZip from 'jszip';
+
+export default class TextDocumentContentProvider implements vscode.TextDocumentContentProvider {
+    state: any;
 
-export default class TextDocumentContentProvider {
     constructor() {
         this.state = state;
     }
 
     provideTextDocumentContent(uri, token) {
         let current = this.state.deref();
         if (current.get('connected')) {
-            return new Promise((resolve, reject) => {
+            return new Promise<string>((resolve, reject) => {
                 let rawPath = uri.path,
                     pathToFileInJar = rawPath.slice(rawPath.search('!/') + 2),
                     pathToJar = rawPath.slice('file:'.length);

src/main/calva/providers/definition.js → calva/providers/definition.ts

@@ -1,10 +1,11 @@
-import vscode from 'vscode';
+import * as vscode from 'vscode';
 import * as state from '../state';
 import repl from '../repl/client';
-import message from 'goog:calva.repl.message';
 import * as util from '../utilities';
+const { message } = require('../../lib/calva');
 
-export default class DefinitionProvider {
+export default class DefinitionProvider implements vscode.DefinitionProvider {
+    state: any;
     constructor() {
         this.state = state;
     }
@@ -15,8 +16,8 @@ export default class DefinitionProvider {
             scope = this,
             filetypeIndex = (document.fileName.lastIndexOf('.') + 1),
             filetype = document.fileName.substr(filetypeIndex, document.fileName.length);
-        if (this.state.deref().get('connected')) {
-            return new Promise((resolve, reject) => {
+        return new Promise<vscode.Location>((resolve, reject) => {
+            if (this.state.deref().get('connected')) {
                 let current = scope.state.deref(),
                     client = repl.create().once('connect', () => {
                         let msg = message.infoMsg(util.getSession(filetype),
@@ -37,9 +38,9 @@ export default class DefinitionProvider {
                             client.end();
                         });
                     });
-            });
-        } else {
-            return new vscode.Hover("Not connected to nREPL..");
-        }
+            } else {
+                reject("Not connected to a REPL…");
+            }
+        });
     }
 };

src/main/calva/providers/hover.js → calva/providers/hover.ts

@@ -1,10 +1,12 @@
-import vscode from 'vscode';
+import * as vscode from 'vscode';
 import * as state from '../state';
 import repl from '../repl/client';
-import message from 'goog:calva.repl.message';
 import * as util from '../utilities';
 
-export default class HoverProvider {
+const { message } = require('../../lib/calva');
+
+export default class HoverProvider implements vscode.HoverProvider {
+    state: any;
     constructor() {
         this.state = state;
     }
@@ -45,7 +47,7 @@ export default class HoverProvider {
         }
 
         if (this.state.deref().get('connected')) {
-            return new Promise((resolve, reject) => {
+            return new Promise<vscode.Hover>((resolve, reject) => {
                 let current = this.state.deref(),
                     client = repl.create()
                         .once('connect', () => {

src/main/calva/repl/client.js → calva/repl/client.ts

@@ -1,11 +1,11 @@
 import * as state from '../state';
-import nrepl from 'goog:calva.repl.nrepl';
+const { nrepl } = require('../../lib/calva');
 
 function send(msg, callback) {
     nrepl.message(this, msg, callback);
 }
 
-function create(options) {
+function create(options?) {
     let current = state.deref(),
         _options = null;
     if (current.get('connected')) {

src/main/calva/repl/middleware/evaluate.js → calva/repl/middleware/evaluate.ts

@@ -1,12 +1,13 @@
-import vscode from 'vscode';
-import _ from 'lodash';
+import * as vscode from 'vscode';
+import * as _ from 'lodash';
 import * as state from '../../state';
 import repl from '../client';
-import message from 'goog:calva.repl.message';
 import annotations from '../../providers/annotations';
 import select from './select';
 import * as util from '../../utilities';
 
+const { message } = require('../../../lib/calva');
+
 function evaluateMsg(msg, startStr, errorStr, callback) {
     let current = state.deref(),
         chan = current.get('outputChannel');
@@ -44,9 +45,9 @@ function evaluateSelection(document = {}, options = {}) {
     let current = state.deref(),
         chan = current.get('outputChannel'),
         doc = util.getDocument(document),
-        pprint = options.pprint || false,
-        replace = options.replace || false,
-        topLevel = options.topLevel || false,
+        pprint = options["pprint"] || false,
+        replace = options["replace"] || false,
+        topLevel = options["topLevel"] || false,
         session = util.getSession(util.getFileType(doc));
 
     if (current.get('connected')) {

src/main/calva/repl/middleware/lint.js → calva/repl/middleware/lint.ts

@@ -1,6 +1,6 @@
-import vscode from 'vscode';
+import * as vscode from 'vscode';
 import { spawn } from 'child_process';
-import path from 'path';
+import * as path from 'path';
 import * as state from '../../state';
 import * as util from '../../utilities';
 
@@ -74,7 +74,7 @@ function lintDocument(document = {}) {
         }
     });
 
-    joker.on("error", (error) => {
+    joker.on("error", (error: { message, code }) => {
         let {
             lint,
             jokerPath