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

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/monaco.contribution.d.ts

@@ -0,0 +1,162 @@
+import { IEvent, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/editor/editor.api.js";
+interface HTMLFormatConfiguration {
+    readonly tabSize: number;
+    readonly insertSpaces: boolean;
+    readonly wrapLineLength: number;
+    readonly unformatted: string;
+    readonly contentUnformatted: string;
+    readonly indentInnerHtml: boolean;
+    readonly preserveNewLines: boolean;
+    readonly maxPreserveNewLines: number | undefined;
+    readonly indentHandlebars: boolean;
+    readonly endWithNewline: boolean;
+    readonly extraLiners: string;
+    readonly wrapAttributes: "auto" | "force" | "force-aligned" | "force-expand-multiline";
+}
+interface CompletionConfiguration {
+    readonly [providerId: string]: boolean;
+}
+interface Options {
+    /**
+     * Settings for the HTML formatter.
+     */
+    readonly format?: HTMLFormatConfiguration;
+    /**
+     * Code completion settings.
+     */
+    readonly suggest?: CompletionConfiguration;
+    /**
+     * Configures the HTML data types known by the HTML langauge service.
+     */
+    readonly data?: HTMLDataConfiguration;
+}
+interface ModeConfiguration {
+    /**
+     * Defines whether the built-in completionItemProvider is enabled.
+     */
+    readonly completionItems?: boolean;
+    /**
+     * Defines whether the built-in hoverProvider is enabled.
+     */
+    readonly hovers?: boolean;
+    /**
+     * Defines whether the built-in documentSymbolProvider is enabled.
+     */
+    readonly documentSymbols?: boolean;
+    /**
+     * Defines whether the built-in definitions provider is enabled.
+     */
+    readonly links?: boolean;
+    /**
+     * Defines whether the built-in references provider is enabled.
+     */
+    readonly documentHighlights?: boolean;
+    /**
+     * Defines whether the built-in rename provider is enabled.
+     */
+    readonly rename?: boolean;
+    /**
+     * Defines whether the built-in color provider is enabled.
+     */
+    readonly colors?: boolean;
+    /**
+     * Defines whether the built-in foldingRange provider is enabled.
+     */
+    readonly foldingRanges?: boolean;
+    /**
+     * Defines whether the built-in diagnostic provider is enabled.
+     */
+    readonly diagnostics?: boolean;
+    /**
+     * Defines whether the built-in selection range provider is enabled.
+     */
+    readonly selectionRanges?: boolean;
+    /**
+     * Defines whether the built-in documentFormattingEdit provider is enabled.
+     */
+    readonly documentFormattingEdits?: boolean;
+    /**
+     * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
+     */
+    readonly documentRangeFormattingEdits?: boolean;
+}
+interface LanguageServiceDefaults {
+    readonly languageId: string;
+    readonly modeConfiguration: ModeConfiguration;
+    readonly onDidChange: IEvent<LanguageServiceDefaults>;
+    readonly options: Options;
+    setOptions(options: Options): void;
+    setModeConfiguration(modeConfiguration: ModeConfiguration): void;
+}
+declare const htmlLanguageService: LanguageServiceRegistration;
+declare const htmlDefaults: LanguageServiceDefaults;
+declare const handlebarLanguageService: LanguageServiceRegistration;
+declare const handlebarDefaults: LanguageServiceDefaults;
+declare const razorLanguageService: LanguageServiceRegistration;
+declare const razorDefaults: LanguageServiceDefaults;
+interface LanguageServiceRegistration extends IDisposable {
+    readonly defaults: LanguageServiceDefaults;
+}
+/**
+ * Registers a new HTML language service for the languageId.
+ * Note: 'html', 'handlebar' and 'razor' are registered by default.
+ *
+ * Use this method to register additional language ids with a HTML service.
+ * The language server has to be registered before an editor model is opened.
+ */
+declare function registerHTMLLanguageService(languageId: string, options?: Options, modeConfiguration?: ModeConfiguration): LanguageServiceRegistration;
+interface HTMLDataConfiguration {
+    /**
+     * Defines whether the standard HTML tags and attributes are shown
+     */
+    readonly useDefaultDataProvider?: boolean;
+    /**
+     * Provides a set of custom data providers.
+     */
+    readonly dataProviders?: {
+        [providerId: string]: HTMLDataV1;
+    };
+}
+/**
+ * Custom HTML tags attributes and attribute values
+ * https://github.com/microsoft/vscode-html-languageservice/blob/main/docs/customData.md
+ */
+interface HTMLDataV1 {
+    readonly version: 1 | 1.1;
+    readonly tags?: ITagData[];
+    readonly globalAttributes?: IAttributeData[];
+    readonly valueSets?: IValueSet[];
+}
+interface IReference {
+    readonly name: string;
+    readonly url: string;
+}
+interface ITagData {
+    readonly name: string;
+    readonly description?: string | MarkupContent;
+    readonly attributes: IAttributeData[];
+    readonly references?: IReference[];
+}
+interface IAttributeData {
+    readonly name: string;
+    readonly description?: string | MarkupContent;
+    readonly valueSet?: string;
+    readonly values?: IValueData[];
+    readonly references?: IReference[];
+}
+interface IValueData {
+    readonly name: string;
+    readonly description?: string | MarkupContent;
+    readonly references?: IReference[];
+}
+interface IValueSet {
+    readonly name: string;
+    readonly values: IValueData[];
+}
+interface MarkupContent {
+    readonly kind: MarkupKind;
+    readonly value: string;
+}
+declare type MarkupKind = "plaintext" | "markdown";
+export { handlebarDefaults, handlebarLanguageService, htmlDefaults, htmlLanguageService, razorDefaults, razorLanguageService, registerHTMLLanguageService };
+export type { CompletionConfiguration, HTMLDataConfiguration, HTMLDataV1, HTMLFormatConfiguration, IAttributeData, IReference, ITagData, IValueData, IValueSet, LanguageServiceDefaults, LanguageServiceRegistration, MarkupContent, MarkupKind, ModeConfiguration, Options };

package/{index.js → language/html/monaco.contribution.js}

@@ -1,34 +1,9 @@
-import * as monaco_editor_core_star from 'monaco-editor';
 
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.54.0(undefined)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
+import { languages, Emitter } from 'monaco-editor';
 
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
-
-// src/fillers/monaco-editor-core.ts
-var monaco_editor_core_exports = {};
-__reExport(monaco_editor_core_exports, monaco_editor_core_star);
-
-// src/language/html/monaco.contribution.ts
-var LanguageServiceDefaultsImpl = class {
+class LanguageServiceDefaultsImpl {
   constructor(languageId, options, modeConfiguration) {
-    this._onDidChange = new monaco_editor_core_exports.Emitter();
+    this._onDidChange = new Emitter();
     this._languageId = languageId;
     this.setOptions(options);
     this.setModeConfiguration(modeConfiguration);
@@ -53,8 +28,8 @@ var LanguageServiceDefaultsImpl = class {
     this._modeConfiguration = modeConfiguration || /* @__PURE__ */ Object.create(null);
     this._onDidChange.fire(this);
   }
-};
-var formatDefaults = {
+}
+const formatDefaults = {
   tabSize: 4,
   insertSpaces: false,
   wrapLineLength: 120,
@@ -68,7 +43,7 @@ var formatDefaults = {
   extraLiners: "head, body, /html",
   wrapAttributes: "auto"
 };
-var optionsDefault = {
+const optionsDefault = {
   format: formatDefaults,
   suggest: {},
   data: { useDefaultDataProvider: true }
@@ -92,53 +67,42 @@ function getConfigurationDefault(languageId) {
     // turned off for Razor and Handlebar
   };
 }
-var htmlLanguageId = "html";
-var handlebarsLanguageId = "handlebars";
-var razorLanguageId = "razor";
-var htmlLanguageService = registerHTMLLanguageService(
+const htmlLanguageId = "html";
+const handlebarsLanguageId = "handlebars";
+const razorLanguageId = "razor";
+const htmlLanguageService = registerHTMLLanguageService(
   htmlLanguageId,
   optionsDefault,
   getConfigurationDefault(htmlLanguageId)
 );
-var htmlDefaults = htmlLanguageService.defaults;
-var handlebarLanguageService = registerHTMLLanguageService(
+const htmlDefaults = htmlLanguageService.defaults;
+const handlebarLanguageService = registerHTMLLanguageService(
   handlebarsLanguageId,
   optionsDefault,
   getConfigurationDefault(handlebarsLanguageId)
 );
-var handlebarDefaults = handlebarLanguageService.defaults;
-var razorLanguageService = registerHTMLLanguageService(
+const handlebarDefaults = handlebarLanguageService.defaults;
+const razorLanguageService = registerHTMLLanguageService(
   razorLanguageId,
   optionsDefault,
   getConfigurationDefault(razorLanguageId)
 );
-var razorDefaults = razorLanguageService.defaults;
-monaco_editor_core_exports.languages.html = {
-  htmlDefaults,
-  razorDefaults,
-  handlebarDefaults,
-  htmlLanguageService,
-  handlebarLanguageService,
-  razorLanguageService,
-  registerHTMLLanguageService
-};
+const razorDefaults = razorLanguageService.defaults;
 function getMode() {
-  {
-    return import('./htmlMode.js');
-  }
+  return import('./htmlMode.js');
 }
 function registerHTMLLanguageService(languageId, options = optionsDefault, modeConfiguration = getConfigurationDefault(languageId)) {
   const defaults = new LanguageServiceDefaultsImpl(languageId, options, modeConfiguration);
-  let mode;
-  const onLanguageListener = monaco_editor_core_exports.languages.onLanguage(languageId, async () => {
-    mode = (await getMode()).setupMode(defaults);
+  let mode2;
+  const onLanguageListener = languages.onLanguage(languageId, async () => {
+    mode2 = (await getMode()).setupMode(defaults);
   });
   return {
     defaults,
     dispose() {
       onLanguageListener.dispose();
-      mode?.dispose();
-      mode = void 0;
+      mode2?.dispose();
+      mode2 = void 0;
     }
   };
 }

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('./html.worker.js', { 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.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -16,15 +16,18 @@
   "description": "monaco-editor html language features bundled to work with @codingame/monaco-vscode-api",
   "exports": {
     ".": {
-      "default": "./index.js"
+      "default": "./language/html/monaco.contribution.js"
     },
     "./worker": {
-      "default": "./worker.js"
+      "default": "./language/html/html.worker.js"
     }
   },
   "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.1",
+    "vscode-html-languageservice": "5.2.0",
+    "vscode-languageserver-textdocument": "1.0.12",
+    "vscode-languageserver-types": "3.17.5"
   }
 }