public async show()

in src/extension/panel.ts [35:152]


    public async show() {
        if (this.panel) {
            if (!this.panel.active) this.panel.reveal(undefined, true);
            return;
        }

        const {context, basing, store} = this;
        const {webview} = this.panel = window.createWebviewPanel(
            'Index', `${this.title}s`, { preserveFocus: true, viewColumn: ViewColumn.Two }, // ViewColumn.Besides steals focus regardless of preserveFocus.
            {
                enableScripts: true,
                localResourceRoots: [Uri.file('/'), ...'abcdefghijklmnopqrstuvwxyz'.split('').map(c => Uri.file(`${c}:`))],
                retainContextWhenHidden: true,
            }
        );
        this.panel.onDidDispose(() => this.panel = null);

        const src = Uri.file(`${context.extensionPath}/out/panel.js`);
        const defaultState = {
            version: 0,
            filtersRow,
            filtersColumn,
        };
        const state = Store.globalState.get('view', defaultState);
        webview.html = `<!DOCTYPE html>
            <html lang="en">
            <head>
                <meta charset="UTF-8">
                <meta http-equiv="Content-Security-Policy" content="
                    default-src 'none';
                    connect-src vscode-resource:;
                    font-src    vscode-resource:;
                    script-src  vscode-resource: 'unsafe-inline';
                    style-src   vscode-resource: 'unsafe-inline';
                    ">
                <style>
                    code { font-family: ${workspace.getConfiguration('editor').get('fontFamily')} }
                </style>
            </head>
            <body>
                <div id="root"></div>
                <script src="${webview.asWebviewUri(src).toString()}"></script>
                <script>
                    vscode = acquireVsCodeApi();
                    (async () => {
                        const store = new Store(${JSON.stringify(state)})
                        await store.onMessage({ data: ${JSON.stringify(this.createSpliceLogsMessage([], store.logs))} })
                        ReactDOM.render(
                            React.createElement(Index, { store }),
                            document.getElementById('root'),
                        )
                    })();
                </script>
            </body>
            </html>`;

        webview.onDidReceiveMessage(async message => {
            if (!message) return;
            switch (message.command as CommandPanelToExtension) {
            case 'open': {
                const uris = await window.showOpenDialog({
                    canSelectMany: true,
                    defaultUri: workspace.workspaceFolders?.[0]?.uri,
                    filters: { 'SARIF files': ['sarif', 'json'] },
                });
                if (!uris) return;
                store.logs.push(...await loadLogs(uris));
                break;
            }
            case 'closeLog': {
                store.logs.removeFirst(log => log._uri === message.uri);
                break;
            }
            case 'closeAllLogs': {
                store.logs.splice(0);
                break;
            }
            case 'select': {
                const {logUri, uri, region} = message as { logUri: string, uri: string, region: Region};
                const validatedUri = await basing.translateArtifactToLocal(uri);
                if (!validatedUri) return;
                await this.selectLocal(logUri, validatedUri, region);
                break;
            }
            case 'selectLog': {
                const [logUri, runIndex, resultIndex] = message.id as ResultId;
                const log = store.logs.find(log => log._uri === logUri);
                const result = store.logs.find(log => log._uri === logUri)?.runs[runIndex]?.results?.[resultIndex];
                if (!log || !result) return;

                const logUriUpgraded = log._uriUpgraded ?? log._uri;
                if (!log._jsonMap) {
                    const file = fs.readFileSync(Uri.parse(logUriUpgraded).fsPath, 'utf8')  // Assume scheme file.
                        .replace(/^\uFEFF/, ''); // Trim BOM.
                    log._jsonMap = (jsonMap.parse(file) as { pointers: JsonMap }).pointers;
                }

                const { value, valueEnd } = log._jsonMap[`/runs/${runIndex}/results/${resultIndex}`];
                const resultRegion = {
                    startLine: value.line,
                    startColumn: value.column,
                    endLine: valueEnd.line,
                    endColumn: valueEnd.column,
                } as Region;
                await this.selectLocal(logUri, logUriUpgraded, resultRegion);
                break;
            }
            case 'setState': {
                const oldState = Store.globalState.get('view', defaultState);
                const {state} = message;
                await Store.globalState.update('view', Object.assign(oldState, JSON.parse(state)));
                break;
            }
            default:
                throw new Error(`Unhandled command: ${message.command}`,);
            }
        }, undefined, context.subscriptions);
    }