Added files

Author: andersnm

.gitignore

@@ -0,0 +1,5 @@
+node_modules
+**/.vscode-test
+**/out
+**/dist
+**/*.vsix

.vscodeignore

@@ -0,0 +1,6 @@
+.vscode/**
+.vscode-test/**
+node_modules/**
+.gitignore
+tsconfig.json
+tslint.json

README.md

@@ -0,0 +1,33 @@
+# VSCode Sourcemap Helper
+
+Monorepo for the VSCode Sourcemap Helper extension.
+
+## Getting started
+
+```bash
+# Install dependencies for all projects
+npm install
+
+# Build all projects
+npm run build
+
+# Run tests
+npm run test
+
+# Bundle project with dependencies to single file js
+npm run bundle
+
+# Create extension VSIX from bundle
+npm run vsce
+```
+
+The extension is saved in `packages/vscode-sourcemap-helper/sourcemap-helper-(VERSION).vsix`
+
+Projects:
+
+- [vscode-sourcemap-helper](./packages/vscode-sourcemap-helper/README.md)
+- [vscode-sourcemap-helper-test](./packages/vscode-sourcemap-helper-test/)
+
+## Shout outs
+
+Based on on https://github.com/vladimir-kotikov/vscode-sourcemaps-navigator by Vladimir Kotikov.

package.json

@@ -0,0 +1,15 @@
+{
+  "name": "root",
+  "workspaces": [
+    "packages/vscode-sourcemap-helper",
+    "packages/vscode-sourcemap-helper-test"
+  ],
+  "scripts": {
+    "build": "npm run build --workspaces",
+    "build-all": "npm run build --workspaces",
+    "dev": "npm run dev --w vscode-sourcemap-helper",
+    "test": "npm run test --w packages/vscode-sourcemap-helper-test",
+    "vsce": "npm run vsce --w packages/vscode-sourcemap-helper",
+    "bundle": "npm run bundle --w packages/vscode-sourcemap-helper"
+  }
+}

packages/vscode-sourcemap-helper-test/.vscode-test.js

@@ -0,0 +1,10 @@
+const { defineConfig } = require('@vscode/test-cli');
+
+module.exports = defineConfig({ 
+    files: 'out/**/*.test.js',
+    workspaceFolder: 'test-workspace', // The path to a workspace to open during tests.
+    extensionDevelopmentPath: '../vscode-sourcemap-helper',
+    mocha: {
+
+    }
+ });

packages/vscode-sourcemap-helper-test/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "sourcemap-helper-test",
+  "version": "0.0.0",
+  "publisher": "andersnm",
+  "private": true,
+  "engines": {
+    "vscode": "^1.90.0"
+  },
+  "main": "./out/src/extension",
+  "scripts": {
+    "build": "tsc -p ./",
+    "test": "vscode-test",
+    "testold": "node ./node_modules/vscode/bin/test"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.12.12",
+    "@types/node-fetch": "^2.6.11",
+    "@types/vscode": "1.90.0",
+    "@vscode/test-cli": "^0.0.9",
+    "@vscode/test-electron": "^2.4.0",
+    "@vscode/vsce": "^2.26.1",
+    "tslint": "^4.4.2",
+    "typescript": "5.4.5",
+    "vscode-test": "^1.6.1"
+  },
+  "dependencies": {
+    "node-fetch": "^2.7.0",
+    "source-map": "^0.7.4",
+    "vscode-sourcemap-helper": "file:../vscode-sourcemap-helper"
+  }
+}

packages/vscode-sourcemap-helper-test/src/extension.test.ts

@@ -0,0 +1,129 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+
+import { SourceMapStore, encodeSourceMapSourceUri, OutputChannelLogger } from 'vscode-sourcemap-helper';
+// import { SourceMapStore } from '../src/SourceMapStore';
+import { createServer, stopServer } from './server';
+// import { encodeSourceMapSourceUri } from '../src/UriHelper';
+import { SourceMapConsumer } from 'source-map';
+// import { OutputChannelLogger } from '../src/Logger';
+
+export async function closeFileIfOpen(file: vscode.Uri) : Promise<void> {
+    const tabs: vscode.Tab[] = vscode.window.tabGroups.all.map(tg => tg.tabs).flat();
+    const index = tabs.findIndex(tab => tab.input instanceof vscode.TabInputText && tab.input.uri.path === file.path);
+    if (index !== -1) {
+        await vscode.window.tabGroups.close(tabs[index]);
+    }
+}
+
+function getSourceMapConsumerSources(sourceMap: SourceMapConsumer) {
+    const sources = [];
+    sourceMap.eachMapping(item => {
+        if (sources.includes(item.source)) {
+            return;
+        }
+
+        sources.push(item.source);
+    });
+
+    return sources;
+}
+
+async function testOpenSourceFilesFor(generatedFileWithMap: vscode.Uri) {
+    const document = await vscode.workspace.openTextDocument(generatedFileWithMap);
+    const outputChannel = vscode.window.createOutputChannel('Source maps');
+    const logger = new OutputChannelLogger(outputChannel);
+    const sms = new SourceMapStore(logger);
+    const mapping = await sms.getForDocument(document);
+    const sources = getSourceMapConsumerSources(mapping.sourceMap);
+
+    for (let source of sources) {
+        const sourceUri = encodeSourceMapSourceUri(mapping.sourceMapUri, source);
+
+        await assert.doesNotReject(async () => {
+            const sourceDocument = await vscode.workspace.openTextDocument(sourceUri);
+            const sourceEditor = await vscode.window.showTextDocument(sourceDocument);
+
+            await closeFileIfOpen(sourceUri);
+        });
+    }
+
+}
+
+suite("SourceMapStore", () => {
+
+    suiteSetup(async () => {
+        // wait for activation
+
+        // perhaps, can call activate from here? if it checks the singleton
+
+        // await extensionActivated;
+    });
+    
+    test("flat: Open source files", async () => {
+        const workspaceUri = vscode.workspace.workspaceFolders[0].uri;
+        const minJsUri = vscode.Uri.joinPath(workspaceUri, "flat/min.js")
+        await testOpenSourceFilesFor(minJsUri);
+        // assert.equal(workspaceUri.toString(true) + "/flat", mapping.sourceMapBaseUri.toString(true));
+    });
+
+    test("flat_no_sourceRoot: Open source files", async () => {
+        const workspaceUri = vscode.workspace.workspaceFolders[0].uri;
+        const minJsUri = vscode.Uri.joinPath(workspaceUri, "flat_no_sourceRoot/min.js")
+        await testOpenSourceFilesFor(minJsUri);
+        // assert.equal(workspaceUri.toString(true) + "/flat", mapping.sourceMapBaseUri.toString(true));
+    });
+
+    test("with_src_out: Open source files", async () => {
+        const workspaceUri = vscode.workspace.workspaceFolders[0].uri;
+        const minJsUri = vscode.Uri.joinPath(workspaceUri, "with_src_out/out/min.js")
+        await testOpenSourceFilesFor(minJsUri);
+        // assert.equal(workspaceUri.toString(true) + "/flat", mapping.sourceMapBaseUri.toString(true));
+    });
+
+    test("with_src_out_no_sourceRoot: Open source files", async () => {
+        const workspaceUri = vscode.workspace.workspaceFolders[0].uri;
+        const minJsUri = vscode.Uri.joinPath(workspaceUri, "with_src_out_no_sourceRoot/out/min.js")
+        await testOpenSourceFilesFor(minJsUri);
+    });
+
+    test("inline: Open source files", async () => {
+        const workspaceUri = vscode.workspace.workspaceFolders[0].uri;
+        const minJsUri = vscode.Uri.joinPath(workspaceUri, "inline/min.js")
+        await testOpenSourceFilesFor(minJsUri);
+    });
+
+    test("flat via http", async () => {
+        const httpRootUri = vscode.workspace.workspaceFolders[0].uri;
+        const server = await createServer("localhost", 8809, httpRootUri.fsPath);
+
+        const minJsUri = vscode.Uri.parse("sourcemap-http://localhost:8809/flat/min.js");
+        // const minJsUri = encodeSourceMapSourceUri(vscode.Uri.parse("null:null"), vscode.Uri.parse("http://localhost:8809/flat/min.js"));
+        await testOpenSourceFilesFor(minJsUri);
+
+        await stopServer(server);
+    });
+
+    test("flat_no_sourceRoot via http", async () => {
+        const httpRootUri = vscode.workspace.workspaceFolders[0].uri;
+        const server = await createServer("localhost", 8809, httpRootUri.fsPath);
+
+        const minJsUri = vscode.Uri.parse("sourcemap-http://localhost:8809/flat_no_sourceRoot/min.js");
+        // const minJsUri = encodeSourceMapSourceUri(vscode.Uri.parse("null:null"), vscode.Uri.parse("http://localhost:8809/flat_no_sourceRoot/min.js"));
+        await testOpenSourceFilesFor(minJsUri);
+
+        await stopServer(server);
+    });
+
+    test("remote via http", async () => {
+        const httpRootUri = vscode.workspace.workspaceFolders[0].uri;
+        const server = await createServer("localhost", 8809, httpRootUri.fsPath);
+
+        const minJsUri = vscode.Uri.parse("sourcemap-http://localhost:8809/remote/min.js");
+        // const minJsUri = encodeSourceMapSourceUri(vscode.Uri.parse("null:null"), vscode.Uri.parse("http://localhost:8809/remote/min.js"));
+        await testOpenSourceFilesFor(minJsUri);
+
+        await stopServer(server);
+    });
+
+});

packages/vscode-sourcemap-helper-test/src/index.ts

@@ -0,0 +1,22 @@
+//
+// PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING
+//
+// This file is providing the test runner to use when running extension tests.
+// By default the test runner in use is Mocha based.
+//
+// You can provide your own test runner if you want to override it by exporting
+// a function run(testRoot: string, clb: (error:Error) => void) that the extension
+// host can call to run the tests. The test runner is expected to use console.log
+// to report the results back to the caller. When the tests are finished, return
+// a possible error to the callback or null if none.
+
+var testRunner = require('vscode/lib/testrunner');
+
+// You can directly control Mocha options by uncommenting the following lines
+// See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
+testRunner.configure({
+    ui: 'tdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
+    useColors: true // colored output from test results
+});
+
+module.exports = testRunner;

packages/vscode-sourcemap-helper-test/src/server.ts

@@ -0,0 +1,95 @@
+// quick and dirty http server based on https://stackoverflow.com/a/29046869
+import * as fs from 'fs/promises';
+import * as http from 'http';
+import * as path from 'path';
+
+async function serveStaticFile(request: http.IncomingMessage, response: http.ServerResponse, rootPath: string) {
+  const filePath = path.join(rootPath, request.url)
+
+  console.log('HTTP server: ' + request.url + ", " + filePath);
+
+  const extname = path.extname(filePath);
+  let contentType = 'text/html';
+  switch (extname) {
+    case '.js':
+      contentType = 'text/javascript';
+      break;
+    case '.css':
+      contentType = 'text/css';
+      break;
+    case '.json':
+    case '.map':
+      contentType = 'application/json';
+      break;
+    case '.png':
+      contentType = 'image/png';
+      break;
+    case '.jpg':
+      contentType = 'image/jpg';
+      break;
+    case '.wav':
+      contentType = 'audio/wav';
+      break;
+  }
+
+  try {
+    const content = await fs.readFile(filePath);
+    response.writeHead(200, { 'Content-Type': contentType });
+    response.end(content, 'utf-8');
+  } catch (error) {
+    response.writeHead(500);
+    response.end('HTTP 500 Server error: ' + error.code + '\n');
+    response.end(); 
+  }
+};
+
+export async function createServer(host, port, rootPath): Promise<http.Server> {
+
+  const requestListener = (request: http.IncomingMessage, response: http.ServerResponse) => {
+    serveStaticFile(request, response, rootPath);
+  };
+
+  const server = http.createServer(requestListener);
+
+  return new Promise<http.Server>((resolve, reject) => {
+    const error = () => {
+      server.off("listening", listening);
+      server.off("error", error);
+      reject();
+    };
+
+    const listening = () => {
+      console.log(`HTTP server is running on http://${host}:${port}`);
+      server.off("listening", listening);
+      server.off("error", error);
+      resolve(server);
+    };
+
+    server.on("error", error);
+    server.on("listening", listening);
+
+    server.listen(port, host);
+  });
+}
+
+export async function stopServer (server: http.Server) {
+  return new Promise<void>((resolve, reject) => {
+    const close = (err: any) => {
+      server.off("close", close);
+
+      if (err) {
+        console.log(`HTTP server failed to stop ` + err.message);
+        reject(err);
+        return;
+      }
+
+      console.log(`HTTP server stopped`);
+      resolve();
+    };
+
+    server.on("close", close);
+
+    server.close();
+    server.closeAllConnections();
+  });
+}