@astrojs/language-server 0.20.1 → 0.21.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @astrojs/language-server
 
+## 0.21.1
+
+### Patch Changes
+
+- 0e9d7d0: Improve error handling in cases where we can't load types from the user's project and when the project isn't at the root of the folder
+- 3f79dbf: Fix `tsconfig.json` not loading properly in certain contexts on Windows
+
+## 0.21.0
+
+### Minor Changes
+
+- 574b75d: Remove support for the Markdown component
+- d23ba22: Changed how Astro's types are consumed to avoid making type acquisition explicit inside Astro files
+
+### Patch Changes
+
+- 81f3aa5: Added a debug command to show the currently opened document's TSX output
+
+## 0.20.3
+
+### Patch Changes
+
+- 081cf24: Fix completions not working inside script tags, fix duplicate completions in some cases, added completions for the slot element
+
 ## 0.20.1
 
 ### Patch Changes

package/README.md

@@ -11,6 +11,5 @@ The Astro language server, implement the [language server protocol](https://micr
 │   ├── core        # Core code such as .astro file parsing, configuration manager, document definition etc
 │   └── plugins     # Modules for the different languages supported in .astro files
 ├── test            # Tests
-├── types           # Types
-└── astro.d.ts      # Types injected into .astro files by the language server
+└── types           # Types injected into Astro files by the language server under certain conditions
 ```

package/dist/check.js

@@ -4,6 +4,8 @@ exports.AstroCheck = exports.DiagnosticSeverity = void 0;
 const config_1 = require("./core/config");
 const documents_1 = require("./core/documents");
 const plugins_1 = require("./plugins");
+const LanguageServiceManager_1 = require("./plugins/typescript/LanguageServiceManager");
+const utils_1 = require("./utils");
 var vscode_languageserver_types_1 = require("vscode-languageserver-types");
 Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return vscode_languageserver_types_1.DiagnosticSeverity; } });
 class AstroCheck {
@@ -37,7 +39,8 @@ class AstroCheck {
         }));
     }
     initialize(workspacePath) {
-        this.pluginHost.registerPlugin(new plugins_1.TypeScriptPlugin(this.docManager, this.configManager, [workspacePath]));
+        const languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(this.docManager, [(0, utils_1.normalizeUri)(workspacePath)], this.configManager);
+        this.pluginHost.registerPlugin(new plugins_1.TypeScriptPlugin(this.configManager, languageServiceManager));
     }
     async getDiagnosticsForFile(uri) {
         const diagnostics = await this.pluginHost.getDiagnostics({ uri });

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

@@ -21,6 +21,10 @@ export declare function getLineAtPosition(position: Position, text: string): str
  * Return if a given offset is inside the start tag of a component
  */
 export declare function isInComponentStartTag(html: HTMLDocument, offset: number): boolean;
+/**
+ * Return if a given offset is inside the name of a tag
+ */
+export declare function isInTagName(html: HTMLDocument, offset: number): boolean;
 /**
  * Return true if a specific node could be a component.
  * This is not a 100% sure test as it'll return false for any component that does not match the standard format for a component

package/dist/core/documents/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFirstNonWhitespaceIndex = exports.getLineOffsets = exports.offsetAt = exports.positionAt = exports.isInsideFrontmatter = exports.isInsideExpression = exports.isInTag = exports.isPossibleComponent = exports.isInComponentStartTag = exports.getLineAtPosition = exports.extractScriptTags = exports.extractStyleTags = exports.walk = void 0;
+exports.getFirstNonWhitespaceIndex = exports.getLineOffsets = exports.offsetAt = exports.positionAt = exports.isInsideFrontmatter = exports.isInsideExpression = exports.isInTag = exports.isPossibleComponent = exports.isInTagName = exports.isInComponentStartTag = exports.getLineAtPosition = exports.extractScriptTags = exports.extractStyleTags = exports.walk = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
 const utils_1 = require("../../utils");
 const parseHtml_1 = require("./parseHtml");
@@ -105,6 +105,14 @@ function isInComponentStartTag(html, offset) {
     return isPossibleComponent(node) && (!node.startTagEnd || offset < node.startTagEnd);
 }
 exports.isInComponentStartTag = isInComponentStartTag;
+/**
+ * Return if a given offset is inside the name of a tag
+ */
+function isInTagName(html, offset) {
+    const node = html.findNodeAt(offset);
+    return offset > node.start && offset < node.start + (node.tag?.length ?? 0);
+}
+exports.isInTagName = isInTagName;
 /**
  * Return true if a specific node could be a component.
  * This is not a 100% sure test as it'll return false for any component that does not match the standard format for a component

package/dist/importPackage.d.ts

@@ -1,6 +1,6 @@
 import type * as svelte from '@astrojs/svelte/dist/editor.cjs';
 import type * as vue from '@astrojs/svelte/dist/editor.cjs';
 export declare function setIsTrusted(_isTrusted: boolean): void;
-export declare function getPackagePath(packageName: string, fromPath: string): string | undefined;
+export declare function getPackagePath(packageName: string, fromPath: string[]): string | undefined;
 export declare function importSvelteIntegration(fromPath: string): typeof svelte | undefined;
 export declare function importVueIntegration(fromPath: string): typeof vue | undefined;

package/dist/importPackage.js

@@ -10,13 +10,10 @@ exports.setIsTrusted = setIsTrusted;
 function getPackagePath(packageName, fromPath) {
     const paths = [];
     if (isTrusted) {
-        paths.unshift(fromPath);
+        paths.unshift(...fromPath);
     }
     try {
-        const packageJSONPath = require.resolve(`${packageName}/package.json`, {
-            paths,
-        });
-        return (0, path_1.dirname)(packageJSONPath);
+        return (0, path_1.dirname)(require.resolve(packageName + '/package.json', { paths }));
     }
     catch (e) {
         return undefined;
@@ -24,10 +21,16 @@ function getPackagePath(packageName, fromPath) {
 }
 exports.getPackagePath = getPackagePath;
 function importEditorIntegration(packageName, fromPath) {
-    const pkgPath = getPackagePath(packageName, fromPath);
+    const pkgPath = getPackagePath(packageName, [fromPath]);
     if (pkgPath) {
-        const main = (0, path_1.resolve)(pkgPath, 'dist', 'editor.cjs');
-        return require(main);
+        try {
+            const main = (0, path_1.resolve)(pkgPath, 'dist', 'editor.cjs');
+            return require(main);
+        }
+        catch (e) {
+            console.error(`Couldn't load editor module from ${pkgPath}. Make sure you're using at least version v0.2.1 of the corresponding integration`);
+            return undefined;
+        }
     }
     return undefined;
 }

package/dist/plugins/PluginHost.js

@@ -38,19 +38,14 @@ class PluginHost {
         const astro = completions.find((completion) => completion.plugin === 'astro');
         if (html && ts) {
             const inComponentStartTag = (0, documents_1.isInComponentStartTag)(document.html, document.offsetAt(position));
-            if (!inComponentStartTag) {
+            // If the HTML plugin returned completions, it's highly likely that TS ones are duplicate
+            if (html.result.items.length > 0) {
                 ts.result.items = [];
             }
-            // If the Astro plugin has completions for us, don't show TypeScript's as they're most likely duplicates
+            // Inside components, if the Astro plugin has completions we don't want the TS ones are they're duplicates
             if (astro && astro.result.items.length > 0 && inComponentStartTag) {
                 ts.result.items = [];
             }
-            ts.result.items = ts.result.items.map((item) => {
-                if (item.sortText != '-1') {
-                    item.sortText = 'Z' + (item.sortText || '');
-                }
-                return item;
-            });
         }
         let flattenedCompletions = completions.flatMap((completion) => completion.result.items);
         const isIncomplete = completions.reduce((incomplete, completion) => incomplete || completion.result.isIncomplete, false);

package/dist/plugins/astro/AstroPlugin.d.ts

@@ -1,13 +1,14 @@
 import { CompletionContext, FoldingRange, Position } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
-import { AstroDocument, DocumentManager } from '../../core/documents';
+import { AstroDocument } from '../../core/documents';
 import { AppCompletionList, Plugin } from '../interfaces';
+import { LanguageServiceManager } from '../typescript/LanguageServiceManager';
 export declare class AstroPlugin implements Plugin {
     __name: string;
     private configManager;
     private readonly languageServiceManager;
     private readonly completionProvider;
-    constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
+    constructor(configManager: ConfigManager, languageServiceManager: LanguageServiceManager);
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
     getFoldingRanges(document: AstroDocument): FoldingRange[];
 }

package/dist/plugins/astro/AstroPlugin.js

@@ -2,13 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstroPlugin = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
-const LanguageServiceManager_1 = require("../typescript/LanguageServiceManager");
 const CompletionsProvider_1 = require("./features/CompletionsProvider");
 class AstroPlugin {
-    constructor(docManager, configManager, workspaceUris) {
+    constructor(configManager, languageServiceManager) {
         this.__name = 'astro';
         this.configManager = configManager;
-        this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
+        this.languageServiceManager = languageServiceManager;
         this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
     }
     async getCompletions(document, position, completionContext) {

package/dist/plugins/html/HTMLPlugin.js

@@ -11,7 +11,7 @@ class HTMLPlugin {
     constructor(configManager) {
         this.__name = 'html';
         this.lang = (0, vscode_html_languageservice_1.getLanguageService)({
-            customDataProviders: [astro_attributes_1.astroAttributes, astro_attributes_1.classListAttribute],
+            customDataProviders: [astro_attributes_1.astroAttributes, astro_attributes_1.astroElements, astro_attributes_1.classListAttribute],
         });
         this.attributeOnlyLang = (0, vscode_html_languageservice_1.getLanguageService)({
             customDataProviders: [astro_attributes_1.astroAttributes],
@@ -72,10 +72,14 @@ class HTMLPlugin {
         }
         // If we're in a component starting tag, we do not want HTML language completions
         // as HTML attributes are not valid for components
-        const results = (0, utils_1.isInComponentStartTag)(html, document.offsetAt(position))
+        const inComponentTag = (0, utils_1.isInComponentStartTag)(html, offset);
+        const inTagName = (0, utils_1.isInTagName)(html, offset);
+        const results = inComponentTag && !inTagName
             ? (0, utils_2.removeDataAttrCompletion)(this.attributeOnlyLang.doComplete(document, position, html).items)
-            : this.lang.doComplete(document, position, html).items;
-        return vscode_languageserver_1.CompletionList.create([...results, ...this.getLangCompletions(results), ...emmetResults.items], 
+            : // We filter items with no documentation to prevent duplicates with our own defined script and style tags
+                this.lang.doComplete(document, position, html).items.filter((item) => item.documentation !== undefined);
+        const langCompletions = inComponentTag ? [] : this.getLangCompletions(results);
+        return vscode_languageserver_1.CompletionList.create([...results, ...langCompletions, ...emmetResults.items], 
         // Emmet completions change on every keystroke, so they are never complete
         emmetResults.items.length > 0);
     }

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

@@ -1,3 +1,4 @@
 export declare const classListAttribute: import("vscode-html-languageservice").IHTMLDataProvider;
+export declare const astroElements: import("vscode-html-languageservice").IHTMLDataProvider;
 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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.astroDirectives = exports.astroAttributes = exports.classListAttribute = void 0;
+exports.astroDirectives = exports.astroAttributes = exports.astroElements = exports.classListAttribute = void 0;
 const vscode_html_languageservice_1 = require("vscode-html-languageservice");
 exports.classListAttribute = (0, vscode_html_languageservice_1.newHTMLDataProvider)('class-list', {
     version: 1,
@@ -17,42 +17,31 @@ exports.classListAttribute = (0, vscode_html_languageservice_1.newHTMLDataProvid
         },
     ],
 });
-exports.astroAttributes = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-attributes', {
+exports.astroElements = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-elements', {
     version: 1,
-    globalAttributes: [
-        {
-            name: 'set:html',
-            description: 'Inject unescaped HTML into this tag',
-            references: [
-                {
-                    name: 'Astro reference',
-                    url: 'https://docs.astro.build/en/reference/directives-reference/#sethtml',
-                },
-            ],
-        },
+    tags: [
         {
-            name: 'set:text',
-            description: 'Inject escaped text into this tag',
+            name: 'slot',
+            description: 'The slot element is a placeholder for external HTML content, allowing you to inject (or “slot”) child elements from other files into your component template.',
             references: [
                 {
                     name: 'Astro reference',
-                    url: 'https://docs.astro.build/en/reference/directives-reference/#settext',
+                    url: 'https://docs.astro.build/en/core-concepts/astro-components/#slots',
                 },
             ],
-        },
-        {
-            name: 'is:raw',
-            description: 'Instructs the Astro compiler to treat any children of this element as text',
-            valueSet: 'v',
-            references: [
+            attributes: [
                 {
-                    name: 'Astro reference',
-                    url: 'https://docs.astro.build/en/reference/directives-reference/#israw',
+                    name: 'name',
+                    description: 'The name attribute allows you to pass only HTML elements with the corresponding slot name into a slot’s location.',
+                    references: [
+                        {
+                            name: 'Astro reference',
+                            url: 'https://docs.astro.build/en/core-concepts/astro-components/#named-slots',
+                        },
+                    ],
                 },
             ],
         },
-    ],
-    tags: [
         {
             name: 'script',
             attributes: [
@@ -146,6 +135,42 @@ exports.astroAttributes = (0, vscode_html_languageservice_1.newHTMLDataProvider)
         },
     ],
 });
+exports.astroAttributes = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-attributes', {
+    version: 1,
+    globalAttributes: [
+        {
+            name: 'set:html',
+            description: 'Inject unescaped HTML into this tag',
+            references: [
+                {
+                    name: 'Astro reference',
+                    url: 'https://docs.astro.build/en/reference/directives-reference/#sethtml',
+                },
+            ],
+        },
+        {
+            name: 'set:text',
+            description: 'Inject escaped text into this tag',
+            references: [
+                {
+                    name: 'Astro reference',
+                    url: 'https://docs.astro.build/en/reference/directives-reference/#settext',
+                },
+            ],
+        },
+        {
+            name: 'is:raw',
+            description: 'Instructs the Astro compiler to treat any children of this element as text',
+            valueSet: 'v',
+            references: [
+                {
+                    name: 'Astro reference',
+                    url: 'https://docs.astro.build/en/reference/directives-reference/#israw',
+                },
+            ],
+        },
+    ],
+});
 exports.astroDirectives = (0, vscode_html_languageservice_1.newHTMLDataProvider)('astro-directives', {
     version: 1,
     globalAttributes: [

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

@@ -1,8 +1,10 @@
 import { CancellationToken, CodeAction, CodeActionContext, CompletionContext, DefinitionLink, Diagnostic, FoldingRange, FormattingOptions, Hover, InlayHint, Position, Range, SemanticTokens, SignatureHelp, SignatureHelpContext, SymbolInformation, TextDocumentContentChangeEvent, TextEdit, WorkspaceEdit } from 'vscode-languageserver';
 import { ConfigManager } from '../../core/config';
-import { AstroDocument, DocumentManager } from '../../core/documents';
+import { AstroDocument } from '../../core/documents';
 import { AppCompletionItem, AppCompletionList, OnWatchFileChangesParam, Plugin } from '../interfaces';
 import { CompletionItemData } from './features/CompletionsProvider';
+import { LanguageServiceManager } from './LanguageServiceManager';
+import { Astro2TSXResult } from './astro2tsx';
 export declare class TypeScriptPlugin implements Plugin {
     __name: string;
     private configManager;
@@ -18,7 +20,7 @@ export declare class TypeScriptPlugin implements Plugin {
     private readonly semanticTokensProvider;
     private readonly foldingRangesProvider;
     private readonly formattingProvider;
-    constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
+    constructor(configManager: ConfigManager, languageServiceManager: LanguageServiceManager);
     doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
     rename(document: AstroDocument, position: Position, newName: string): Promise<WorkspaceEdit | null>;
     formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
@@ -34,5 +36,6 @@ export declare class TypeScriptPlugin implements Plugin {
     onWatchFileChanges(onWatchFileChangesParas: OnWatchFileChangesParam[]): Promise<void>;
     updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): Promise<void>;
     getSignatureHelp(document: AstroDocument, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
+    getTSXForDocument(document: AstroDocument): Astro2TSXResult;
     private featureEnabled;
 }

package/dist/plugins/typescript/TypeScriptPlugin.js

@@ -10,7 +10,6 @@ const CompletionsProvider_1 = require("./features/CompletionsProvider");
 const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
 const HoverProvider_1 = require("./features/HoverProvider");
 const SignatureHelpProvider_1 = require("./features/SignatureHelpProvider");
-const LanguageServiceManager_1 = require("./LanguageServiceManager");
 const utils_1 = require("./utils");
 const DocumentSymbolsProvider_1 = require("./features/DocumentSymbolsProvider");
 const SemanticTokenProvider_1 = require("./features/SemanticTokenProvider");
@@ -19,11 +18,13 @@ const CodeActionsProvider_1 = require("./features/CodeActionsProvider");
 const DefinitionsProvider_1 = require("./features/DefinitionsProvider");
 const InlayHintsProvider_1 = require("./features/InlayHintsProvider");
 const FormattingProvider_1 = require("./features/FormattingProvider");
+const astro2tsx_1 = __importDefault(require("./astro2tsx"));
+const utils_2 = require("./snapshots/utils");
 class TypeScriptPlugin {
-    constructor(docManager, configManager, workspaceUris) {
+    constructor(configManager, languageServiceManager) {
         this.__name = 'typescript';
         this.configManager = configManager;
-        this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
+        this.languageServiceManager = languageServiceManager;
         this.codeActionsProvider = new CodeActionsProvider_1.CodeActionsProviderImpl(this.languageServiceManager, this.configManager);
         this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager, this.configManager);
         this.hoverProvider = new HoverProvider_1.HoverProviderImpl(this.languageServiceManager);
@@ -137,6 +138,9 @@ class TypeScriptPlugin {
     async getSignatureHelp(document, position, context, cancellationToken) {
         return this.signatureHelpProvider.getSignatureHelp(document, position, context, cancellationToken);
     }
+    getTSXForDocument(document) {
+        return (0, astro2tsx_1.default)(document.getText(), (0, utils_2.classNameFromFilename)(document.getURL()));
+    }
     async featureEnabled(document, feature) {
         return ((await this.configManager.isEnabled(document, 'typescript')) &&
             (await this.configManager.isEnabled(document, 'typescript', feature)));

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

@@ -1,5 +1,4 @@
-interface Astro2TSXResult {
+export interface Astro2TSXResult {
     code: string;
 }
 export default function (content: string, className: string): Astro2TSXResult;
-export {};

package/dist/plugins/typescript/astro2tsx.js

@@ -41,10 +41,6 @@ function default_1(content, className) {
         // 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/CompletionsProvider.d.ts

@@ -21,7 +21,6 @@ export declare class CompletionsProviderImpl implements CompletionsProvider<Comp
     getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext, cancellationToken?: CancellationToken): Promise<AppCompletionList<CompletionItemData> | null>;
     resolveCompletion(document: AstroDocument, item: AppCompletionItem<CompletionItemData>, cancellationToken?: CancellationToken): Promise<AppCompletionItem<CompletionItemData>>;
     private toCompletionItem;
-    private isValidCompletion;
     private getCompletionDocument;
     /**
      * If the textEdit is out of the word range of the triggered position

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

@@ -78,26 +78,8 @@ class CompletionsProviderImpl {
             scriptTagIndex = scriptIndex;
             completions = lang.getCompletionsAtPosition(scriptFilePath, scriptOffset, {
                 ...tsPreferences,
-                // File extensions are required inside script tags, however TypeScript can't return completions with the `ts`
-                // extension, so what we'll do instead is force `minimal` (aka, no extension) and manually add the extensions
-                importModuleSpecifierEnding: 'minimal',
                 triggerCharacter: validTriggerCharacter,
             }, formatOptions);
-            if (completions) {
-                // Manually adds file extensions to js and ts files
-                completions.entries = completions?.entries.map((comp) => {
-                    if (comp.kind === typescript_1.ScriptElementKind.scriptElement &&
-                        (comp.kindModifiers === '.js' || comp.kindModifiers === '.ts')) {
-                        return {
-                            ...comp,
-                            name: comp.name + comp.kindModifiers,
-                        };
-                    }
-                    else {
-                        return comp;
-                    }
-                });
-            }
         }
         else {
             // PERF: Getting TS completions is fairly slow and I am currently not sure how to speed it up
@@ -132,7 +114,7 @@ class CompletionsProviderImpl {
         const fragment = await tsDoc.createFragment();
         const existingImports = this.getExistingImports(document);
         const completionItems = completions.entries
-            .filter(this.isValidCompletion)
+            .filter(isValidCompletion)
             .map((entry) => this.toCompletionItem(fragment, entry, filePath, offset, isCompletionInsideFrontmatter, scriptTagIndex, existingImports))
             .filter(utils_3.isNotNullOrUndefined)
             .map((comp) => this.fixTextEditRange(wordRangeStartPosition, comp));
@@ -250,13 +232,6 @@ class CompletionsProviderImpl {
             },
         };
     }
-    isValidCompletion(completion) {
-        // Remove completion for default exported function
-        if (completion.name === 'default' && completion.kindModifiers == typescript_1.ScriptElementKindModifier.exportedModifier) {
-            return false;
-        }
-        return true;
-    }
     getCompletionDocument(compDetail) {
         const { sourceDisplay, documentation: tsDocumentation, displayParts } = compDetail;
         let detail = (0, utils_2.removeAstroComponentSuffix)(typescript_1.default.displayPartsToString(displayParts));
@@ -355,3 +330,31 @@ function codeActionChangeToTextEdit(document, fragment, isInsideScriptTag, chang
     return vscode_languageserver_1.TextEdit.replace(range, change.newText);
 }
 exports.codeActionChangeToTextEdit = codeActionChangeToTextEdit;
+// When Svelte components are imported, we have to reference the svelte2tsx's types to properly type the component
+// An unfortunate downside of this is that it polutes completions, so let's filter those internal types manually
+const svelte2tsxTypes = new Set([
+    'Svelte2TsxComponent',
+    'Svelte2TsxComponentConstructorParameters',
+    'SvelteComponentConstructor',
+    'SvelteActionReturnType',
+    'SvelteTransitionConfig',
+    'SvelteTransitionReturnType',
+    'SvelteAnimationReturnType',
+    'SvelteWithOptionalProps',
+    'SvelteAllProps',
+    'SveltePropsAnyFallback',
+    'SvelteSlotsAnyFallback',
+    'SvelteRestProps',
+    'SvelteSlots',
+    'SvelteStore',
+]);
+function isValidCompletion(completion) {
+    // Remove completion for default exported function
+    const isDefaultExport = completion.name === 'default' && completion.kindModifiers == typescript_1.ScriptElementKindModifier.exportedModifier;
+    // Remove completion for svelte2tsx internal types
+    const isSvelte2tsxCompletion = completion.name.startsWith('__sveltets_') || svelte2tsxTypes.has(completion.name);
+    if (isDefaultExport || isSvelte2tsxCompletion) {
+        return false;
+    }
+    return true;
+}

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

@@ -95,7 +95,6 @@ class DiagnosticsProviderImpl {
         const sourceFile = program?.getSourceFile(tsFilePath);
         const boundaries = {
             script: [],
-            markdown: [],
         };
         if (!sourceFile) {
             return boundaries;
@@ -110,10 +109,6 @@ class DiagnosticsProviderImpl {
                             boundaries.script.push([node.getStart(), node.getEnd()]);
                             break;
                         }
-                        case 'Markdown': {
-                            boundaries.markdown.push([node.getStart(), node.getEnd()]);
-                            break;
-                        }
                     }
                 }
                 findTags(node);

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

@@ -19,7 +19,7 @@ class FoldingRangesProviderImpl {
             const node = html.findNodeAt(span.textSpan.start);
             // Due to how our TSX output transform those tags into function calls or template literals
             // TypeScript thinks of those as outlining spans, which is fine but we don't want folding ranges for those
-            return node.tag !== 'script' && node.tag !== 'style' && node.tag !== 'Markdown';
+            return node.tag !== 'script' && node.tag !== 'style';
         });
         const scriptOutliningSpans = [];
         document.scriptTags.forEach((scriptTag) => {

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

@@ -72,7 +72,7 @@ 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);
+    const astroInstall = (0, utils_1.getAstroInstall)([tsconfigRoot, workspacePath]);
     const config = (await docContext.configManager.getConfig('astro.typescript', workspacePath)) ?? {};
     const allowArbitraryAttrs = config.allowArbitraryAttributes ?? false;
     // `raw` here represent the tsconfig merged with any extended config
@@ -80,6 +80,10 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
     let projectVersion = 0;
     const snapshotManager = new SnapshotManager_1.SnapshotManager(docContext.globalSnapshotManager, files, fullConfig, tsconfigRoot || process.cwd());
     const astroModuleLoader = (0, module_loader_1.createAstroModuleLoader)(getScriptSnapshot, compilerOptions);
+    const scriptFileNames = [];
+    if (astroInstall) {
+        scriptFileNames.push(...['./env.d.ts', './astro-jsx.d.ts'].map((f) => typescript_1.default.sys.resolvePath((0, path_1.resolve)(astroInstall.path, f))));
+    }
     let languageServerDirectory;
     try {
         languageServerDirectory = (0, path_1.dirname)(require.resolve('@astrojs/language-server'));
@@ -87,15 +91,13 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
     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') &&
-        !astroVersion.full.startsWith('0.0.0-rc-') // 1.0.0's RC is considered to be 0.0.0, so we have to check for it
+    // Fallback to internal types when Astro is not installed or the Astro version is too old
+    if (!astroInstall ||
+        ((astroInstall.version.major === 0 || astroInstall.version.full === '1.0.0-beta.0') &&
+            !astroInstall.version.full.startsWith('0.0.0-rc-')) // 1.0.0's RC is considered to be 0.0.0, so we have to check for it
     ) {
-        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");
+        scriptFileNames.push(...['../types/astro-jsx.d.ts', '../types/env.d.ts'].map((f) => typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, f))));
+        console.warn("Couldn't load types from Astro, using internal types instead");
     }
     if (allowArbitraryAttrs) {
         const arbitraryAttrsDTS = typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, '../types/arbitrary-attrs.d.ts'));
@@ -221,23 +223,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         });
     }
     function getParsedTSConfig() {
-        let configJson = (tsconfigPath && typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile).config) || {
-            compilerOptions: getDefaultCompilerOptions(astroVersion),
-        };
-        // If our user has types in their config but it doesn't include the types needed for Astro, add them to the config
-        if (configJson.compilerOptions?.types) {
-            if (!configJson.compilerOptions?.types.includes('astro/env')) {
-                configJson.compilerOptions.types.push('astro/env');
-            }
-            if ((astroVersion.major >= 1 || astroVersion.full.startsWith('0.0.0-rc-')) &&
-                astroVersion.full !== '1.0.0-beta.0' &&
-                !configJson.compilerOptions?.types.includes('astro/astro-jsx')) {
-                configJson.compilerOptions.types.push('astro/astro-jsx');
-            }
-        }
-        else {
-            configJson.compilerOptions = Object.assign(getDefaultCompilerOptions(astroVersion), configJson.compilerOptions);
-        }
+        let configJson = (tsconfigPath && typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile).config) || {};
         // 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
@@ -273,18 +259,6 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         };
     }
 }
-/**
- * Default compiler configuration used when the user doesn't have any
- */
-function getDefaultCompilerOptions(astroVersion) {
-    const types = ['astro/env'];
-    if ((astroVersion.major >= 1 && astroVersion.full !== '1.0.0-beta.0') || astroVersion.full.startsWith('0.0.0-rc-')) {
-        types.push('astro/astro-jsx');
-    }
-    return {
-        types: types,
-    };
-}
 function getDefaultExclude() {
     return ['dist', 'node_modules'];
 }

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

@@ -26,3 +26,4 @@ export declare function createFromTSFilePath(filePath: string): TypeScriptDocume
  */
 export declare function createFromAstroFilePath(filePath: string, createDocument: (filePath: string, text: string) => AstroDocument): AstroSnapshot;
 export declare function createFromFrameworkFilePath(filePath: string, framework: FrameworkExt): TypeScriptDocumentSnapshot;
+export declare function classNameFromFilename(filename: string): string;