@parcel/lsp 2.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Devon Govett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@parcel/lsp",
+  "version": "2.7.0",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/parcel.git"
+  },
+  "main": "./out/LspServer.js",
+  "source": "src/LspServer.ts",
+  "scripts": {
+    "vscode:prepublish": "yarn run compile",
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./",
+    "pretest": "yarn run compile && yarn run lint",
+    "lint": "eslint src --ext ts",
+    "test": "node ./out/test/runTest.js"
+  },
+  "engines": {
+    "node": ">= 12.0.0",
+    "parcel": "^2.7.0"
+  },
+  "dependencies": {
+    "@parcel/diagnostic": "2.5.0",
+    "@parcel/plugin": "2.5.0",
+    "@parcel/types": "2.5.0",
+    "@parcel/utils": "2.5.0",
+    "@parcel/watcher": "2.0.5",
+    "node-ipc": "^9.1.4",
+    "nullthrows": "^1.1.1",
+    "ps-node": "^0.1.6",
+    "vscode-languageclient": "^8.0.1",
+    "vscode-languageserver": "^8.0.1",
+    "vscode-languageserver-textdocument": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/glob": "^7.1.3",
+    "@types/mocha": "^8.0.4",
+    "@types/node": "^12.11.7",
+    "@types/node-ipc": "^9.1.3",
+    "@types/vscode": "^1.67.0",
+    "@typescript-eslint/eslint-plugin": "^4.14.1",
+    "@typescript-eslint/parser": "^4.14.1",
+    "eslint": "^7.19.0",
+    "glob": "^7.1.6",
+    "typescript": "^4.6.4"
+  },
+  "gitHead": "9e5d05586577e89991ccf90400f2c741dca11aa3"
+}

package/src/LspServer.ts

@@ -0,0 +1,239 @@
+/* eslint-disable no-console */
+
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import {
+  createConnection,
+  TextDocuments,
+  Diagnostic,
+  DiagnosticSeverity,
+  ProposedFeatures,
+  InitializeParams,
+  DidChangeConfigurationNotification,
+  CompletionItem,
+  CompletionItemKind,
+  TextDocumentPositionParams,
+  TextDocumentSyncKind,
+  InitializeResult,
+  WorkDoneProgressServerReporter,
+} from 'vscode-languageserver/node';
+
+import {
+  CloseAction,
+  ErrorAction,
+  LanguageClient,
+  LanguageClientOptions,
+  MessageTransports,
+} from 'vscode-languageclient/node';
+
+import * as net from 'net';
+import * as invariant from 'assert';
+import nullthrows from 'nullthrows';
+import {IPC} from 'node-ipc';
+
+import {TextDocument} from 'vscode-languageserver-textdocument';
+import * as watcher from '@parcel/watcher';
+
+type IPCType = InstanceType<typeof IPC>;
+
+const connection = createConnection(ProposedFeatures.all);
+
+// Create a simple text document manager.
+const documents: TextDocuments<TextDocument> = new TextDocuments(TextDocument);
+
+let hasConfigurationCapability = false;
+let hasWorkspaceFolderCapability = false;
+let hasDiagnosticRelatedInformationCapability = false;
+
+connection.onInitialize((params: InitializeParams) => {
+  const capabilities = params.capabilities;
+
+  // Does the client support the `workspace/configuration` request?
+  // If not, we fall back using global settings.
+  hasConfigurationCapability = !!(
+    capabilities.workspace && !!capabilities.workspace.configuration
+  );
+  hasWorkspaceFolderCapability = !!(
+    capabilities.workspace && !!capabilities.workspace.workspaceFolders
+  );
+  hasDiagnosticRelatedInformationCapability = !!(
+    capabilities.textDocument &&
+    capabilities.textDocument.publishDiagnostics &&
+    capabilities.textDocument.publishDiagnostics.relatedInformation
+  );
+
+  const result: InitializeResult = {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+      // Tell the client that this server supports code completion.
+      completionProvider: {
+        resolveProvider: true,
+      },
+    },
+  };
+
+  if (hasWorkspaceFolderCapability) {
+    result.capabilities.workspace = {
+      workspaceFolders: {
+        supported: true,
+      },
+    };
+  }
+  return result;
+});
+
+connection.onInitialized(() => {
+  if (hasConfigurationCapability) {
+    // Register for all configuration changes.
+    connection.client.register(
+      DidChangeConfigurationNotification.type,
+      undefined,
+    );
+  }
+  if (hasWorkspaceFolderCapability) {
+    connection.workspace.onDidChangeWorkspaceFolders(_event => {
+      connection.console.log('Workspace folder change event received.');
+    });
+  }
+});
+
+class ProgressReporter {
+  progressReporterPromise?: Promise<WorkDoneProgressServerReporter> | null;
+  lastMessage?: string;
+  begin() {
+    this.progressReporterPromise = (async () => {
+      let reporter = await connection.window.createWorkDoneProgress();
+      reporter.begin('Parcel');
+      return reporter;
+    })();
+    this.progressReporterPromise.then(reporter => {
+      if (this.lastMessage != null) {
+        reporter.report(this.lastMessage);
+      }
+    });
+  }
+  async done() {
+    if (this.progressReporterPromise == null) {
+      this.begin();
+    }
+    invariant(this.progressReporterPromise != null);
+    (await this.progressReporterPromise).done();
+    this.progressReporterPromise = null;
+  }
+  async report(message: string) {
+    if (this.progressReporterPromise == null) {
+      this.lastMessage = message;
+      this.begin();
+    } else {
+      let r = await this.progressReporterPromise;
+      r.report(message);
+    }
+  }
+}
+
+function createIPCClientIfPossible(
+  parcelLspDir: string,
+  filePath: string,
+): {client: IPCType; uris: Set<string>} | undefined {
+  let transportName: string;
+  try {
+    transportName = JSON.parse(
+      fs.readFileSync(filePath, {
+        encoding: 'utf8',
+      }),
+    ).transportName;
+  } catch (e) {
+    // TODO: Handle this
+    console.log(e);
+    return;
+  }
+
+  let uris: Set<string> = new Set();
+  let client = new IPC();
+  client.config.id = `parcel-lsp-${process.pid}`;
+  client.config.retry = 1500;
+  client.connectTo(transportName, function () {
+    client.of[transportName].on(
+      'message', //any event or message type your server listens for
+      function (data: any) {
+        switch (data.type) {
+          case 'parcelBuildEnd':
+            progressReporter.done();
+            break;
+
+          case 'parcelFileDiagnostics':
+            for (let [uri, diagnostics] of data.fileDiagnostics) {
+              connection.sendDiagnostics({uri, diagnostics});
+              uris.add(uri);
+            }
+            break;
+
+          case 'parcelBuildSuccess':
+            progressReporter.done();
+            break;
+
+          case 'parcelBuildStart':
+            uris.clear();
+            progressReporter.begin();
+            break;
+
+          case 'parcelBuildProgress':
+            progressReporter.report(data.message);
+            break;
+
+          default:
+            throw new Error();
+        }
+      },
+    );
+  });
+
+  return {client, uris};
+}
+
+let progressReporter = new ProgressReporter();
+let clients: Map<string, {client: IPCType; uris: Set<string>}> = new Map();
+let parcelLspDir = path.join(fs.realpathSync(os.tmpdir()), 'parcel-lsp');
+fs.mkdirSync(parcelLspDir, {recursive: true});
+// Search for currently running Parcel processes in the parcel-lsp dir.
+// Create an IPC client connection for each running process.
+for (let filename of fs.readdirSync(parcelLspDir)) {
+  const filepath = path.join(parcelLspDir, filename);
+  let client = createIPCClientIfPossible(parcelLspDir, filepath);
+  if (client) {
+    clients.set(filepath, client);
+  }
+}
+
+// Watch for new Parcel processes in the parcel-lsp dir, and disconnect the
+// client for each corresponding connection when a Parcel process ends
+watcher.subscribe(parcelLspDir, async (err, events) => {
+  if (err) {
+    throw err;
+  }
+
+  for (let event of events) {
+    if (event.type === 'create') {
+      let client = createIPCClientIfPossible(parcelLspDir, event.path);
+      if (client) {
+        clients.set(event.path, client);
+      }
+    } else if (event.type === 'delete') {
+      let existing = clients.get(event.path);
+      if (existing) {
+        clients.delete(event.path);
+        for (let id of Object.keys(existing.client.of)) {
+          existing.client.disconnect(id);
+        }
+        await Promise.all(
+          [...existing.uris].map(uri =>
+            connection.sendDiagnostics({uri, diagnostics: []}),
+          ),
+        );
+      }
+    }
+  }
+});
+
+connection.listen();

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es6",
+    "outDir": "out",
+    "lib": ["es6"],
+    "sourceMap": true,
+    "rootDir": "src",
+    "strict": true /* enable all strict type-checking options */
+    /* Additional Checks */
+    // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
+    // "noUnusedParameters": true,  /* Report errors on unused parameters. */
+  },
+  "exclude": ["node_modules", ".vscode-test"]
+}