phares3757/yo-vscode
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

## 1.116.0

Browse Source
This commit is contained in:
Mike Phares
2025-02-24 17:36:06 -07:00
parent baa3c222f3
commit ab334f91dc
8 changed files with 439 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
type-script-helper/src/calculator.ts Normal file
View File

@ -0,0 +1,193 @@
import * as vscode from 'vscode';
import * as editorCalc from 'editor-calc';
export class CalcProvider implements vscode.CompletionItemProvider {
public enableActive: boolean;
private decorationType: vscode.TextEditorDecorationType;
constructor(
public config: vscode.WorkspaceConfiguration,
private onError: (error: unknown) => any,
) {
this.enableActive = false;
this.decorationType = vscode.window.createTextEditorDecorationType({
dark: {
border: '1px dashed gray',
},
light: {
border: '1px dashed black',
},
});
}
public async highlight(range: vscode.Range) {
const editor = vscode.window.activeTextEditor;
if (editor) {
editor.setDecorations(this.decorationType, [range]);
}
}
public async clearHighlight() {
const editor = vscode.window.activeTextEditor;
if (editor) {
editor.setDecorations(this.decorationType, []);
}
}
public calculateLine(
position: vscode.Position,
exprLine: string,
): {
skip: number;
result: string;
insertText: string;
expressionRange: vscode.Range;
expressionWithEqualSignRange: vscode.Range;
expressionEndRange: vscode.Range;
} | null {
let skip, result;
try {
({ skip, result } = editorCalc.calculate(exprLine));
} catch (error) {
this.onError(error);
return null;
}
const formulaRaw = exprLine.slice(skip);
const leftMatches = formulaRaw.match(/^\s+/);
const leftEmpty = leftMatches ? leftMatches[0].length : 0;
const rightMatches = formulaRaw.match(/[\s=]+$/);
const rightEmpty = rightMatches ? rightMatches[0].length : 0;
const insertText = exprLine.endsWith(' =') ? ` ${result}` : result;
return {
skip,
result,
insertText,
expressionRange: new vscode.Range(
position.line,
skip + leftEmpty,
position.line,
position.character - rightEmpty,
),
expressionWithEqualSignRange: new vscode.Range(
position.line,
skip + leftEmpty,
position.line,
position.character,
),
expressionEndRange: new vscode.Range(
position.line,
position.character,
position.line,
position.character,
),
};
}
private getCompletionResultsFromExtraCursors(document: vscode.TextDocument): {
additionalReplacements: vscode.Range[];
additionalTextInserts: string[];
additionalResults: string[];
} {
const additionalReplacements = [];
const additionalTextInserts = [];
const additionalResults = [];
const editor = vscode.window.activeTextEditor;
if (editor) {
for (const selection of editor.selections.slice(1)) {
const position = selection.active;
const exprLine = document.getText(
new vscode.Range(new vscode.Position(position.line, 0), position),
);
const lineCalcResult = this.calculateLine(position, exprLine);
if (lineCalcResult == null) {
continue;
}
const { expressionWithEqualSignRange, insertText, result } =
lineCalcResult;
additionalReplacements.push(expressionWithEqualSignRange);
additionalTextInserts.push(insertText);
additionalResults.push(result);
}
}
return { additionalReplacements, additionalTextInserts, additionalResults };
}
public async provideCompletionItems(
document: vscode.TextDocument,
position: vscode.Position,
_token: vscode.CancellationToken,
_context: vscode.CompletionContext,
): Promise<vscode.CompletionItem[]> {
const exprLine = document.getText(
new vscode.Range(new vscode.Position(position.line, 0), position),
);
if (!this.enableActive && !exprLine.trimRight().endsWith('=')) {
return [];
}
const lineCalcResult = this.calculateLine(position, exprLine);
if (lineCalcResult == null) {
return [];
}
const {
skip,
result,
expressionRange,
expressionWithEqualSignRange,
expressionEndRange,
insertText,
} = lineCalcResult;
this.clearHighlight().catch(this.onError);
this.highlight(expressionRange).catch(this.onError);
const { additionalReplacements, additionalTextInserts, additionalResults } =
this.getCompletionResultsFromExtraCursors(document);
const documentationPostfix =
additionalResults.length > 0 ? ' (multiple)' : '';
return [
{
label: result,
kind: vscode.CompletionItemKind.Constant,
detail: `calc append${documentationPostfix}`,
documentation: `\`${exprLine
.slice(skip)
.trimStart()}${insertText}\`${documentationPostfix}`,
range: expressionEndRange,
additionalTextEdits: [
vscode.TextEdit.insert(expressionWithEqualSignRange.end, insertText),
...additionalReplacements.map((replacementRange, i) =>
vscode.TextEdit.insert(replacementRange.end, additionalTextInserts[i]),
),
],
insertText: '', // text specified here will be inserted on every line
},
{
label: result,
kind: vscode.CompletionItemKind.Constant,
detail: `calc replace${documentationPostfix}`,
documentation: `\`${result}\`${documentationPostfix}`,
additionalTextEdits: [
vscode.TextEdit.replace(expressionWithEqualSignRange, result),
...additionalReplacements.map((replacementRange, i) =>
vscode.TextEdit.replace(replacementRange, additionalResults[i]),
),
],
insertText: '',
},
];
}
async resolveCompletionItem(
item: vscode.CompletionItem,
_token: vscode.CancellationToken,
): Promise<vscode.CompletionItem> {
return item;
}
}

142
type-script-helper/src/extension.ts
View File

@ -1,21 +1,23 @@
// 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 { WebviewPanelExample } from './WebviewPanelExample';
import * as readOnlyLinesHelper from './readOnlyLinesHelper';
import { WebviewPanelCostOfDelay } from './WebviewPanelCostOfDelay';
import { ColumnsToCardsWebviewViewProvider, refreshSidebar } from './ColumnsToCardsWebviewViewProvider';
import * as WebviewPanelExample from './WebviewPanelExample';
import * as WebviewPanelCostOfDelay from './WebviewPanelCostOfDelay';
import * as ColumnsToCardsWebviewViewProvider from './ColumnsToCardsWebviewViewProvider';
// 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 columnsToCardsWebviewViewProvider = new ColumnsToCardsWebviewViewProvider(extensionContext);
const columnsToCardsWebviewViewProvider = new ColumnsToCardsWebviewViewProvider.ColumnsToCardsWebviewViewProvider(extensionContext);
const item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right);
item.text = "$(beaker) Show Kanban";
@ -23,25 +25,113 @@ export async function activate(extensionContext: vscode.ExtensionContext) {
item.show();
extensionContext.subscriptions.push(vscode.window.registerWebviewViewProvider("columns-to-cards-webview-view-provider", columnsToCardsWebviewViewProvider));
// Use the console to output diagnostic information (console.log) and errors (console.error)
// This line of code will only be executed once when your extension is activated
console.log('Congratulations, your extension "type-script-helper":1.6.2 is now active!');
const config = vscode.workspace.getConfiguration('calc');
const outputChannel = vscode.window.createOutputChannel('calc');
// // The command has been defined in the package.json file
// // Now provide the implementation of the command with registerCommand
// // The commandId parameter must match the command field in package.json
// let disposable = vscode.commands.registerCommand('type-script-helper.helloWorld', () => {
// // The code you place here will be executed every time your command is executed
// // Display a message box to the user
// vscode.window.showInformationMessage('Hello World from type-script-helper!');
// });
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);
}
};
// context.subscriptions.push(disposable);
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);
}),
);
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.refreshBoth", () => { kanbanHelper.refreshBoth(extensionContext); }),
vscode.commands.registerCommand("kanban.refreshSidebar", refreshSidebar),
vscode.commands.registerCommand("kanban.refreshSidebar", ColumnsToCardsWebviewViewProvider.refreshSidebar),
vscode.commands.registerCommand("kanban.openWithTextEditor", kanbanHelper.openWithTextEditor),
vscode.commands.registerCommand("kanban.openInNewWindow", kanbanHelper.openInNewWindow),
vscode.commands.registerCommand("markdown.newMarkdownFile", markdownHelper.newMarkdownFile),
@ -72,15 +162,15 @@ export async function activate(extensionContext: vscode.ExtensionContext) {
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.costOfDelayMesa", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', ''); }),
vscode.commands.registerCommand("webview.costOfDelayEffortMesa", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'EFFORT'); }),
vscode.commands.registerCommand("webview.costOfDelayLiveMesa", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'LIVE'); }),
vscode.commands.registerCommand("webview.costOfDelayWSJFMesa", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'MES', 'WSJF'); }),
vscode.commands.registerCommand("webview.costOfDelayLeominster", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', ''); }),
vscode.commands.registerCommand("webview.costOfDelayEffortLeominster", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'EFFORT'); }),
vscode.commands.registerCommand("webview.costOfDelayLiveLeominster", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'LIVE'); }),
vscode.commands.registerCommand("webview.costOfDelayWSJFLeominster", () => { WebviewPanelCostOfDelay.createOrShow(extensionContext, 'LEO', 'WSJF'); }),
vscode.commands.registerCommand("webview.example", () => { WebviewPanelExample.createOrShow(extensionContext); })
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.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));

29
type-script-helper/src/settingsHelper.ts Normal file
View File

@ -0,0 +1,29 @@
import * as vscode from 'vscode';
async function rotateExplorerSortOrderLogic(): Promise<any> {
const config = vscode.workspace.getConfiguration("explorer");
const sortOrder = config.get("sortOrder");
let sortOrderOptions = [
"default",
"modified",
"type",
"mixed",
"filesFirst",
"foldersNestsFiles",
];
let index = sortOrderOptions.findIndex(l => l === sortOrder);
if (index !== -1)
index++;
else
index = 0;
if (index >= sortOrderOptions.length)
index = 0;
let value = sortOrderOptions[index];
await config.update("sortOrder", value);
index++;
if (index >= sortOrderOptions.length)
index = 0;
vscode.window.showInformationMessage(`Explorer Sort Order set to: ${value}; next will be: ${sortOrderOptions[index]};`);
}
export const rotateExplorerSortOrder = () => rotateExplorerSortOrderLogic();