@astrojs/language-server 0.12.1 → 0.13.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @astrojs/language-server
 
+## 0.13.2
+
+### Patch Changes
+
+- aff8b76: Fix error caused by malformed Svelte components
+- Updated dependencies [aff8b76]
+  - @astrojs/svelte-language-integration@0.1.2
+
+## 0.13.1
+
+### Patch Changes
+
+- ea74fdb: Publish failed
+
+## 0.13.0
+
+### Minor Changes
+
+- 82b8891: Add HTML hover info, fix Astro directives producing errors, fix missing children property for JSX based frameworks
+
+### Patch Changes
+
+- 9f4f907: Add CSS hover info
+- c09116f: Add support for Document Symbols (Outline tab, breadcrumb navigation)
+
 ## 0.12.1
 
 ### Patch Changes

package/dist/core/documents/AstroDocument.d.ts

@@ -1,4 +1,4 @@
-import { HTMLDocument } from 'vscode-html-languageservice';
+import { HTMLDocument, Range } from 'vscode-html-languageservice';
 import { WritableDocument } from './DocumentBase';
 import { AstroMetadata } from './parseAstro';
 import { TagInformation } from './utils';
@@ -12,7 +12,7 @@ export declare class AstroDocument extends WritableDocument {
     constructor(url: string, content: string);
     private updateDocInfo;
     setText(text: string): void;
-    getText(): string;
+    getText(range?: Range | undefined): string;
     getURL(): string;
     getFilePath(): string | null;
 }

package/dist/core/documents/AstroDocument.js

@@ -24,7 +24,12 @@ class AstroDocument extends DocumentBase_1.WritableDocument {
         this.version++;
         this.updateDocInfo();
     }
-    getText() {
+    getText(range) {
+        if (range) {
+            const start = this.offsetAt(range.start);
+            const end = this.offsetAt(range.end);
+            return this.content.substring(start, end);
+        }
         return this.content;
     }
     getURL() {

package/dist/plugins/PluginHost.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, Location, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, TextDocumentIdentifier, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, Color, ColorInformation, ColorPresentation, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Range, Location, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, TextDocumentIdentifier, WorkspaceEdit, SymbolInformation } from 'vscode-languageserver';
 import type { AppCompletionItem, Plugin } from './interfaces';
 import { DocumentManager } from '../core/documents/DocumentManager';
 interface PluginHostConfig {
@@ -18,6 +18,7 @@ export declare class PluginHost {
     doHover(textDocument: TextDocumentIdentifier, position: Position): Promise<Hover | null>;
     doTagComplete(textDocument: TextDocumentIdentifier, position: Position): Promise<string | null>;
     getFoldingRanges(textDocument: TextDocumentIdentifier): Promise<FoldingRange[] | null>;
+    getDocumentSymbols(textDocument: TextDocumentIdentifier, cancellationToken: CancellationToken): Promise<SymbolInformation[]>;
     getDefinitions(textDocument: TextDocumentIdentifier, position: Position): Promise<DefinitionLink[] | Location[]>;
     rename(textDocument: TextDocumentIdentifier, position: Position, newName: string): Promise<WorkspaceEdit | null>;
     getDocumentColors(textDocument: TextDocumentIdentifier): Promise<ColorInformation[]>;

package/dist/plugins/PluginHost.js

@@ -53,6 +53,10 @@ class PluginHost {
         const foldingRanges = (0, lodash_1.flatten)(await this.execute('getFoldingRanges', [document], ExecuteMode.Collect)).filter((completion) => completion != null);
         return foldingRanges;
     }
+    async getDocumentSymbols(textDocument, cancellationToken) {
+        const document = this.getDocument(textDocument.uri);
+        return (0, lodash_1.flatten)(await this.execute('getDocumentSymbols', [document, cancellationToken], ExecuteMode.Collect));
+    }
     async getDefinitions(textDocument, position) {
         const document = this.getDocument(textDocument.uri);
         const definitions = (0, lodash_1.flatten)(await this.execute('getDefinitions', [document, position], ExecuteMode.Collect));

package/dist/plugins/css/CSSPlugin.d.ts

@@ -1,4 +1,4 @@
-import { Color, ColorInformation, ColorPresentation, CompletionContext, CompletionList, Position, Range } from 'vscode-languageserver';
+import { Color, ColorInformation, ColorPresentation, CompletionContext, CompletionList, Hover, Position, Range, SymbolInformation } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config/ConfigManager';
 import { AstroDocument } from '../../core/documents';
 import type { Plugin } from '../interfaces';
@@ -8,16 +8,25 @@ export declare class CSSPlugin implements Plugin {
     private cssDocuments;
     private triggerCharacters;
     constructor(configManager: ConfigManager);
+    doHover(document: AstroDocument, position: Position): Hover | null;
+    private doHoverInternal;
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): CompletionList | null;
     private getCompletionsInternal;
     getDocumentColors(document: AstroDocument): ColorInformation[];
     getColorPresentations(document: AstroDocument, range: Range, color: Color): ColorPresentation[];
+    getDocumentSymbols(document: AstroDocument): SymbolInformation[];
     private inStyleAttributeWithoutInterpolation;
     /**
      * Get the associated CSS Document for a style tag
      */
     private getCSSDocumentForStyleTag;
+    /**
+     * Get all the CSSDocuments in a document
+     */
     private getCSSDocumentsForDocument;
+    /**
+     * Get all the stylesheets (Stylesheet type) in a document
+     */
     private getStylesheetsForDocument;
     /**
      * Get style tag at position for a document

package/dist/plugins/css/CSSPlugin.js

@@ -17,6 +17,35 @@ class CSSPlugin {
         this.triggerCharacters = new Set(['.', ':', '-', '/']);
         this.configManager = configManager;
     }
+    doHover(document, position) {
+        if (!this.featureEnabled('hover')) {
+            return null;
+        }
+        if ((0, documents_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position))) {
+            return null;
+        }
+        const styleTag = this.getStyleTagForPosition(document, position);
+        if (!styleTag) {
+            const attributeContext = (0, parseHtml_1.getAttributeContextAtPosition)(document, position);
+            if (!attributeContext) {
+                return null;
+            }
+            if (this.inStyleAttributeWithoutInterpolation(attributeContext, document.getText())) {
+                const [start, end] = attributeContext.valueRange;
+                return this.doHoverInternal(new StyleAttributeDocument_1.StyleAttributeDocument(document, start, end), position);
+            }
+            return null;
+        }
+        const cssDocument = this.getCSSDocumentForStyleTag(styleTag, document);
+        if (shouldExcludeHover(cssDocument)) {
+            return null;
+        }
+        return this.doHoverInternal(cssDocument, position);
+    }
+    doHoverInternal(cssDocument, position) {
+        const hoverInfo = (0, language_service_1.getLanguageService)(extractLanguage(cssDocument)).doHover(cssDocument, cssDocument.getGeneratedPosition(position), cssDocument.stylesheet);
+        return hoverInfo ? (0, documents_1.mapHoverToParent)(cssDocument, hoverInfo) : hoverInfo;
+    }
     getCompletions(document, position, completionContext) {
         if (!this.featureEnabled('completions')) {
             return null;
@@ -100,6 +129,17 @@ class CSSPlugin {
         });
         return (0, lodash_1.flatten)(allColorPres);
     }
+    getDocumentSymbols(document) {
+        if (!this.featureEnabled('documentSymbols')) {
+            return [];
+        }
+        const allDocumentSymbols = this.getCSSDocumentsForDocument(document).map((cssDoc) => {
+            return (0, language_service_1.getLanguageService)(extractLanguage(cssDoc))
+                .findDocumentSymbols(cssDoc, cssDoc.stylesheet)
+                .map((symbol) => (0, documents_1.mapSymbolInformationToOriginal)(cssDoc, symbol));
+        });
+        return (0, lodash_1.flatten)(allDocumentSymbols);
+    }
     inStyleAttributeWithoutInterpolation(attrContext, text) {
         return (attrContext.name === 'style' &&
             !!attrContext.valueRange &&
@@ -116,9 +156,15 @@ class CSSPlugin {
         }
         return cssDoc;
     }
+    /**
+     * Get all the CSSDocuments in a document
+     */
     getCSSDocumentsForDocument(document) {
         return document.styleTags.map((tag) => this.getCSSDocumentForStyleTag(tag, document));
     }
+    /**
+     * Get all the stylesheets (Stylesheet type) in a document
+     */
     getStylesheetsForDocument(document) {
         return this.getCSSDocumentsForDocument(document).map((cssDoc) => cssDoc.stylesheet);
     }
@@ -135,6 +181,22 @@ class CSSPlugin {
     }
 }
 exports.CSSPlugin = CSSPlugin;
+/**
+ * Exclude certain language when getting hover info
+ * The CSS language service only supports CSS, LESS and SCSS,
+ * which mean that we cannot support hover info in other languages
+ */
+function shouldExcludeHover(document) {
+    const language = typeof document === 'string' ? document : extractLanguage(document);
+    switch (language) {
+        case 'sass':
+        case 'stylus':
+        case 'styl':
+            return true;
+        default:
+            return false;
+    }
+}
 /**
  * Exclude certain language when getting colors
  * The CSS language service only supports CSS, LESS and SCSS,

package/dist/plugins/css/features/astro-selectors.js

@@ -5,10 +5,10 @@ exports.pseudoClass = [
     {
         name: ':global()',
         description: `[astro] :global modifier
-Applying styles to a selector globally`,
+Apply styles to a selector globally`,
         references: [
             {
-                name: 'Astro Docs',
+                name: 'Astro documentation',
                 url: 'https://docs.astro.build/en/guides/styling/#global-styles-within-style-tag',
             },
         ],

package/dist/plugins/html/HTMLPlugin.d.ts

@@ -1,19 +1,22 @@
-import { CompletionList, Position, FoldingRange } from 'vscode-languageserver';
+import { CompletionList, Position, FoldingRange, Hover, SymbolInformation } from 'vscode-languageserver';
 import type { Plugin } from '../interfaces';
 import { ConfigManager } from '../../core/config/ConfigManager';
 import { AstroDocument } from '../../core/documents/AstroDocument';
 export declare class HTMLPlugin implements Plugin {
     __name: string;
     private lang;
+    private componentLang;
     private styleScriptTemplate;
     private configManager;
     constructor(configManager: ConfigManager);
+    doHover(document: AstroDocument, position: Position): Hover | null;
     /**
      * Get HTML completions
      */
     getCompletions(document: AstroDocument, position: Position): CompletionList | null;
     getFoldingRanges(document: AstroDocument): FoldingRange[] | null;
     doTagComplete(document: AstroDocument, position: Position): string | null;
+    getDocumentSymbols(document: AstroDocument): SymbolInformation[];
     /**
      * Get lang completions for style tags (ex: `<style lang="scss">`)
      */

package/dist/plugins/html/HTMLPlugin.js

@@ -5,13 +5,39 @@ const vscode_languageserver_1 = require("vscode-languageserver");
 const emmet_helper_1 = require("@vscode/emmet-helper");
 const vscode_html_languageservice_1 = require("vscode-html-languageservice");
 const utils_1 = require("../../core/documents/utils");
+const utils_2 = require("../../utils");
+const astro_attributes_1 = require("./features/astro-attributes");
 class HTMLPlugin {
     constructor(configManager) {
         this.__name = 'html';
-        this.lang = (0, vscode_html_languageservice_1.getLanguageService)();
+        this.lang = (0, vscode_html_languageservice_1.getLanguageService)({
+            customDataProviders: [astro_attributes_1.astroAttributes],
+        });
+        this.componentLang = (0, vscode_html_languageservice_1.getLanguageService)({
+            customDataProviders: [astro_attributes_1.astroAttributes, astro_attributes_1.astroDirectives],
+            useDefaultDataProvider: false,
+        });
         this.styleScriptTemplate = new Set(['style']);
         this.configManager = configManager;
     }
+    doHover(document, position) {
+        if (!this.featureEnabled('hover')) {
+            return null;
+        }
+        const html = document.html;
+        if (!html) {
+            return null;
+        }
+        const node = html.findNodeAt(document.offsetAt(position));
+        if (!node) {
+            return null;
+        }
+        // If the node we're hovering on is a component, instead only provide astro-specific hover info
+        if ((0, utils_2.isPossibleComponent)(node)) {
+            return this.componentLang.doHover(document, position, html);
+        }
+        return this.lang.doHover(document, position, html);
+    }
     /**
      * Get HTML completions
      */
@@ -66,6 +92,16 @@ class HTMLPlugin {
         }
         return this.lang.doTagComplete(document, position, html);
     }
+    getDocumentSymbols(document) {
+        if (!this.featureEnabled('documentSymbols')) {
+            return [];
+        }
+        const html = document.html;
+        if (!html) {
+            return [];
+        }
+        return this.lang.findDocumentSymbols(document, html);
+    }
     /**
      * Get lang completions for style tags (ex: `<style lang="scss">`)
      */

package/dist/plugins/html/features/astro-attributes.d.ts

@@ -0,0 +1,2 @@
+export declare const astroAttributes: import("vscode-html-languageservice").IHTMLDataProvider;
+export declare const astroDirectives: import("vscode-html-languageservice").IHTMLDataProvider;

package/dist/plugins/html/features/astro-attributes.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astroDirectives = exports.astroAttributes = void 0;
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+exports.astroAttributes = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-attributes', {
+    version: 1,
+    globalAttributes: [
+        {
+            name: 'class:list',
+            description: 'Utility to provide a list of class',
+        },
+        {
+            name: 'set:html',
+            description: 'Inject unescaped HTML into this tag',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/migrate/#deprecated-unescaped-html',
+                },
+            ],
+        },
+        {
+            name: 'set:text',
+            description: 'Inject escaped text into this tag',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/migrate/#deprecated-unescaped-html',
+                },
+            ],
+        },
+    ],
+    tags: [
+        {
+            name: 'script',
+            attributes: [
+                {
+                    // The VS Code tag definitions does not provide a description for the deprecated `charset` attribute on script tags
+                    // Which mean that since we get no hover info for this, we instead get JSX hover info. So we'll just specify a description ourselves for this specific case
+                    name: 'charset',
+                    description: "(Deprecated) It's unnecessary to specify the charset attribute, because documents must use UTF-8, and the script element inherits its character encoding from the document.",
+                },
+                {
+                    name: 'define:vars',
+                    description: 'Passes serializable server-side variables into a client-side script element',
+                    references: [
+                        {
+                            name: 'Astro documentation',
+                            url: 'https://docs.astro.build/en/guides/styling/#variables-in-scripts--styles',
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'style',
+            attributes: [
+                {
+                    name: 'define:vars',
+                    description: 'Passes serializable server-side variables into a client-side style element',
+                    references: [
+                        {
+                            name: 'Astro documentation',
+                            url: 'https://docs.astro.build/en/guides/styling/#variables-in-scripts--styles',
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+});
+exports.astroDirectives = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-directives', {
+    version: 1,
+    globalAttributes: [
+        {
+            name: 'client:load',
+            description: 'Start importing the component JS at page load. Hydrate the component when import completes.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:idle',
+            description: 'Start importing the component JS as soon as main thread is free (uses requestIdleCallback()). Hydrate the component when import completes.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:visible',
+            description: 'Start importing the component JS as soon as the element enters the viewport (uses IntersectionObserver). Hydrate the component when import completes. Useful for content lower down on the page.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:media',
+            description: 'Start importing the component JS as soon as the browser matches the given media query (uses matchMedia). Hydrate the component when import completes. Useful for sidebar toggles, or other elements that should only display on mobile or desktop devices.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+        {
+            name: 'client:only',
+            description: 'Start importing the component JS at page load and hydrate when the import completes, similar to client:load. The component will be skipped at build time, useful for components that are entirely dependent on client-side APIs. This is best avoided unless absolutely needed, in most cases it is best to render placeholder content on the server and delay any browser API calls until the component hydrates in the browser.',
+            references: [
+                {
+                    name: 'Astro documentation',
+                    url: 'https://docs.astro.build/en/core-concepts/component-hydration/#hydrate-interactive-components',
+                },
+            ],
+        },
+    ],
+});

package/dist/plugins/typescript/TypeScriptPlugin.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
 import { AstroDocument, DocumentManager } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
@@ -11,9 +11,11 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly hoverProvider;
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
+    private readonly documentSymbolsProvider;
     constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
+    getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList<CompletionEntryWithIdentifer> | null>;
     resolveCompletion(document: AstroDocument, completionItem: AppCompletionItem<CompletionEntryWithIdentifer>): Promise<AppCompletionItem<CompletionEntryWithIdentifer>>;
     getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -35,6 +35,7 @@ const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
 const utils_2 = require("./features/utils");
 const LanguageServiceManager_1 = require("./LanguageServiceManager");
 const utils_3 = require("./utils");
+const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
@@ -44,8 +45,12 @@ class TypeScriptPlugin {
         this.hoverProvider = new HoverProvider_1.HoverProviderImpl(this.languageServiceManager);
         this.signatureHelpProvider = new SignatureHelpProvider_1.SignatureHelpProviderImpl(this.languageServiceManager);
         this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
+        this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
     }
     async doHover(document, position) {
+        if (!this.featureEnabled('hover')) {
+            return null;
+        }
         return this.hoverProvider.doHover(document, position);
     }
     async rename(document, position, newName) {
@@ -71,7 +76,17 @@ class TypeScriptPlugin {
         });
         return edit;
     }
+    async getDocumentSymbols(document) {
+        if (!this.featureEnabled('documentSymbols')) {
+            return [];
+        }
+        const symbols = await this.documentSymbolsProvider.getDocumentSymbols(document);
+        return symbols;
+    }
     async getCompletions(document, position, completionContext) {
+        if (!this.featureEnabled('completions')) {
+            return null;
+        }
         const completions = await this.completionProvider.getCompletions(document, position, completionContext);
         return completions;
     }

package/dist/plugins/typescript/features/CompletionsProvider.js

@@ -19,7 +19,7 @@ class CompletionsProviderImpl {
     }
     async getCompletions(document, position, _completionContext) {
         var _a;
-        // TODO: handle inside expression
+        // TODO: handle inside expression and script tags
         if (!(0, utils_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position))) {
             return null;
         }

package/dist/plugins/typescript/features/DiagnosticsProvider.js

@@ -188,35 +188,14 @@ function isNoMarkdownBlockQuoteWithinMarkdown(sourceFile, boundaries, diagnostic
  * Some diagnostics have JSX-specific nomenclature. Enhance them for more clarity.
  */
 function enhanceIfNecessary(diagnostic) {
-    if (diagnostic.code === 2786) {
-        return {
-            ...diagnostic,
-            message: 'Type definitions are missing for this Svelte Component. ' +
-                // eslint-disable-next-line max-len
-                "It needs a class definition with at least the property '$$prop_def' which should contain a map of input property definitions.\n" +
-                'Example:\n' +
-                '  class ComponentName { $$prop_def: { propertyName: string; } }\n' +
-                'If you are using Svelte 3.31+, use SvelteComponentTyped:\n' +
-                '  import type { SvelteComponentTyped } from "svelte";\n' +
-                '  class ComponentName extends SvelteComponentTyped<{propertyName: string;}> {}\n\n' +
-                'Underlying error:\n' +
-                diagnostic.message,
-        };
-    }
-    if (diagnostic.code === 2607) {
-        return {
-            ...diagnostic,
-            message: 'Element does not support attributes because ' +
-                'type definitions are missing for this Svelte Component or element cannot be used as such.\n\n' +
-                'Underlying error:\n' +
-                diagnostic.message,
-        };
-    }
-    if (diagnostic.code === 1184) {
-        return {
-            ...diagnostic,
-            message: diagnostic.message + '\nIf this is a declare statement, move it into <script context="module">..</script>',
-        };
+    if (diagnostic.code === 2322) {
+        // For the rare case where an user might try to put a client directive on something that is not a component
+        if (diagnostic.message.includes("Property 'client:") && diagnostic.message.includes("to type 'HTMLProps")) {
+            return {
+                ...diagnostic,
+                message: 'Client directives are only available on framework components',
+            };
+        }
     }
     return diagnostic;
 }

package/dist/plugins/typescript/features/DocumentSymbolsProvider.d.ts

@@ -0,0 +1,10 @@
+import { SymbolInformation } from 'vscode-languageserver-types';
+import { AstroDocument } from '../../../core/documents';
+import { DocumentSymbolsProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class DocumentSymbolsProviderImpl implements DocumentSymbolsProvider {
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getDocumentSymbols(document: AstroDocument): Promise<SymbolInformation[]>;
+    private collectSymbols;
+}

package/dist/plugins/typescript/features/DocumentSymbolsProvider.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentSymbolsProviderImpl = void 0;
+const typescript_1 = require("typescript");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const documents_1 = require("../../../core/documents");
+const utils_1 = require("../utils");
+const vscode_languageserver_types_2 = require("vscode-languageserver-types");
+class DocumentSymbolsProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getDocumentSymbols(document) {
+        var _a, _b, _c;
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const fragment = await tsDoc.createFragment();
+        const navTree = lang.getNavigationTree(tsDoc.filePath);
+        if (!navTree) {
+            return [];
+        }
+        const symbols = [];
+        this.collectSymbols(navTree, fragment, undefined, (symbol) => symbols.push(symbol));
+        const result = [];
+        // Add a "Frontmatter" namespace for the frontmatter if we have a closed one
+        if (document.astroMeta.frontmatter.state === 'closed') {
+            result.push(vscode_languageserver_types_1.SymbolInformation.create('Frontmatter', vscode_languageserver_types_1.SymbolKind.Namespace, vscode_languageserver_types_1.Range.create(document.positionAt(document.astroMeta.frontmatter.startOffset), document.positionAt(document.astroMeta.frontmatter.endOffset))));
+        }
+        // Add a "Template" namespace for everything under the frontmatter
+        result.push(vscode_languageserver_types_1.SymbolInformation.create('Template', vscode_languageserver_types_1.SymbolKind.Namespace, vscode_languageserver_types_1.Range.create(document.positionAt((_a = document.astroMeta.frontmatter.endOffset) !== null && _a !== void 0 ? _a : 0), document.positionAt(document.getTextLength()))));
+        for (let symbol of symbols.splice(1)) {
+            symbol = (0, documents_1.mapSymbolInformationToOriginal)(fragment, symbol);
+            if (document.offsetAt(symbol.location.range.end) >= ((_b = document.astroMeta.content.firstNonWhitespaceOffset) !== null && _b !== void 0 ? _b : 0)) {
+                symbol.containerName = 'Template';
+                // For some reason, it seems like TypeScript thinks that the "class" attribute is a real class, weird
+                if (symbol.kind === vscode_languageserver_types_1.SymbolKind.Class && symbol.name === '<class>') {
+                    const node = document.html.findNodeAt(document.offsetAt(symbol.location.range.start));
+                    if ((_c = node.attributes) === null || _c === void 0 ? void 0 : _c.class) {
+                        continue;
+                    }
+                }
+            }
+            // Remove the default function detected in our TSX output
+            if (symbol.kind === vscode_languageserver_types_1.SymbolKind.Function && symbol.name == 'default') {
+                continue;
+            }
+            result.push(symbol);
+        }
+        return result;
+    }
+    collectSymbols(item, fragment, container, cb) {
+        for (const span of item.spans) {
+            const symbol = vscode_languageserver_types_1.SymbolInformation.create(item.text, (0, utils_1.symbolKindFromString)(item.kind), vscode_languageserver_types_1.Range.create(fragment.positionAt(span.start), fragment.positionAt(span.start + span.length)), fragment.getURL(), container);
+            // TypeScript gives us kind modifiers as a string instead of an array
+            const kindModifiers = new Set(item.kindModifiers.split(/,|\s+/g));
+            if (kindModifiers.has(typescript_1.ScriptElementKindModifier.deprecatedModifier)) {
+                if (!symbol.tags)
+                    symbol.tags = [];
+                symbol.tags.push(vscode_languageserver_types_2.SymbolTag.Deprecated);
+            }
+            cb(symbol);
+        }
+        if (item.childItems) {
+            for (const child of item.childItems) {
+                this.collectSymbols(child, fragment, item.text, cb);
+            }
+        }
+    }
+}
+exports.DocumentSymbolsProviderImpl = DocumentSymbolsProviderImpl;