@astrojs/language-server 0.13.2 → 0.14.0

package/dist/plugins/html/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDataAttrCompletion = void 0;
+/**
+ * The VS Code HTML language service provides a completion for data attributes that is independent from
+ * data providers, which mean that you can't disable it, so this function removes them from completions
+ */
+function removeDataAttrCompletion(items) {
+    return items.filter((item) => !item.label.startsWith('data-'));
+}
+exports.removeDataAttrCompletion = removeDataAttrCompletion;

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

@@ -1,4 +1,4 @@
-import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, WorkspaceEdit } from 'vscode-languageserver';
+import { CancellationToken, CompletionContext, DefinitionLink, Diagnostic, Hover, Position, Range, SemanticTokens, 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';
@@ -12,9 +12,11 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly signatureHelpProvider;
     private readonly diagnosticsProvider;
     private readonly documentSymbolsProvider;
+    private readonly semanticTokensProvider;
     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>;
+    getSemanticTokens(textDocument: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | 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>>;

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -36,6 +36,7 @@ const utils_2 = require("./features/utils");
 const LanguageServiceManager_1 = require("./LanguageServiceManager");
 const utils_3 = require("./utils");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
+const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
 class TypeScriptPlugin {
     constructor(docManager, configManager, workspaceUris) {
         this.__name = 'typescript';
@@ -46,6 +47,7 @@ class TypeScriptPlugin {
         this.signatureHelpProvider = new SignatureHelpProvider_1.SignatureHelpProviderImpl(this.languageServiceManager);
         this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
         this.documentSymbolsProvider = new DocumentSymbolsProvider_1.DocumentSymbolsProviderImpl(this.languageServiceManager);
+        this.semanticTokensProvider = new SemanticTokenProvider_1.SemanticTokensProviderImpl(this.languageServiceManager);
     }
     async doHover(document, position) {
         if (!this.featureEnabled('hover')) {
@@ -76,6 +78,12 @@ class TypeScriptPlugin {
         });
         return edit;
     }
+    async getSemanticTokens(textDocument, range, cancellationToken) {
+        if (!this.featureEnabled('semanticTokens')) {
+            return null;
+        }
+        return this.semanticTokensProvider.getSemanticTokens(textDocument, range, cancellationToken);
+    }
     async getDocumentSymbols(document) {
         if (!this.featureEnabled('documentSymbols')) {
             return [];

package/dist/plugins/typescript/astro2tsx.js

@@ -38,9 +38,13 @@ function default_1(content) {
         .replace(/<\s*!--([^-->]*)(.*?)-->/gs, (whole) => {
         return `{/*${whole}*/}`;
     })
-        // Turn styles into internal strings
+        // Turn styles tags into internal strings
         .replace(/<\s*style([^>]*)>(.*?)<\s*\/\s*style>/gs, (_whole, attrs, children) => {
         return `<style${attrs}>{\`${escapeTemplateLiteralContent(children)}\`}</style>`;
+    })
+        // Turn Markdown tags into internal strings
+        .replace(/<\s*Markdown([^>]*)>(.*?)<\s*\/\s*Markdown>/gs, (_whole, attrs, children) => {
+        return `<Markdown${attrs}>{\`${escapeTemplateLiteralContent(children)}\`}</Markdown>`;
     })
         // Turn scripts into function calls
         .replace(/<\s*script([^\/>]*)>(.*?)<\s*\/\s*script>/gs, (_whole, attrs, children, offset) => {

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

@@ -13,7 +13,7 @@ class DiagnosticsProviderImpl {
         this.languageServiceManager = languageServiceManager;
     }
     async getDiagnostics(document, _cancellationToken) {
-        var _a, _b, _c;
+        var _a, _b;
         // Don't return diagnostics for files inside node_modules. These are considered read-only
         // and they would pollute the output for astro check
         if (((_a = document.getFilePath()) === null || _a === void 0 ? void 0 : _a.includes('/node_modules/')) || ((_b = document.getFilePath()) === null || _b === void 0 ? void 0 : _b.includes('\\node_modules\\'))) {
@@ -21,16 +21,14 @@ class DiagnosticsProviderImpl {
         }
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
-        const { script: scriptBoundaries, markdown: markdownBoundaries } = this.getTagBoundaries(lang, filePath);
+        const { script: scriptBoundaries } = this.getTagBoundaries(lang, filePath);
         const syntaxDiagnostics = lang.getSyntacticDiagnostics(filePath);
         const suggestionDiagnostics = lang.getSuggestionDiagnostics(filePath);
         const semanticDiagnostics = lang.getSemanticDiagnostics(filePath).filter((d) => {
-            return isNoWithinScript(scriptBoundaries, d);
+            return isNoWithinBoundary(scriptBoundaries, d);
         });
         const diagnostics = [...syntaxDiagnostics, ...suggestionDiagnostics, ...semanticDiagnostics];
         const fragment = await tsDoc.createFragment();
-        const sourceFile = (_c = lang.getProgram()) === null || _c === void 0 ? void 0 : _c.getSourceFile(filePath);
-        const isNoFalsePositiveInst = isNoFalsePositive();
         return diagnostics
             .map((diagnostic) => ({
             range: (0, utils_1.convertRange)(tsDoc, diagnostic),
@@ -43,14 +41,13 @@ class DiagnosticsProviderImpl {
             .map(mapRange(fragment, document))
             .filter((diag) => {
             return (hasNoNegativeLines(diag) &&
-                isNoFalsePositiveInst(diag) &&
                 isNoJSXImplicitRuntimeWarning(diag) &&
                 isNoJSXMustHaveOneParent(diag) &&
-                isNoCantUseJSX(diag) &&
                 isNoCantEndWithTS(diag) &&
                 isNoSpreadExpected(diag) &&
                 isNoCantResolveJSONModule(diag) &&
-                isNoMarkdownBlockQuoteWithinMarkdown(sourceFile, markdownBoundaries, diag));
+                isNoCantReturnOutsideFunction(diag) &&
+                isNoJsxCannotHaveMultipleAttrsError(diag));
         })
             .map(enhanceIfNecessary);
     }
@@ -64,7 +61,7 @@ class DiagnosticsProviderImpl {
         if (!sourceFile) {
             return boundaries;
         }
-        function findScript(parent) {
+        function findTags(parent) {
             typescript_1.default.forEachChild(parent, (node) => {
                 if (typescript_1.default.isJsxElement(node)) {
                     let tagName = node.openingElement.tagName.getText();
@@ -80,10 +77,10 @@ class DiagnosticsProviderImpl {
                         }
                     }
                 }
-                findScript(node);
+                findTags(node);
             });
         }
-        findScript(sourceFile);
+        findTags(sourceFile);
         return boundaries;
     }
 }
@@ -116,33 +113,55 @@ function mapRange(fragment, _document) {
 function hasNoNegativeLines(diagnostic) {
     return diagnostic.range.start.line >= 0 && diagnostic.range.end.line >= 0;
 }
-function isNoFalsePositive() {
-    return (diagnostic) => {
-        return isNoJsxCannotHaveMultipleAttrsError(diagnostic);
-    };
-}
 /**
- * Jsx cannot have multiple attributes with same name,
- * but that's allowed for svelte
+ * Astro allows multiple attributes to have the same name
  */
 function isNoJsxCannotHaveMultipleAttrsError(diagnostic) {
     return diagnostic.code !== 17001;
 }
-function isNoJSXImplicitRuntimeWarning(diagnostic) {
-    return diagnostic.code !== 7016 && diagnostic.code !== 2792;
-}
+/** Astro allows component with multiple root elements */
 function isNoJSXMustHaveOneParent(diagnostic) {
     return diagnostic.code !== 2657;
 }
-function isNoCantUseJSX(diagnostic) {
-    return diagnostic.code !== 17004 && diagnostic.code !== 6142;
-}
+/** Astro allows `.ts` ending for imports, unlike TypeScript */
 function isNoCantEndWithTS(diagnostic) {
     return diagnostic.code !== 2691;
 }
 function isNoSpreadExpected(diagnostic) {
     return diagnostic.code !== 1005;
 }
+function isNoJSXImplicitRuntimeWarning(diagnostic) {
+    return diagnostic.code !== 7016 && diagnostic.code !== 2792;
+}
+/**
+ * Ignore "Can't return outside of function body"
+ * This is technically a valid diagnostic, but due to how we format our TSX, the frontmatter is at top-level so we have
+ * to ignore this. It wasn't a problem before because users didn't need to return things but they can now with SSR
+ */
+function isNoCantReturnOutsideFunction(diagnostic) {
+    return diagnostic.code !== 1108;
+}
+/**
+ * Astro allows users to import JSON modules
+ */
+function isNoCantResolveJSONModule(diagnostic) {
+    return diagnostic.code !== 2732;
+}
+/**
+ * Some diagnostics have JSX-specific nomenclature or unclear description. Enhance them for more clarity.
+ */
+function enhanceIfNecessary(diagnostic) {
+    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;
+}
 function isWithinBoundaries(boundaries, start) {
     for (let [bstart, bend] of boundaries) {
         if (start > bstart && start < bend) {
@@ -163,39 +182,6 @@ function diagnosticIsWithinBoundaries(sourceFile, boundaries, diagnostic) {
     let pos = typescript_1.default.getPositionOfLineAndCharacter(sourceFile, startRange.line, startRange.character);
     return isWithinBoundaries(boundaries, pos);
 }
-function isNoWithinScript(boundaries, diagnostic) {
+function isNoWithinBoundary(boundaries, diagnostic) {
     return !diagnosticIsWithinBoundaries(undefined, boundaries, diagnostic);
 }
-/**
- * This allows us to have JSON module imports.
- */
-function isNoCantResolveJSONModule(diagnostic) {
-    return diagnostic.code !== 2732;
-}
-/**
- * This is for using > within a markdown component like:
- * <Markdown>
- *   > Blockquote here.
- * </Markdown>
- */
-function isNoMarkdownBlockQuoteWithinMarkdown(sourceFile, boundaries, diagnostic) {
-    if (diagnostic.code !== 1382) {
-        return true;
-    }
-    return !diagnosticIsWithinBoundaries(sourceFile, boundaries, diagnostic);
-}
-/**
- * Some diagnostics have JSX-specific nomenclature. Enhance them for more clarity.
- */
-function enhanceIfNecessary(diagnostic) {
-    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.js

@@ -20,17 +20,20 @@ class DocumentSymbolsProviderImpl {
         }
         const symbols = [];
         this.collectSymbols(navTree, fragment, undefined, (symbol) => symbols.push(symbol));
+        const originalContainerName = symbols[0].name;
         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))));
+            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)), document.getURL()));
         }
         // 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()))));
+        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())), document.getURL()));
         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';
+                if (symbol.containerName === originalContainerName) {
+                    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));

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

@@ -0,0 +1,15 @@
+import { CancellationToken, Range, SemanticTokens } from 'vscode-languageserver';
+import { AstroDocument } from '../../../core/documents';
+import { SemanticTokensProvider } from '../../interfaces';
+import { LanguageServiceManager } from '../LanguageServiceManager';
+export declare class SemanticTokensProviderImpl implements SemanticTokensProvider {
+    private languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
+    private mapToOrigin;
+    /**
+     *  TSClassification = (TokenType + 1) << TokenEncodingConsts.typeOffset + TokenModifier
+     */
+    private getTokenTypeFromClassification;
+    private getTokenModifierFromClassification;
+}

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

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticTokensProviderImpl = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const vscode_languageserver_1 = require("vscode-languageserver");
+const documents_1 = require("../../../core/documents");
+const utils_1 = require("../utils");
+class SemanticTokensProviderImpl {
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
+    }
+    async getSemanticTokens(document, range, cancellationToken) {
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const fragment = (await tsDoc.createFragment());
+        if (cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.isCancellationRequested) {
+            return null;
+        }
+        const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
+        const start = range ? fragment.offsetAt(fragment.getGeneratedPosition(range.start)) : 0;
+        const { spans } = lang.getEncodedSemanticClassifications(filePath, {
+            start,
+            length: range
+                ? fragment.offsetAt(fragment.getGeneratedPosition(range.end)) - start
+                : // We don't want tokens for things added by astro2tsx
+                    fragment.text.lastIndexOf('export default function (_props:') || fragment.text.length,
+        }, typescript_1.default.SemanticClassificationFormat.TwentyTwenty);
+        const tokens = [];
+        let i = 0;
+        while (i < spans.length) {
+            const offset = spans[i++];
+            const generatedLength = spans[i++];
+            const classification = spans[i++];
+            const originalPosition = this.mapToOrigin(document, fragment, offset, generatedLength);
+            if (!originalPosition) {
+                continue;
+            }
+            const [line, character, length] = originalPosition;
+            const classificationType = this.getTokenTypeFromClassification(classification);
+            if (classificationType < 0) {
+                continue;
+            }
+            const modifier = this.getTokenModifierFromClassification(classification);
+            tokens.push([line, character, length, classificationType, modifier]);
+        }
+        const sorted = tokens.sort((a, b) => {
+            const [lineA, charA] = a;
+            const [lineB, charB] = b;
+            return lineA - lineB || charA - charB;
+        });
+        const builder = new vscode_languageserver_1.SemanticTokensBuilder();
+        sorted.forEach((tokenData) => builder.push(...tokenData));
+        const build = builder.build();
+        return build;
+    }
+    mapToOrigin(document, fragment, generatedOffset, generatedLength) {
+        const range = {
+            start: fragment.positionAt(generatedOffset),
+            end: fragment.positionAt(generatedOffset + generatedLength),
+        };
+        const { start: startPosition, end: endPosition } = (0, documents_1.mapRangeToOriginal)(fragment, range);
+        if (startPosition.line < 0 || endPosition.line < 0) {
+            return;
+        }
+        const startOffset = document.offsetAt(startPosition);
+        const endOffset = document.offsetAt(endPosition);
+        return [startPosition.line, startPosition.character, endOffset - startOffset, startOffset];
+    }
+    /**
+     *  TSClassification = (TokenType + 1) << TokenEncodingConsts.typeOffset + TokenModifier
+     */
+    getTokenTypeFromClassification(tsClassification) {
+        return (tsClassification >> 8 /* typeOffset */) - 1;
+    }
+    getTokenModifierFromClassification(tsClassification) {
+        return tsClassification & 255 /* modifierMask */;
+    }
+}
+exports.SemanticTokensProviderImpl = SemanticTokensProviderImpl;

package/dist/plugins/typescript/language-service.d.ts

@@ -35,4 +35,4 @@ export declare function forAllLanguageServices(cb: (service: LanguageServiceCont
  * @param tsconfigPath has to be absolute
  * @param docContext
  */
-export declare function getLanguageServiceForTsconfig(tsconfigPath: string, docContext: LanguageServiceDocumentContext): Promise<LanguageServiceContainer>;
+export declare function getLanguageServiceForTsconfig(tsconfigPath: string, docContext: LanguageServiceDocumentContext, workspaceUris: string[]): Promise<LanguageServiceContainer>;

package/dist/plugins/typescript/language-service.js

@@ -37,7 +37,7 @@ const DocumentSnapshotUtils = __importStar(require("./snapshots/utils"));
 const services = new Map();
 async function getLanguageService(path, workspaceUris, docContext) {
     const tsconfigPath = (0, utils_2.findTsConfigPath)(path, workspaceUris);
-    return getLanguageServiceForTsconfig(tsconfigPath, docContext);
+    return getLanguageServiceForTsconfig(tsconfigPath, docContext, workspaceUris);
 }
 exports.getLanguageService = getLanguageService;
 async function forAllLanguageServices(cb) {
@@ -50,34 +50,44 @@ exports.forAllLanguageServices = forAllLanguageServices;
  * @param tsconfigPath has to be absolute
  * @param docContext
  */
-async function getLanguageServiceForTsconfig(tsconfigPath, docContext) {
+async function getLanguageServiceForTsconfig(tsconfigPath, docContext, workspaceUris) {
     let service;
     if (services.has(tsconfigPath)) {
         service = await services.get(tsconfigPath);
     }
     else {
-        const newService = createLanguageService(tsconfigPath, docContext);
+        const newService = createLanguageService(tsconfigPath, docContext, workspaceUris);
         services.set(tsconfigPath, newService);
         service = await newService;
     }
     return service;
 }
 exports.getLanguageServiceForTsconfig = getLanguageServiceForTsconfig;
-async function createLanguageService(tsconfigPath, docContext) {
-    const workspaceRoot = tsconfigPath ? (0, path_1.dirname)(tsconfigPath) : process.cwd();
+async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
+    const tsconfigRoot = tsconfigPath ? (0, path_1.dirname)(tsconfigPath) : process.cwd();
+    const workspacePaths = workspaceUris.map((uri) => (0, utils_1.urlToPath)(uri));
+    const workspacePath = workspacePaths.find((uri) => tsconfigRoot.startsWith(uri)) || workspacePaths[0];
+    const astroVersion = (0, utils_1.getUserAstroVersion)(workspacePath);
     // `raw` here represent the tsconfig merged with any extended config
     const { compilerOptions, fileNames: files, raw: fullConfig } = getParsedTSConfig();
     let projectVersion = 0;
-    const snapshotManager = new SnapshotManager_1.SnapshotManager(docContext.globalSnapshotManager, files, fullConfig, workspaceRoot || process.cwd());
+    const snapshotManager = new SnapshotManager_1.SnapshotManager(docContext.globalSnapshotManager, files, fullConfig, tsconfigRoot || process.cwd());
     const astroModuleLoader = (0, module_loader_1.createAstroModuleLoader)(getScriptSnapshot, compilerOptions);
-    let languageServerDirectory;
-    try {
-        languageServerDirectory = (0, path_1.dirname)(require.resolve('@astrojs/language-server'));
-    }
-    catch (e) {
-        languageServerDirectory = __dirname;
+    const scriptFileNames = [];
+    // Before Astro 1.0, JSX definitions were inside of the language-server instead of inside Astro
+    // TODO: Remove this and astro-jsx.d.ts in types when we consider having support for Astro < 1.0 unnecessary
+    if (astroVersion.major === 0 || astroVersion.full === '1.0.0-beta.0') {
+        let languageServerDirectory;
+        try {
+            languageServerDirectory = (0, path_1.dirname)(require.resolve('@astrojs/language-server'));
+        }
+        catch (e) {
+            languageServerDirectory = __dirname;
+        }
+        const astroTSXFile = typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, '../types/astro-jsx.d.ts'));
+        scriptFileNames.push(astroTSXFile);
+        console.warn("Version lower than 1.0 detected, using internal types instead of Astro's");
     }
-    const astroTSXFile = typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, '../types/astro-jsx.d.ts'));
     const host = {
         getNewLine: () => typescript_1.default.sys.newLine,
         useCaseSensitiveFileNames: () => typescript_1.default.sys.useCaseSensitiveFileNames,
@@ -87,10 +97,10 @@ async function createLanguageService(tsconfigPath, docContext) {
         fileExists: astroModuleLoader.fileExists,
         readDirectory: astroModuleLoader.readDirectory,
         getCompilationSettings: () => compilerOptions,
-        getCurrentDirectory: () => workspaceRoot,
+        getCurrentDirectory: () => tsconfigRoot,
         getDefaultLibFileName: typescript_1.default.getDefaultLibFilePath,
         getProjectVersion: () => projectVersion.toString(),
-        getScriptFileNames: () => Array.from(new Set([...snapshotManager.getProjectFileNames(), ...snapshotManager.getFileNames(), astroTSXFile])),
+        getScriptFileNames: () => Array.from(new Set([...snapshotManager.getProjectFileNames(), ...snapshotManager.getFileNames(), ...scriptFileNames])),
         getScriptSnapshot,
         getScriptVersion: (fileName) => getScriptSnapshot(fileName).version.toString(),
     };
@@ -176,17 +186,24 @@ async function createLanguageService(tsconfigPath, docContext) {
         snapshotManager.updateNonAstroFile(fileName, changes);
     }
     function getParsedTSConfig() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         let configJson = (tsconfigPath && typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile).config) || {};
         // If our user has types in their config but it doesn't include the types needed for Astro, add them to the config
-        if (((_a = configJson.compilerOptions) === null || _a === void 0 ? void 0 : _a.types) && !((_b = configJson.compilerOptions) === null || _b === void 0 ? void 0 : _b.types.includes('astro/env'))) {
-            configJson.compilerOptions.types.push('astro/env');
+        if ((_a = configJson.compilerOptions) === null || _a === void 0 ? void 0 : _a.types) {
+            if (!((_b = configJson.compilerOptions) === null || _b === void 0 ? void 0 : _b.types.includes('astro/env'))) {
+                configJson.compilerOptions.types.push('astro/env');
+            }
+            if (astroVersion.major >= 1 &&
+                astroVersion.full !== '1.0.0-beta.0' &&
+                !((_c = configJson.compilerOptions) === null || _c === void 0 ? void 0 : _c.types.includes('astro/astro-jsx'))) {
+                configJson.compilerOptions.types.push('astro/astro-jsx');
+            }
         }
-        configJson.compilerOptions = Object.assign(getDefaultCompilerOptions(), configJson.compilerOptions);
+        configJson.compilerOptions = Object.assign(getDefaultCompilerOptions(astroVersion), configJson.compilerOptions);
         // Delete include so that .astro files don't get mistakenly excluded by the user
         delete configJson.include;
         // If the user supplied exclude, let's use theirs otherwise, use ours
-        (_c = configJson.exclude) !== null && _c !== void 0 ? _c : (configJson.exclude = getDefaultExclude());
+        (_d = configJson.exclude) !== null && _d !== void 0 ? _d : (configJson.exclude = getDefaultExclude());
         // Everything here will always, unconditionally, be in the resulting config
         const forcedCompilerOptions = {
             noEmit: true,
@@ -200,7 +217,7 @@ async function createLanguageService(tsconfigPath, docContext) {
             target: typescript_1.default.ScriptTarget.ESNext,
             moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
         };
-        const project = typescript_1.default.parseJsonConfigFileContent(configJson, typescript_1.default.sys, workspaceRoot, forcedCompilerOptions, tsconfigPath, undefined, [
+        const project = typescript_1.default.parseJsonConfigFileContent(configJson, typescript_1.default.sys, tsconfigRoot, forcedCompilerOptions, tsconfigPath, undefined, [
             { extension: '.vue', isMixedContent: true, scriptKind: typescript_1.default.ScriptKind.Deferred },
             { extension: '.svelte', isMixedContent: true, scriptKind: typescript_1.default.ScriptKind.Deferred },
             { extension: '.astro', isMixedContent: true, scriptKind: typescript_1.default.ScriptKind.Deferred },
@@ -218,11 +235,15 @@ async function createLanguageService(tsconfigPath, docContext) {
 /**
  * Default configuration used as a base and when the user doesn't have any
  */
-function getDefaultCompilerOptions() {
+function getDefaultCompilerOptions(astroVersion) {
+    const types = ['astro/env'];
+    if (astroVersion.major >= 1 && astroVersion.full !== '1.0.0-beta.0') {
+        types.push('astro/astro-jsx');
+    }
     return {
         maxNodeModuleJsDepth: 2,
         allowSyntheticDefaultImports: true,
-        types: ['astro/env'],
+        types: types,
     };
 }
 function getDefaultExclude() {

package/dist/plugins/typescript/snapshots/SnapshotManager.js

@@ -185,7 +185,8 @@ class SnapshotManager {
         if (date.getTime() - this.lastLogged.getTime() > 60000) {
             this.lastLogged = date;
             const projectFiles = this.getProjectFileNames();
-            const allFiles = Array.from(new Set([...projectFiles, ...this.getFileNames()]));
+            let allFiles = Array.from(new Set([...projectFiles, ...this.getFileNames()]));
+            allFiles = allFiles.map((file) => (0, utils_2.ensureRealFilePath)(file));
             console.log('SnapshotManager File Statistics:\n' +
                 `Project files: ${projectFiles.length}\n` +
                 `Astro files: ${allFiles.filter((name) => name.endsWith('.astro')).length}\n` +

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

@@ -1,6 +1,29 @@
 import ts from 'typescript';
-import { CompletionItemKind, DiagnosticSeverity, Position, Range, SymbolKind } from 'vscode-languageserver';
+import { CompletionItemKind, DiagnosticSeverity, Position, Range, SymbolKind, SemanticTokensLegend } from 'vscode-languageserver';
 import { SnapshotFragment } from './snapshots/DocumentSnapshot';
+export declare const enum TokenType {
+    class = 0,
+    enum = 1,
+    interface = 2,
+    namespace = 3,
+    typeParameter = 4,
+    type = 5,
+    parameter = 6,
+    variable = 7,
+    enumMember = 8,
+    property = 9,
+    function = 10,
+    method = 11
+}
+export declare const enum TokenModifier {
+    declaration = 0,
+    static = 1,
+    async = 2,
+    readonly = 3,
+    defaultLibrary = 4,
+    local = 5
+}
+export declare function getSemanticTokenLegend(): SemanticTokensLegend;
 export declare function symbolKindFromString(kind: string): SymbolKind;
 export declare function scriptElementKindToCompletionItemKind(kind: ts.ScriptElementKind): CompletionItemKind;
 export declare function getCommitCharactersForScriptElement(kind: ts.ScriptElementKind): string[] | undefined;

package/dist/plugins/typescript/utils.js

@@ -3,12 +3,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureRealFilePath = exports.ensureRealAstroFilePath = exports.toRealAstroFilePath = exports.toVirtualFilePath = exports.toVirtualAstroFilePath = exports.isVirtualFilePath = exports.isVirtualSvelteFilePath = exports.isVirtualVueFilePath = exports.isVirtualAstroFilePath = exports.isFrameworkFilePath = exports.isAstroFilePath = exports.isVirtualFrameworkFilePath = exports.getFrameworkFromFilePath = exports.convertToLocationRange = exports.convertRange = exports.mapSeverity = exports.getScriptKindFromFileName = exports.isSubPath = exports.findTsConfigPath = exports.getExtensionFromScriptKind = exports.getCommitCharactersForScriptElement = exports.scriptElementKindToCompletionItemKind = exports.symbolKindFromString = void 0;
+exports.ensureRealFilePath = exports.ensureRealAstroFilePath = exports.toRealAstroFilePath = exports.toVirtualFilePath = exports.toVirtualAstroFilePath = exports.isVirtualFilePath = exports.isVirtualSvelteFilePath = exports.isVirtualVueFilePath = exports.isVirtualAstroFilePath = exports.isFrameworkFilePath = exports.isAstroFilePath = exports.isVirtualFrameworkFilePath = exports.getFrameworkFromFilePath = exports.convertToLocationRange = exports.convertRange = exports.mapSeverity = exports.getScriptKindFromFileName = exports.isSubPath = exports.findTsConfigPath = exports.getExtensionFromScriptKind = exports.getCommitCharactersForScriptElement = exports.scriptElementKindToCompletionItemKind = exports.symbolKindFromString = exports.getSemanticTokenLegend = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const path_1 = require("path");
 const utils_1 = require("../../utils");
 const vscode_languageserver_1 = require("vscode-languageserver");
 const documents_1 = require("../../core/documents");
+function getSemanticTokenLegend() {
+    const tokenModifiers = [];
+    [
+        [0 /* declaration */, vscode_languageserver_1.SemanticTokenModifiers.declaration],
+        [1 /* static */, vscode_languageserver_1.SemanticTokenModifiers.static],
+        [2 /* async */, vscode_languageserver_1.SemanticTokenModifiers.async],
+        [3 /* readonly */, vscode_languageserver_1.SemanticTokenModifiers.readonly],
+        [4 /* defaultLibrary */, vscode_languageserver_1.SemanticTokenModifiers.defaultLibrary],
+        [5 /* local */, 'local'],
+    ].forEach(([tsModifier, legend]) => (tokenModifiers[tsModifier] = legend));
+    const tokenTypes = [];
+    [
+        [0 /* class */, vscode_languageserver_1.SemanticTokenTypes.class],
+        [1 /* enum */, vscode_languageserver_1.SemanticTokenTypes.enum],
+        [2 /* interface */, vscode_languageserver_1.SemanticTokenTypes.interface],
+        [3 /* namespace */, vscode_languageserver_1.SemanticTokenTypes.namespace],
+        [4 /* typeParameter */, vscode_languageserver_1.SemanticTokenTypes.typeParameter],
+        [5 /* type */, vscode_languageserver_1.SemanticTokenTypes.type],
+        [6 /* parameter */, vscode_languageserver_1.SemanticTokenTypes.parameter],
+        [7 /* variable */, vscode_languageserver_1.SemanticTokenTypes.variable],
+        [8 /* enumMember */, vscode_languageserver_1.SemanticTokenTypes.enumMember],
+        [9 /* property */, vscode_languageserver_1.SemanticTokenTypes.property],
+        [10 /* function */, vscode_languageserver_1.SemanticTokenTypes.function],
+        [11 /* method */, vscode_languageserver_1.SemanticTokenTypes.method],
+    ].forEach(([tokenType, legend]) => (tokenTypes[tokenType] = legend));
+    return {
+        tokenModifiers,
+        tokenTypes,
+    };
+}
+exports.getSemanticTokenLegend = getSemanticTokenLegend;
 function symbolKindFromString(kind) {
     switch (kind) {
         case 'module':