200 lines
10 KiB
TypeScript
200 lines
10 KiB
TypeScript
// The module 'vscode' contains the VS Code extensibility API
|
|
// Import the module and reference it with the alias vscode in your code below
|
|
import * as vscode from 'vscode';
|
|
import * as Calculator from './calculator';
|
|
import * as copyHelper from './copyHelper';
|
|
import * as kanbanHelper from './kanbanHelper';
|
|
import * as markdownHelper from './markdownHelper';
|
|
import * as settingsHelper from './settingsHelper';
|
|
import * as promiseLinesHelper from './promiseLinesHelper';
|
|
import * as replaceLinesHelper from './replaceLinesHelper';
|
|
import * as readOnlyLinesHelper from './readOnlyLinesHelper';
|
|
import * as WebviewPanelExample from './WebviewPanelExample';
|
|
import * as WebviewPanelCostOfDelay from './WebviewPanelCostOfDelay';
|
|
import { ViewCommandPalleteWebviewViewProvider } from "./ViewCommandPalleteWebviewViewProvider";
|
|
|
|
// This method is called when your extension is activated
|
|
// Your extension is activated the very first time the command is executed
|
|
export async function activate(extensionContext: vscode.ExtensionContext) {
|
|
|
|
const viewCommandPalleteWebviewViewProvider = new ViewCommandPalleteWebviewViewProvider(extensionContext);
|
|
extensionContext.subscriptions.push(vscode.window.registerWebviewViewProvider("view-command-pallete-webview-view-provider", viewCommandPalleteWebviewViewProvider));
|
|
|
|
const config = vscode.workspace.getConfiguration('calc');
|
|
const outputChannel = vscode.window.createOutputChannel('calc');
|
|
|
|
const onError = (error: unknown) => {
|
|
if (error instanceof Error) {
|
|
outputChannel.appendLine(error.message);
|
|
if (error.stack) outputChannel.appendLine(error.stack);
|
|
} else {
|
|
outputChannel.appendLine((error as any).toString().message);
|
|
}
|
|
};
|
|
|
|
const calcProvider = new Calculator.CalcProvider(config, onError);
|
|
|
|
extensionContext.subscriptions.push(
|
|
vscode.languages.registerCompletionItemProvider('*', calcProvider, '=', ' '),
|
|
vscode.workspace.onDidOpenTextDocument(() => {
|
|
calcProvider.clearHighlight().catch(onError);
|
|
}),
|
|
vscode.window.onDidChangeTextEditorSelection(() => {
|
|
calcProvider.clearHighlight().catch(onError);
|
|
}),
|
|
);
|
|
|
|
function getWebviewView(title: string) {
|
|
const column = vscode.window.activeTextEditor
|
|
? vscode.window.activeTextEditor.viewColumn
|
|
: undefined;
|
|
|
|
// Otherwise, create a new panel.
|
|
const webviewView = vscode.window.createWebviewPanel(
|
|
"web-view-panel",
|
|
title,
|
|
column || vscode.ViewColumn.One,
|
|
{
|
|
// Enable javascript in the webview
|
|
enableScripts: true,
|
|
|
|
// And restrict the webview to only loading content from our extension's `media` directory.
|
|
localResourceRoots: [
|
|
vscode.Uri.joinPath(extensionContext.extensionUri, "media"),
|
|
vscode.Uri.joinPath(extensionContext.extensionUri, "out/compiled"),
|
|
],
|
|
}
|
|
);
|
|
return webviewView;
|
|
}
|
|
|
|
async function replaceResultsWithPositions(
|
|
editor: vscode.TextEditor,
|
|
positionsAndExpressions: [vscode.Position, string][],
|
|
mode: 'append' | 'replace',
|
|
) {
|
|
await editor.edit((editBuilder) => {
|
|
for (const [position, expression] of positionsAndExpressions) {
|
|
const lineCalcResult = calcProvider.calculateLine(position, expression);
|
|
if (lineCalcResult == null) {
|
|
continue;
|
|
}
|
|
const { insertText, expressionWithEqualSignRange, expressionEndRange } =
|
|
lineCalcResult;
|
|
|
|
if (mode === 'append') {
|
|
const endWithEqual = expression.trimEnd().endsWith('=');
|
|
editBuilder.replace(
|
|
expressionEndRange,
|
|
endWithEqual ? insertText : ` = ${insertText}`,
|
|
);
|
|
} else if (mode === 'replace') {
|
|
editBuilder.replace(expressionWithEqualSignRange, insertText);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
async function replaceResult(
|
|
mode: 'append' | 'replace',
|
|
withCursor: boolean,
|
|
) {
|
|
const editor = vscode.window.activeTextEditor;
|
|
if (!editor || !editor.selection.isEmpty) {
|
|
return;
|
|
}
|
|
const doc = editor.document;
|
|
|
|
let positionsAndExpressions;
|
|
if (withCursor) {
|
|
positionsAndExpressions = editor.selections.map(
|
|
(selection) =>
|
|
<[vscode.Position, string]>[
|
|
selection.active,
|
|
doc
|
|
.lineAt(selection.active.line)
|
|
.text.slice(0, selection.active.character),
|
|
],
|
|
);
|
|
} else {
|
|
const uniqueLineNumbers = [
|
|
...new Set(editor.selections.map((selection) => selection.active.line)),
|
|
];
|
|
positionsAndExpressions = uniqueLineNumbers.map((number) => {
|
|
const line = doc.lineAt(number);
|
|
return <[vscode.Position, string]>[line.range.end, line.text];
|
|
});
|
|
}
|
|
await replaceResultsWithPositions(editor, positionsAndExpressions, mode);
|
|
}
|
|
|
|
extensionContext.subscriptions.push(
|
|
vscode.commands.registerTextEditorCommand('extension.calcAppendWithCursor', () => {
|
|
replaceResult('append', true).catch(onError);
|
|
}),
|
|
vscode.commands.registerTextEditorCommand('extension.calcAppend', () => {
|
|
replaceResult('append', false).catch(onError);
|
|
}),
|
|
vscode.commands.registerTextEditorCommand(
|
|
'extension.calcReplaceWithCursor',
|
|
() => {
|
|
replaceResult('replace', true).catch(onError);
|
|
},
|
|
),
|
|
vscode.commands.registerTextEditorCommand('extension.calcReplace', () => {
|
|
replaceResult('replace', false).catch(onError);
|
|
}),
|
|
);
|
|
|
|
const commands = [
|
|
vscode.commands.registerCommand("copyHelper.copySyntaxInLight", copyHelper.copySyntaxInLight),
|
|
vscode.commands.registerCommand("extension.rotateExplorerSortOrder", settingsHelper.rotateExplorerSortOrder),
|
|
vscode.commands.registerCommand("kanban.openWithTextEditor", kanbanHelper.openWithTextEditor),
|
|
vscode.commands.registerCommand("kanban.openInNewWindow", kanbanHelper.openInNewWindow),
|
|
vscode.commands.registerCommand("markdown.newMarkdownFile", markdownHelper.newMarkdownFile),
|
|
vscode.commands.registerCommand('promiseLinesHelper.codeGeneratorQuickPick', promiseLinesHelper.codeGeneratorQuickPick),
|
|
vscode.commands.registerCommand('promiseLinesHelper.insertDateTime', promiseLinesHelper.insertDateTime),
|
|
vscode.commands.registerCommand("promiseLinesHelper.insertAllExtensions", promiseLinesHelper.insertAllExtensions),
|
|
vscode.commands.registerCommand('promiseLinesHelper.transformToPopperCase', promiseLinesHelper.transformToPopperCase),
|
|
vscode.commands.registerCommand('promiseLinesHelper.transformToParamCase', promiseLinesHelper.transformToParamCase),
|
|
vscode.commands.registerCommand('readOnlyLinesHelper.searchGoogle', readOnlyLinesHelper.searchGoogle),
|
|
vscode.commands.registerCommand('replaceLinesHelper.addCSharpComment', replaceLinesHelper.addCSharpComment),
|
|
vscode.commands.registerCommand('replaceLinesHelper.addVBComment', replaceLinesHelper.addVBComment),
|
|
vscode.commands.registerCommand('replaceLinesHelper.convertToRegularExpression', replaceLinesHelper.convertToRegularExpression),
|
|
vscode.commands.registerCommand('replaceLinesHelper.cutEachLine', replaceLinesHelper.cutEachLine),
|
|
vscode.commands.registerCommand('replaceLinesHelper.distinctLines', replaceLinesHelper.distinctLines),
|
|
vscode.commands.registerCommand('replaceLinesHelper.expandSql', replaceLinesHelper.expandSql),
|
|
vscode.commands.registerCommand('replaceLinesHelper.listToListFamily', replaceLinesHelper.listToListFamily),
|
|
vscode.commands.registerCommand('replaceLinesHelper.listToListWrappedComma', replaceLinesHelper.listToListWrappedComma),
|
|
vscode.commands.registerCommand('replaceLinesHelper.prettySql', replaceLinesHelper.prettySql),
|
|
vscode.commands.registerCommand('replaceLinesHelper.quickFixCamelCaseProperties', replaceLinesHelper.quickFixCamelCaseProperties),
|
|
vscode.commands.registerCommand('replaceLinesHelper.quickFixCS0108', replaceLinesHelper.quickFixCS0108),
|
|
vscode.commands.registerCommand('replaceLinesHelper.quickFixInstanceFieldToCalisthenics', replaceLinesHelper.quickFixInstanceFieldToCalisthenics),
|
|
vscode.commands.registerCommand('replaceLinesHelper.quickFixProperCaseProperties', replaceLinesHelper.quickFixProperCaseProperties),
|
|
vscode.commands.registerCommand('replaceLinesHelper.quickFixPublic', replaceLinesHelper.quickFixPublic),
|
|
vscode.commands.registerCommand('replaceLinesHelper.removeComment', replaceLinesHelper.removeComment),
|
|
vscode.commands.registerCommand('replaceLinesHelper.sortLength', replaceLinesHelper.sortLength),
|
|
vscode.commands.registerCommand('replaceLinesHelper.sortNormal', replaceLinesHelper.sortNormal),
|
|
vscode.commands.registerCommand('replaceLinesHelper.splitBySpaceReverseJoinSort', replaceLinesHelper.splitBySpaceReverseJoinSort),
|
|
vscode.commands.registerCommand('replaceLinesHelper.unwrapSql', replaceLinesHelper.unwrapSql),
|
|
vscode.commands.registerCommand('replaceLinesHelper.wrapSqlCSharp', replaceLinesHelper.wrapSqlCSharp),
|
|
vscode.commands.registerCommand('replaceLinesHelper.wrapSqlVB', replaceLinesHelper.wrapSqlVB),
|
|
vscode.commands.registerCommand("webview.backlogMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'HTML'); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', ''); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayEffortMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'EFFORT'); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayLiveMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'LIVE'); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayWSJFMesa", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'WSJF'); }),
|
|
vscode.commands.registerCommand("webview.backlogLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'HTML'); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', ''); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayEffortLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'EFFORT'); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayLiveLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'LIVE'); }),
|
|
vscode.commands.registerCommand("webview.costOfDelayWSJFLeominster", () => { WebviewPanelCostOfDelay.WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'WSJF'); }),
|
|
vscode.commands.registerCommand("webview.example", () => { WebviewPanelExample.WebviewPanelExample.createOrShow(extensionContext); })
|
|
];
|
|
|
|
commands.forEach(command => extensionContext.subscriptions.push(command));
|
|
}
|
|
|
|
// This method is called when your extension is deactivated
|
|
export function deactivate() { }
|