codemirror-languageserver 1.13.0 → 1.15.0

package/dist/plugin.d.ts

@@ -0,0 +1,407 @@
+import { EditorView, Tooltip, ViewPlugin } from '@codemirror/view';
+import { CompletionTriggerKind } from 'vscode-languageserver-protocol';
+import type { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+import type { PluginValue, ViewUpdate } from '@codemirror/view';
+import { Transport } from '@open-rpc/client-js/build/transports/Transport';
+import type { PublishDiagnosticsParams } from 'vscode-languageserver-protocol';
+import type * as LSP from 'vscode-languageserver-protocol';
+interface LSPRequestMap {
+    initialize: [LSP.InitializeParams, LSP.InitializeResult];
+    'textDocument/hover': [LSP.HoverParams, LSP.Hover];
+    'textDocument/completion': [
+        LSP.CompletionParams,
+        LSP.CompletionItem[] | LSP.CompletionList | null
+    ];
+    'textDocument/definition': [
+        LSP.DefinitionParams,
+        LSP.Location | LSP.Location[] | LSP.LocationLink[] | null
+    ];
+}
+interface LSPNotifyMap {
+    initialized: LSP.InitializedParams;
+    'textDocument/didChange': LSP.DidChangeTextDocumentParams;
+    'textDocument/didOpen': LSP.DidOpenTextDocumentParams;
+}
+interface LSPEventMap {
+    'textDocument/publishDiagnostics': LSP.PublishDiagnosticsParams;
+}
+type Notification = {
+    [key in keyof LSPEventMap]: {
+        jsonrpc: '2.0';
+        id?: null | undefined;
+        method: key;
+        params: LSPEventMap[key];
+    };
+}[keyof LSPEventMap];
+export declare class LanguageServerClient<InitializationOptions = unknown> {
+    ready: boolean;
+    capabilities: LSP.ServerCapabilities<any>;
+    initializePromise: Promise<void>;
+    private rootUri;
+    private workspaceFolders;
+    private autoClose?;
+    private transport;
+    private requestManager;
+    private client;
+    private plugins;
+    private options;
+    constructor(options: LanguageServerClientOptions<InitializationOptions>);
+    protected getInitializeParams(): LSP.InitializeParams;
+    initialize(): Promise<void>;
+    close(): void;
+    textDocumentDidOpen(params: LSP.DidOpenTextDocumentParams): Promise<LSP.DidOpenTextDocumentParams>;
+    textDocumentDidChange(params: LSP.DidChangeTextDocumentParams): Promise<LSP.DidChangeTextDocumentParams>;
+    textDocumentHover(params: LSP.HoverParams): Promise<LSP.Hover>;
+    textDocumentCompletion(params: LSP.CompletionParams): Promise<LSP.CompletionList | LSP.CompletionItem[]>;
+    textDocumentDefinition(params: LSP.DefinitionParams): Promise<LSP.Location | LSP.Location[] | LSP.LocationLink[]>;
+    attachPlugin(plugin: LanguageServerPlugin): void;
+    detachPlugin(plugin: LanguageServerPlugin): void;
+    protected request<K extends keyof LSPRequestMap>(method: K, params: LSPRequestMap[K][0], timeout: number): Promise<LSPRequestMap[K][1]>;
+    protected notify<K extends keyof LSPNotifyMap>(method: K, params: LSPNotifyMap[K]): Promise<LSPNotifyMap[K]>;
+    protected processNotification(notification: Notification): void;
+}
+declare class LanguageServerPlugin implements PluginValue {
+    private view;
+    private allowHTMLContent;
+    client: LanguageServerClient;
+    private documentUri;
+    private languageId;
+    private documentVersion;
+    private changesTimeout;
+    constructor(view: EditorView, allowHTMLContent: boolean);
+    update({ docChanged }: ViewUpdate): void;
+    destroy(): void;
+    initialize({ documentText }: {
+        documentText: string;
+    }): Promise<void>;
+    sendChange({ documentText }: {
+        documentText: string;
+    }): Promise<void>;
+    requestDiagnostics(view: EditorView): void;
+    requestHoverTooltip(view: EditorView, { line, character }: {
+        line: number;
+        character: number;
+    }): Promise<Tooltip | null>;
+    requestCompletion(context: CompletionContext, { line, character }: {
+        line: number;
+        character: number;
+    }, { triggerKind, triggerCharacter, }: {
+        triggerKind: CompletionTriggerKind;
+        triggerCharacter: string | undefined;
+    }): Promise<CompletionResult | null>;
+    requestDefinition(view: EditorView, { line, character }: {
+        line: number;
+        character: number;
+    }): Promise<{
+        uri: string;
+        range: LSP.Range;
+    }>;
+    processNotification(notification: Notification): void;
+    processDiagnostics(params: PublishDiagnosticsParams): void;
+}
+export declare const languageServerPlugin: ViewPlugin<LanguageServerPlugin, boolean>;
+interface LanguageServerBaseOptions {
+    rootUri: string | null;
+    workspaceFolders: LSP.WorkspaceFolder[] | null;
+    documentUri: string;
+    languageId: string;
+}
+interface LanguageServerClientOptions<InitializationOptions = unknown> extends LanguageServerBaseOptions {
+    transport: Transport;
+    autoClose?: boolean;
+    initializationOptions?: InitializationOptions;
+}
+interface LanguageServerOptions<InitializationOptions = unknown> extends LanguageServerClientOptions<InitializationOptions> {
+    client?: LanguageServerClient<InitializationOptions>;
+    allowHTMLContent?: boolean;
+}
+interface LanguageServerWebsocketOptions<InitializationOptions = unknown> extends LanguageServerBaseOptions {
+    serverUri: `ws://${string}` | `wss://${string}`;
+    initializationOptions?: InitializationOptions;
+}
+export declare function languageServer<InitializationOptions = unknown>(options: LanguageServerWebsocketOptions<InitializationOptions>): ({
+    extension: import("@codemirror/state").Extension;
+} | readonly import("@codemirror/state").Extension[])[];
+export declare function languageServerWithTransport<InitializationOptions = unknown>(options: LanguageServerOptions<InitializationOptions>): ({
+    extension: import("@codemirror/state").Extension;
+} | readonly import("@codemirror/state").Extension[])[];
+/**
+ * Initialization options for Pyright language server
+ * @see https://github.com/microsoft/pyright/blob/main/docs/settings.md
+ */
+export interface PyrightInitializationOptions {
+    python?: {
+        pythonPath?: string;
+        venvPath?: string;
+        analysis?: {
+            autoSearchPaths?: boolean;
+            extraPaths?: string[];
+            diagnosticMode?: 'workspace' | 'openFilesOnly';
+            stubPath?: string;
+            typeshedPaths?: string[];
+            useLibraryCodeForTypes?: boolean;
+            typeCheckingMode?: 'off' | 'basic' | 'strict';
+            autoImportCompletions?: boolean;
+            indexing?: boolean;
+        };
+    };
+    reportMissingImports?: boolean;
+    reportMissingTypeStubs?: boolean;
+    reportMissingModuleSource?: boolean;
+    reportInvalidTypeVarUse?: boolean;
+    reportOptionalSubscript?: boolean;
+    reportOptionalMemberAccess?: boolean;
+    reportOptionalCall?: boolean;
+    reportOptionalIterable?: boolean;
+    reportOptionalContextManager?: boolean;
+    reportOptionalOperand?: boolean;
+    reportTypedDictNotRequiredAccess?: boolean;
+    reportPrivateImportUsage?: boolean;
+    reportConstantRedefinition?: boolean;
+    reportIncompatibleMethodOverride?: boolean;
+    reportIncompatibleVariableOverride?: boolean;
+    reportInconsistentConstructor?: boolean;
+}
+/**
+ * Initialization options for Rust Analyzer language server
+ * @see https://rust-analyzer.github.io/manual.html#configuration
+ */
+export interface RustAnalyzerInitializationOptions {
+    cargo?: {
+        buildScripts?: {
+            enable?: boolean;
+            invocationStrategy?: 'per_workspace' | 'once';
+            invocationLocation?: 'workspace' | 'root';
+        };
+        allTargets?: boolean;
+        noDefaultFeatures?: boolean;
+        allFeatures?: boolean;
+        features?: string[];
+        target?: string;
+        runBuildScripts?: boolean;
+        useRustcWrapperForBuildScripts?: boolean;
+    };
+    procMacro?: {
+        enable?: boolean;
+        ignored?: Record<string, string[]>;
+        server?: string;
+        attributes?: {
+            enable?: boolean;
+        };
+    };
+    diagnostics?: {
+        enable?: boolean;
+        disabled?: string[];
+        warningsAsHint?: string[];
+        warningsAsInfo?: string[];
+        remapPrefix?: Record<string, string>;
+        experimental?: {
+            enable?: boolean;
+        };
+    };
+    completion?: {
+        addCallArgumentSnippets?: boolean;
+        addCallParenthesis?: boolean;
+        postfix?: {
+            enable?: boolean;
+        };
+        autoimport?: {
+            enable?: boolean;
+        };
+        privateEditable?: {
+            enable?: boolean;
+        };
+    };
+    assist?: {
+        importGranularity?: 'preserve' | 'crate' | 'module' | 'item';
+        importEnforceGranularity?: boolean;
+        importPrefix?: 'plain' | 'by_self' | 'by_crate';
+        allowMergingIntoGlobImports?: boolean;
+    };
+    callInfo?: {
+        full?: boolean;
+    };
+    lens?: {
+        enable?: boolean;
+        run?: boolean;
+        debug?: boolean;
+        implementations?: boolean;
+        refs?: boolean;
+        methodReferences?: boolean;
+        references?: boolean;
+        enumVariantReferences?: boolean;
+    };
+    hover?: {
+        documentation?: boolean;
+        keywords?: boolean;
+        linksInHover?: boolean;
+        memoryLayout?: {
+            enable?: boolean;
+        };
+    };
+    workspace?: {
+        symbol?: {
+            search?: {
+                scope?: 'workspace' | 'workspace_and_dependencies';
+                kind?: 'only_types' | 'all_symbols';
+            };
+        };
+    };
+}
+/**
+ * Initialization options for TypeScript/JavaScript language server
+ * @see https://github.com/typescript-language-server/typescript-language-server
+ */
+export interface TypeScriptInitializationOptions {
+    hostInfo?: string;
+    npmLocation?: string;
+    globalPlugins?: string[];
+    pluginProbeLocations?: string[];
+    preferences?: {
+        includePackageJsonAutoImports?: 'auto' | 'on' | 'off';
+        providePrefixAndSuffixTextForRename?: boolean;
+        allowRenameOfImportPath?: boolean;
+        includeAutomaticOptionalChainCompletions?: boolean;
+        includeCompletionsForModuleExports?: boolean;
+        includeCompletionsForImportStatements?: boolean;
+        includeCompletionsWithSnippetText?: boolean;
+        includeCompletionsWithInsertText?: boolean;
+        allowIncompleteCompletions?: boolean;
+        importModuleSpecifier?: 'shortest' | 'relative' | 'absolute' | 'auto';
+        importModuleSpecifierEnding?: 'minimal' | 'index' | 'js';
+        allowTextChangesInNewFiles?: boolean;
+        lazyConfiguredProjectsFromExternalProject?: boolean;
+        providePrefixAndSuffixTextForQuickInfo?: boolean;
+        includeInlayParameterNameHints?: 'none' | 'literals' | 'all';
+        includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean;
+        includeInlayFunctionParameterTypeHints?: boolean;
+        includeInlayVariableTypeHints?: boolean;
+        includeInlayVariableTypeHintsWhenTypeMatchesName?: boolean;
+        includeInlayPropertyDeclarationTypeHints?: boolean;
+        includeInlayFunctionLikeReturnTypeHints?: boolean;
+        includeInlayEnumMemberValueHints?: boolean;
+    };
+    locale?: string;
+    maxTsServerMemory?: number;
+    tsserver?: {
+        logLevel?: 'off' | 'terse' | 'normal' | 'requestTime' | 'verbose';
+        logVerbosity?: 'off' | 'terse' | 'normal' | 'requestTime' | 'verbose';
+        trace?: 'off' | 'messages' | 'verbose';
+        useSeparateSyntaxServer?: boolean;
+        enableTracing?: boolean;
+        path?: string;
+    };
+}
+/**
+ * Initialization options for ESLint language server
+ * @see https://github.com/Microsoft/vscode-eslint
+ */
+export interface ESLintInitializationOptions {
+    packageManager?: 'npm' | 'yarn' | 'pnpm';
+    nodePath?: string;
+    options?: Record<string, any>;
+    rules?: Record<string, any>;
+    rulesCustomizations?: Array<{
+        rule: string;
+        severity: 'downgrade' | 'upgrade' | 'info' | 'warn' | 'error' | 'off';
+    }>;
+    run?: 'onType' | 'onSave';
+    problems?: {
+        shortenToSingleLine?: boolean;
+    };
+    codeAction?: {
+        disableRuleComment?: {
+            enable?: boolean;
+            location?: 'separateLine' | 'sameLine';
+        };
+        showDocumentation?: {
+            enable?: boolean;
+        };
+    };
+    codeActionOnSave?: {
+        enable?: boolean;
+        mode?: 'all' | 'problems';
+    };
+    format?: {
+        enable?: boolean;
+    };
+    quiet?: boolean;
+    onIgnoredFiles?: 'off' | 'warn';
+    useESLintClass?: boolean;
+    experimental?: {
+        useFlatConfig?: boolean;
+    };
+    workingDirectory?: {
+        mode?: 'auto' | 'location';
+    };
+}
+/**
+ * Initialization options for Clangd language server
+ * @see https://clangd.llvm.org/config
+ */
+export interface ClangdInitializationOptions {
+    compilationDatabasePath?: string;
+    compilationDatabaseChanges?: Record<string, any>;
+    fallbackFlags?: string[];
+    clangdFileStatus?: boolean;
+    utf8?: boolean;
+    offsetEncoding?: ('utf-8' | 'utf-16' | 'utf-32')[];
+    index?: {
+        background?: 'Build' | 'Skip';
+        threads?: number;
+    };
+    completion?: {
+        detailedLabel?: boolean;
+        allScopes?: boolean;
+    };
+    hover?: {
+        showAKA?: boolean;
+    };
+    inlayHints?: {
+        enabled?: boolean;
+        parameterNames?: boolean;
+        deducedTypes?: boolean;
+        designators?: boolean;
+    };
+    semanticHighlighting?: boolean;
+    diagnostics?: {
+        unusedIncludes?: 'None' | 'Strict';
+        missingIncludes?: 'None' | 'Strict';
+        clangTidy?: boolean;
+        suppressAll?: boolean;
+    };
+}
+/**
+ * Initialization options for Gopls (Go language server)
+ * @see https://github.com/golang/tools/blob/master/gopls/doc/settings.md
+ */
+export interface GoplsInitializationOptions {
+    buildFlags?: string[];
+    env?: Record<string, string>;
+    directoryFilters?: string[];
+    templateExtensions?: string[];
+    memoryMode?: 'DegradeClosed' | 'Normal';
+    gofumpt?: boolean;
+    staticcheck?: boolean;
+    analyses?: Record<string, boolean>;
+    codelenses?: Record<string, boolean>;
+    usePlaceholders?: boolean;
+    completionBudget?: string;
+    diagnosticsDelay?: string;
+    experimentalPostfixCompletions?: boolean;
+    experimentalWorkspaceModule?: boolean;
+    experimentalTemplateSupport?: boolean;
+    semanticTokens?: boolean;
+    noSemanticString?: boolean;
+    noSemanticNumber?: boolean;
+    expandWorkspaceToModule?: boolean;
+    experimentalUseInvalidMetadata?: boolean;
+    hoverKind?: 'FullDocumentation' | 'NoDocumentation' | 'SingleLine' | 'Structured' | 'SynopsisDocumentation';
+    linkTarget?: string;
+    linksInHover?: boolean;
+    importShortcut?: 'Both' | 'Definition' | 'Link';
+    symbolMatcher?: 'CaseInsensitive' | 'CaseSensitive' | 'FastFuzzy' | 'Fuzzy';
+    symbolStyle?: 'Dynamic' | 'Full' | 'Package';
+    verboseOutput?: boolean;
+}
+export {};

package/dist/pos.d.ts

@@ -0,0 +1,9 @@
+import type { Text } from '@codemirror/state';
+export declare function posToOffset(doc: Text, pos: {
+    line: number;
+    character: number;
+}): number;
+export declare function offsetToPos(doc: Text, offset: number): {
+    character: number;
+    line: number;
+};

package/package.json

@@ -1,48 +1,55 @@
 {
-  "name": "codemirror-languageserver",
-  "version": "1.13.0",
-  "description": "Language Server Plugin for CodeMirror 6",
-  "main": "dist/index.js",
-  "type": "module",
-  "scripts": {
-    "prepare": "rollup -c rollup.config.js"
-  },
-  "author": {
-    "name": "Mahmud Ridwan",
-    "email": "m@hjr265.me",
-    "url": "https://hjr265.me"
-  },
-  "homepage": "https://github.com/FurqanSoftware/codemirror-languageserver",
-  "bugs": {
-    "url": "https://github.com/FurqanSoftware/codemirror-languageserver/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/FurqanSoftware/codemirror-languageserver.git"
-  },
-  "license": "BSD-3-Clause",
-  "devDependencies": {
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
-    "@rollup/plugin-babel": "^6.0.4",
-    "@rollup/plugin-typescript": "^12.1.4",
-    "prettier": "^3.6.2",
-    "rollup": "^4.46.2",
-    "tslib": "^2.8.1",
-    "tslint": "^6.1.3",
-    "typescript": "^5.9.2"
-  },
-  "dependencies": {
-    "@codemirror/autocomplete": "^6.18.6",
-    "@codemirror/lint": "^6.8.5",
-    "@codemirror/state": "^6.5.2",
-    "@codemirror/view": "^6.38.1",
-    "@open-rpc/client-js": "^1.8.1",
-    "marked": "^16.1.2",
-    "vscode-languageserver-protocol": "^3.17.5"
-  },
-  "prettier": {
-    "tabWidth": 4,
-    "singleQuote": true
-  }
+    "name": "codemirror-languageserver",
+    "version": "1.15.0",
+    "description": "Language Server Plugin for CodeMirror 6",
+    "main": "dist/index.js",
+    "type": "module",
+    "scripts": {
+        "prepare": "rollup -c rollup.config.js"
+    },
+    "author": {
+        "name": "Mahmud Ridwan",
+        "email": "m@hjr265.me",
+        "url": "https://hjr265.me"
+    },
+    "homepage": "https://github.com/FurqanSoftware/codemirror-languageserver",
+    "bugs": {
+        "url": "https://github.com/FurqanSoftware/codemirror-languageserver/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/FurqanSoftware/codemirror-languageserver.git"
+    },
+    "license": "BSD-3-Clause",
+    "devDependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/preset-env": "^7.28.0",
+        "@codemirror/commands": "^6.8.1",
+        "@codemirror/lang-cpp": "^6.0.3",
+        "@codemirror/search": "^6.5.11",
+        "@rollup/plugin-babel": "^6.0.4",
+        "@rollup/plugin-commonjs": "^28.0.6",
+        "@rollup/plugin-node-resolve": "^16.0.1",
+        "@rollup/plugin-typescript": "^12.1.4",
+        "prettier": "^3.6.2",
+        "rollup": "^4.46.2",
+        "rollup-plugin-node-polyfills": "^0.2.1",
+        "rollup-plugin-serve": "^3.0.0",
+        "tslib": "^2.8.1",
+        "tslint": "^6.1.3",
+        "typescript": "^5.9.2"
+    },
+    "dependencies": {
+        "@codemirror/autocomplete": "^6.18.6",
+        "@codemirror/lint": "^6.8.5",
+        "@codemirror/state": "^6.5.2",
+        "@codemirror/view": "^6.38.1",
+        "@open-rpc/client-js": "^1.8.1",
+        "marked": "^16.1.2",
+        "vscode-languageserver-protocol": "^3.17.5"
+    },
+    "prettier": {
+        "tabWidth": 4,
+        "singleQuote": true
+    }
 }

package/rollup.config.demo.js

@@ -0,0 +1,30 @@
+import babel from '@rollup/plugin-babel';
+import typescript from '@rollup/plugin-typescript';
+import serve from 'rollup-plugin-serve';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import nodePolyfills from 'rollup-plugin-node-polyfills';
+
+export default {
+    input: 'demo/demo.js',
+    output: {
+        dir: 'demo/dist',
+        format: 'es',
+        intro: 'const global = window;',
+    },
+    plugins: [
+        typescript({
+            declaration: false,
+        }),
+        babel({
+            babelHelpers: 'bundled',
+        }),
+        nodeResolve({
+            browser: true,
+            preferBuiltins: true,
+        }),
+        commonjs(),
+        nodePolyfills(),
+        serve('./demo'),
+    ],
+};