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

## 1.112.0

Browse Source
This commit is contained in:
Mike Phares
2025-01-31 14:14:52 -07:00
parent 8ca13ac88a
commit 5269b0db43
12 changed files with 418 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
type-script-helper/src/WebviewPanelCostOfDelay.ts Normal file
View File

@ -0,0 +1,217 @@
import * as vscode from "vscode";
import { getNonce } from "./getNonce";
import { apiBaseUrl } from "./constants";
import { PostMessage } from "./PostMessage";
import { title } from "process";
export class WebviewPanelCostOfDelay {
/**
* Track the currently panel. Only allow a single panel to exist at a time.
*/
public static _site: string;
public static _view: string;
public static currentPanel: WebviewPanelCostOfDelay | undefined;
public static readonly viewType = "web-view-panel";
private _disposables: vscode.Disposable[] = [];
public static createOrShow(extensionContext: vscode.ExtensionContext, site: string, view: string) {
this._site = site;
this._view = view;
const column = vscode.window.activeTextEditor
? vscode.window.activeTextEditor.viewColumn
: undefined;
// If we already have a panel, show it.
if (WebviewPanelCostOfDelay.currentPanel) {
WebviewPanelCostOfDelay.currentPanel._panel.reveal(column);
WebviewPanelCostOfDelay.currentPanel._update(site, view);
return;
}
const title = view === '' ? 'Cost of Delay (CoD)' :
view === 'EFFORT' ? 'Effort' :
view === 'LIVE' ? 'Cost of Delay (CoD) - Live Update' :
view === 'WSJF' ? 'Weightest Shortest Job First calculation (WSJF)' :
'CoD';
// Otherwise, create a new panel.
const panel = vscode.window.createWebviewPanel(
WebviewPanelCostOfDelay.viewType,
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"),
],
}
);
WebviewPanelCostOfDelay.currentPanel = new WebviewPanelCostOfDelay(panel, extensionContext, site, view);
}
public static kill() {
WebviewPanelCostOfDelay.currentPanel?.dispose();
WebviewPanelCostOfDelay.currentPanel = undefined;
}
public static revive(panel: vscode.WebviewPanel, extensionContext: vscode.ExtensionContext) {
WebviewPanelCostOfDelay.currentPanel = new WebviewPanelCostOfDelay(panel, extensionContext, this._site, this._view);
}
private constructor(private readonly _panel: vscode.WebviewPanel, private readonly _extensionContext: vscode.ExtensionContext, site: string, view: string) {
// Set the webview's initial html content
this._update(site, view);
// Listen for when the panel is disposed
// This happens when the user closes the panel or when the panel is closed programmatically
this._panel.onDidDispose(() => this.dispose(), null, this._disposables);
// // Handle messages from the webview
// this._panel.webview.onDidReceiveMessage(
// (message) => {
// switch (message.command) {
// case "alert":
// vscode.window.showErrorMessage(message.text);
// return;
// }
// },
// null,
// this._disposables
// );
}
public dispose() {
WebviewPanelCostOfDelay.currentPanel = undefined;
// Clean up our resources
this._panel.dispose();
while (this._disposables.length) {
const x = this._disposables.pop();
if (x) {
x.dispose();
}
}
}
private async _update(site: string, view: string) {
const webview = this._panel.webview;
this._panel.webview.html = this._getHtmlForWebview(site, view, webview);
webview.onDidReceiveMessage(async (postMessage: PostMessage) => {
switch (postMessage.type) {
case "on-info":
if (!postMessage.value)
return;
vscode.window.showInformationMessage(postMessage.value);
break;
case "on-error":
if (!postMessage.value)
return;
vscode.window.showErrorMessage(postMessage.value);
break;
default:
vscode.window.showErrorMessage(postMessage.type);
break;
}
});
}
private _getHtmlForWebview(site: string, view: string, webview: vscode.Webview) {
const baseUri = 'https://eaf-dev.mes.infineon.com';
const styleBootstrapUri = webview.asWebviewUri(
vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "bootstrap.min.css")
);
const styleCostOfDelayUri = webview.asWebviewUri(
vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "cod.css")
);
const scriptJQueryUri = webview.asWebviewUri(
vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "jquery-1.6.4.min.js")
);
const scriptSignalRUri = webview.asWebviewUri(
vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "jquery.signalR-2.4.3.min.js")
);
const scriptCostOfDelayUri = webview.asWebviewUri(
vscode.Uri.joinPath(this._extensionContext.extensionUri, "media", "cost-of-delay.js")
);
// Use a nonce to only allow a specific script to be run.
const nonce = getNonce();
return `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Infineon - Cost of Delay (CoD) (see @SCALE formula)</title>
<link href="${styleBootstrapUri}" rel="stylesheet" />
<link href="${styleCostOfDelayUri}" rel="stylesheet" />
<script nonce="${nonce}" src="${scriptJQueryUri}"></script>
<script nonce="${nonce}" src="${scriptSignalRUri}"></script>
<script nonce="${nonce}" src="${baseUri}/signalr/hubs"></script>
<script nonce="${nonce}" src="${baseUri}/js/cod-b.js?v=2025-01-22-10-49" type="text/javascript"></script>
<script nonce="${nonce}">
const _webviewSite = '${site}';
const _webviewView = '${view}';
const acquiredVsCodeApi = acquireVsCodeApi();
const apiBaseUrl = ${JSON.stringify(apiBaseUrl)}
const _webviewUsername = '${process.env.USERNAME}';
const _webviewMachineId = '${vscode.env.machineId}';
</script>
</head>
<body>
<div class="navbar navbar-fixed-top">
<div class="container-fluid">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<div class="navbar-brand">
<span id="siteHeader">&nbsp;</span> -
<span id="th-span">&nbsp;</span>
<button id="toggle">Toggle</button>
</div>
</div>
<div class="navbar-collapse collapse">
<ul class="nav navbar-nav">
</ul>
<p class="navbar-text navbar-right">
&nbsp;
</p>
</div>
</div>
</div>
<div class="container-fluid body-content" style="margin-top: 40px; margin-left: 15px;">
<div id="HeaderGridDiv">
<table id="HeaderGrid" border="1"></table>
</div>
<br />&nbsp;
<div id="AllGridDiv">
<table id="AllGrid"></table>
</div>
<textarea id="AllTextarea" rows="20" cols="147"></textarea>
</div>
<script nonce="${nonce}" src="${scriptCostOfDelayUri}"></script>
</body>
</html>`;
}
}

28
type-script-helper/src/WebViewPanel.ts → type-script-helper/src/WebviewPanelExample.ts
View File

@ -3,16 +3,16 @@ import { getNonce } from "./getNonce";
import { apiBaseUrl } from "./constants";
import { PostMessage } from "./PostMessage";
export function refreshWebView(extensionContext: vscode.ExtensionContext): any {
WebViewPanel.kill();
WebViewPanel.createOrShow(extensionContext);
export function refreshWebviewPanelExample(extensionContext: vscode.ExtensionContext): any {
WebviewPanelExample.kill();
WebviewPanelExample.createOrShow(extensionContext);
}
export class WebViewPanel {
export class WebviewPanelExample {
/**
* Track the currently panel. Only allow a single panel to exist at a time.
*/
public static currentPanel: WebViewPanel | undefined;
public static currentPanel: WebviewPanelExample | undefined;
public static readonly viewType = "web-view-panel";
@ -24,15 +24,15 @@ export class WebViewPanel {
: undefined;
// If we already have a panel, show it.
if (WebViewPanel.currentPanel) {
WebViewPanel.currentPanel._panel.reveal(column);
WebViewPanel.currentPanel._update();
if (WebviewPanelExample.currentPanel) {
WebviewPanelExample.currentPanel._panel.reveal(column);
WebviewPanelExample.currentPanel._update();
return;
}
// Otherwise, create a new panel.
const panel = vscode.window.createWebviewPanel(
WebViewPanel.viewType,
WebviewPanelExample.viewType,
"Web-View-Panel",
column || vscode.ViewColumn.One,
{
@ -47,16 +47,16 @@ export class WebViewPanel {
}
);
WebViewPanel.currentPanel = new WebViewPanel(panel, extensionContext);
WebviewPanelExample.currentPanel = new WebviewPanelExample(panel, extensionContext);
}
public static kill() {
WebViewPanel.currentPanel?.dispose();
WebViewPanel.currentPanel = undefined;
WebviewPanelExample.currentPanel?.dispose();
WebviewPanelExample.currentPanel = undefined;
}
public static revive(panel: vscode.WebviewPanel, extensionContext: vscode.ExtensionContext) {
WebViewPanel.currentPanel = new WebViewPanel(panel, extensionContext);
WebviewPanelExample.currentPanel = new WebviewPanelExample(panel, extensionContext);
}
private constructor(private readonly _panel: vscode.WebviewPanel, private readonly _extensionContext: vscode.ExtensionContext) {
@ -83,7 +83,7 @@ export class WebViewPanel {
}
public dispose() {
WebViewPanel.currentPanel = undefined;
WebviewPanelExample.currentPanel = undefined;
// Clean up our resources
this._panel.dispose();

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

@ -6,9 +6,10 @@ import * as kanbanHelper from './kanbanHelper';
import * as markdownHelper from './markdownHelper';
import * as promiseLinesHelper from './promiseLinesHelper';
import * as replaceLinesHelper from './replaceLinesHelper';
import { WebviewPanelExample } from './WebviewPanelExample';
import * as readOnlyLinesHelper from './readOnlyLinesHelper';
import { WebViewPanel, refreshWebView } from "./WebViewPanel";
import { ColumnsToCardsWebviewViewProvider, refreshSidebar } from "./ColumnsToCardsWebviewViewProvider";
import { WebviewPanelCostOfDelay } from './WebviewPanelCostOfDelay';
import { ColumnsToCardsWebviewViewProvider, refreshSidebar } from './ColumnsToCardsWebviewViewProvider';
// This method is called when your extension is activated
// Your extension is activated the very first time the command is executed
@ -41,7 +42,6 @@ export async function activate(extensionContext: vscode.ExtensionContext) {
vscode.commands.registerCommand("copyHelper.copySyntaxInLight", copyHelper.copySyntaxInLight),
vscode.commands.registerCommand("kanban.refreshBoth", () => { kanbanHelper.refreshBoth(extensionContext); }),
vscode.commands.registerCommand("kanban.refreshSidebar", refreshSidebar),
vscode.commands.registerCommand("kanban.refreshWebView", () => { refreshWebView(extensionContext); }),
vscode.commands.registerCommand("kanban.openWithTextEditor", kanbanHelper.openWithTextEditor),
vscode.commands.registerCommand("kanban.openInNewWindow", kanbanHelper.openInNewWindow),
vscode.commands.registerCommand("markdown.newMarkdownFile", markdownHelper.newMarkdownFile),
@ -72,7 +72,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.webView", () => { WebViewPanel.createOrShow(extensionContext); })
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); })
];
commands.forEach(command => extensionContext.subscriptions.push(command));

2
type-script-helper/src/kanbanHelper.ts
View File

@ -1,11 +1,9 @@
import * as vscode from 'vscode';
import { refreshWebView } from './WebViewPanel';
import { paramCase } from './promiseLinesHelper';
import { refreshSidebar } from './ColumnsToCardsWebviewViewProvider';
export function refreshBoth(extensionContext: vscode.ExtensionContext): any {
refreshSidebar();
refreshWebView(extensionContext);
setTimeout(() => { vscode.commands.executeCommand("workbench.action.webview.openDeveloperTools"); }, 500);
}