@codingame/monaco-vscode-standalone-html-language-features 23.1.1 → 23.2.0

package/language/html/htmlMode.js

@@ -0,0 +1,141 @@
+import { WorkerManager } from './workerManager.js';
+import { HoverAdapter, DocumentHighlightAdapter, DocumentLinkAdapter, FoldingRangeAdapter, DocumentSymbolAdapter, SelectionRangeAdapter, RenameAdapter, DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider, CompletionAdapter } from '../common/lspLanguageFeatures.js';
+export { DefinitionAdapter, DiagnosticsAdapter, DocumentColorAdapter, ReferenceAdapter, fromPosition, fromRange, toRange, toTextEdit } from '../common/lspLanguageFeatures.js';
+import { languages } from 'monaco-editor';
+
+class HTMLCompletionAdapter extends CompletionAdapter {
+  constructor(worker) {
+    super(worker, [".", ":", "<", '"', "=", "/"]);
+  }
+}
+function setupMode1(defaults) {
+  const client = new WorkerManager(defaults);
+  const worker = (...uris) => {
+    return client.getLanguageServiceWorker(...uris);
+  };
+  let languageId = defaults.languageId;
+  languages.registerCompletionItemProvider(languageId, new HTMLCompletionAdapter(worker));
+  languages.registerHoverProvider(languageId, new HoverAdapter(worker));
+  languages.registerDocumentHighlightProvider(
+    languageId,
+    new DocumentHighlightAdapter(worker)
+  );
+  languages.registerLinkProvider(languageId, new DocumentLinkAdapter(worker));
+  languages.registerFoldingRangeProvider(
+    languageId,
+    new FoldingRangeAdapter(worker)
+  );
+  languages.registerDocumentSymbolProvider(
+    languageId,
+    new DocumentSymbolAdapter(worker)
+  );
+  languages.registerSelectionRangeProvider(
+    languageId,
+    new SelectionRangeAdapter(worker)
+  );
+  languages.registerRenameProvider(languageId, new RenameAdapter(worker));
+  if (languageId === "html") {
+    languages.registerDocumentFormattingEditProvider(
+      languageId,
+      new DocumentFormattingEditProvider(worker)
+    );
+    languages.registerDocumentRangeFormattingEditProvider(
+      languageId,
+      new DocumentRangeFormattingEditProvider(worker)
+    );
+  }
+}
+function setupMode(defaults) {
+  const disposables = [];
+  const providers = [];
+  const client = new WorkerManager(defaults);
+  disposables.push(client);
+  const worker = (...uris) => {
+    return client.getLanguageServiceWorker(...uris);
+  };
+  function registerProviders() {
+    const { languageId, modeConfiguration } = defaults;
+    disposeAll(providers);
+    if (modeConfiguration.completionItems) {
+      providers.push(
+        languages.registerCompletionItemProvider(languageId, new HTMLCompletionAdapter(worker))
+      );
+    }
+    if (modeConfiguration.hovers) {
+      providers.push(
+        languages.registerHoverProvider(languageId, new HoverAdapter(worker))
+      );
+    }
+    if (modeConfiguration.documentHighlights) {
+      providers.push(
+        languages.registerDocumentHighlightProvider(
+          languageId,
+          new DocumentHighlightAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.links) {
+      providers.push(
+        languages.registerLinkProvider(languageId, new DocumentLinkAdapter(worker))
+      );
+    }
+    if (modeConfiguration.documentSymbols) {
+      providers.push(
+        languages.registerDocumentSymbolProvider(
+          languageId,
+          new DocumentSymbolAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.rename) {
+      providers.push(
+        languages.registerRenameProvider(languageId, new RenameAdapter(worker))
+      );
+    }
+    if (modeConfiguration.foldingRanges) {
+      providers.push(
+        languages.registerFoldingRangeProvider(
+          languageId,
+          new FoldingRangeAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.selectionRanges) {
+      providers.push(
+        languages.registerSelectionRangeProvider(
+          languageId,
+          new SelectionRangeAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentFormattingEdits) {
+      providers.push(
+        languages.registerDocumentFormattingEditProvider(
+          languageId,
+          new DocumentFormattingEditProvider(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentRangeFormattingEdits) {
+      providers.push(
+        languages.registerDocumentRangeFormattingEditProvider(
+          languageId,
+          new DocumentRangeFormattingEditProvider(worker)
+        )
+      );
+    }
+  }
+  registerProviders();
+  disposables.push(asDisposable(providers));
+  return asDisposable(disposables);
+}
+function asDisposable(disposables) {
+  return { dispose: () => disposeAll(disposables) };
+}
+function disposeAll(disposables) {
+  while (disposables.length) {
+    disposables.pop().dispose();
+  }
+}
+
+export { CompletionAdapter, DocumentFormattingEditProvider, DocumentHighlightAdapter, DocumentLinkAdapter, DocumentRangeFormattingEditProvider, DocumentSymbolAdapter, FoldingRangeAdapter, HoverAdapter, RenameAdapter, SelectionRangeAdapter, WorkerManager, setupMode, setupMode1 };

package/language/html/htmlWorker.js

@@ -0,0 +1,126 @@
+import { newHTMLDataProvider, getLanguageService } from 'vscode-html-languageservice';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+class HTMLWorker {
+  constructor(ctx, createData) {
+    this._ctx = ctx;
+    this._languageSettings = createData.languageSettings;
+    this._languageId = createData.languageId;
+    const data = this._languageSettings.data;
+    const useDefaultDataProvider = data?.useDefaultDataProvider;
+    const customDataProviders = [];
+    if (data?.dataProviders) {
+      for (const id in data.dataProviders) {
+        customDataProviders.push(newHTMLDataProvider(id, data.dataProviders[id]));
+      }
+    }
+    this._languageService = getLanguageService({
+      useDefaultDataProvider,
+      customDataProviders
+    });
+  }
+  async doComplete(uri, position) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    let htmlDocument = this._languageService.parseHTMLDocument(document);
+    return Promise.resolve(
+      this._languageService.doComplete(
+        document,
+        position,
+        htmlDocument,
+        this._languageSettings && this._languageSettings.suggest
+      )
+    );
+  }
+  async format(uri, range, options) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    let formattingOptions = { ...this._languageSettings.format, ...options };
+    let textEdits = this._languageService.format(document, range, formattingOptions);
+    return Promise.resolve(textEdits);
+  }
+  async doHover(uri, position) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    let htmlDocument = this._languageService.parseHTMLDocument(document);
+    let hover = this._languageService.doHover(document, position, htmlDocument);
+    return Promise.resolve(hover);
+  }
+  async findDocumentHighlights(uri, position) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    let htmlDocument = this._languageService.parseHTMLDocument(document);
+    let highlights = this._languageService.findDocumentHighlights(document, position, htmlDocument);
+    return Promise.resolve(highlights);
+  }
+  async findDocumentLinks(uri) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    let links = this._languageService.findDocumentLinks(
+      document,
+      null
+      /*TODO@aeschli*/
+    );
+    return Promise.resolve(links);
+  }
+  async findDocumentSymbols(uri) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    let htmlDocument = this._languageService.parseHTMLDocument(document);
+    let symbols = this._languageService.findDocumentSymbols(document, htmlDocument);
+    return Promise.resolve(symbols);
+  }
+  async getFoldingRanges(uri, context) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    let ranges = this._languageService.getFoldingRanges(document, context);
+    return Promise.resolve(ranges);
+  }
+  async getSelectionRanges(uri, positions) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    let ranges = this._languageService.getSelectionRanges(document, positions);
+    return Promise.resolve(ranges);
+  }
+  async doRename(uri, position, newName) {
+    let document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    let htmlDocument = this._languageService.parseHTMLDocument(document);
+    let renames = this._languageService.doRename(document, position, newName, htmlDocument);
+    return Promise.resolve(renames);
+  }
+  _getTextDocument(uri) {
+    let models = this._ctx.getMirrorModels();
+    for (let model of models) {
+      if (model.uri.toString() === uri) {
+        return TextDocument.create(
+          uri,
+          this._languageId,
+          model.version,
+          model.getValue()
+        );
+      }
+    }
+    return null;
+  }
+}
+
+export { HTMLWorker };

package/language/html/workerManager.js

@@ -0,0 +1,64 @@
+import { createWebWorker } from '../../common/workers.js';
+
+const STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
+class WorkerManager {
+  constructor(defaults) {
+    this._defaults = defaults;
+    this._worker = null;
+    this._client = null;
+    this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1e3);
+    this._lastUsedTime = 0;
+    this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
+  }
+  _stopWorker() {
+    if (this._worker) {
+      this._worker.dispose();
+      this._worker = null;
+    }
+    this._client = null;
+  }
+  dispose() {
+    clearInterval(this._idleCheckInterval);
+    this._configChangeListener.dispose();
+    this._stopWorker();
+  }
+  _checkIfIdle() {
+    if (!this._worker) {
+      return;
+    }
+    let timePassedSinceLastUsed = Date.now() - this._lastUsedTime;
+    if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {
+      this._stopWorker();
+    }
+  }
+  _getClient() {
+    this._lastUsedTime = Date.now();
+    if (!this._client) {
+      this._worker = createWebWorker({
+        // module that exports the create() method and returns a `HTMLWorker` instance
+        moduleId: "vs/language/html/htmlWorker",
+        createWorker: () => new Worker(new URL(new URL('../../html.worker.js', import.meta.url).href, import.meta.url), { type: "module" }),
+        // passed in to the create() method
+        createData: {
+          languageSettings: this._defaults.options,
+          languageId: this._defaults.languageId
+        },
+        label: this._defaults.languageId
+      });
+      this._client = this._worker.getProxy();
+    }
+    return this._client;
+  }
+  getLanguageServiceWorker(...resources) {
+    let _client;
+    return this._getClient().then((client) => {
+      _client = client;
+    }).then((_) => {
+      if (this._worker) {
+        return this._worker.withSyncedResources(resources);
+      }
+    }).then((_) => _client);
+  }
+}
+
+export { WorkerManager };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-standalone-html-language-features",
-  "version": "23.1.1",
+  "version": "23.2.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -25,6 +25,9 @@
   "main": "index.js",
   "module": "index.js",
   "dependencies": {
-    "monaco-editor": "npm:@codingame/monaco-vscode-editor-api@23.1.1"
+    "monaco-editor": "npm:@codingame/monaco-vscode-editor-api@23.2.0",
+    "vscode-html-languageservice": "5.2.0",
+    "vscode-languageserver-textdocument": "1.0.12",
+    "vscode-languageserver-types": "3.17.5"
   }
 }