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

package/common/workers.d.ts

@@ -0,0 +1,29 @@
+import { editor } from "@codingame/monaco-vscode-api/vscode/vs/editor/editor.api.js";
+declare function createWebWorker<T extends object>(opts: IWebWorkerOptions): editor.MonacoWebWorker<T>;
+interface IWebWorkerOptions {
+    /**
+     * The AMD moduleId to load.
+     * It should export a function `create` that should return the exported proxy.
+     */
+    moduleId: string;
+    createWorker?: () => Worker;
+    /**
+     * The data to send over when calling create on the module.
+     */
+    createData?: any;
+    /**
+     * A label to be used to identify the web worker for debugging purposes.
+     */
+    label?: string;
+    /**
+     * An object that can be used by the web worker to make calls back to the main thread.
+     */
+    host?: any;
+    /**
+     * Keep idle models.
+     * Defaults to false, which means that idle models will stop syncing after a while.
+     */
+    keepIdleModels?: boolean;
+}
+export { createWebWorker };
+export type { IWebWorkerOptions };

package/common/workers.js

@@ -1,3 +1,4 @@
+
 import { editor } from 'monaco-editor';
 
 function createTrustedTypesPolicy(policyName, policyOptions) {

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,3 +1,4 @@
+
 import { languages, Emitter } from 'monaco-editor';
 
 class LanguageServiceDefaultsImpl {
@@ -88,7 +89,7 @@ const razorLanguageService = registerHTMLLanguageService(
 );
 const razorDefaults = razorLanguageService.defaults;
 function getMode() {
-  return import('./language/html/htmlMode.js');
+  return import('./htmlMode.js');
 }
 function registerHTMLLanguageService(languageId, options = optionsDefault, modeConfiguration = getConfigurationDefault(languageId)) {
   const defaults = new LanguageServiceDefaultsImpl(languageId, options, modeConfiguration);

package/language/html/workerManager.js

@@ -37,7 +37,7 @@ class WorkerManager {
       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" }),
+        createWorker: () => new Worker('./html.worker.js', { type: "module" }),
         // passed in to the create() method
         createData: {
           languageSettings: this._defaults.options,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-standalone-html-language-features",
-  "version": "23.2.0",
+  "version": "23.2.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -16,16 +16,16 @@
   "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.2.0",
+    "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"

package/worker.js

@@ -1,8 +0,0 @@
-import { initialize } from './common/initialize.js';
-import { HTMLWorker } from './language/html/htmlWorker.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return new HTMLWorker(ctx, createData);
-  });
-};