@astrojs/language-server 0.9.3 → 0.12.1

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

@@ -5,66 +5,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiagnosticsProviderImpl = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const vscode_languageserver_1 = require("vscode-languageserver");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
 const documents_1 = require("../../../core/documents");
 const utils_1 = require("../utils");
-const utils_2 = require("./utils");
 class DiagnosticsProviderImpl {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;
     }
     async getDiagnostics(document, _cancellationToken) {
-        var _a, _b, _c, _d, _e;
-        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\\'))) &&
-            // Sapper convention: Put stuff inside node_modules below src
-            !(((_c = document.getFilePath()) === null || _c === void 0 ? void 0 : _c.includes('/src/node_modules/')) ||
-                ((_d = document.getFilePath()) === null || _d === void 0 ? void 0 : _d.includes('\\src\\node_modules\\')))) {
-            // Don't return diagnostics for files inside node_modules. These are considered read-only (cannot be changed)
-            // and in case of svelte-check they would pollute/skew the output
+        var _a, _b, _c;
+        // 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\\'))) {
             return [];
         }
-        const { lang, tsDoc } = await this.getLSAndTSDoc(document);
-        const isTypescript = tsDoc.scriptKind === typescript_1.default.ScriptKind.TSX;
-        // Document preprocessing failed, show parser error instead
-        if (tsDoc.parserError) {
-            return [
-                {
-                    range: tsDoc.parserError.range,
-                    severity: vscode_languageserver_1.DiagnosticSeverity.Error,
-                    source: isTypescript ? 'ts' : 'js',
-                    message: tsDoc.parserError.message,
-                    code: tsDoc.parserError.code
-                }
-            ];
-        }
+        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 syntaxDiagnostics = lang.getSyntacticDiagnostics(filePath);
         const suggestionDiagnostics = lang.getSuggestionDiagnostics(filePath);
-        const semanticDiagnostics = lang.getSemanticDiagnostics(filePath).filter(d => {
-            return (isNoWithinScript(scriptBoundaries, d));
+        const semanticDiagnostics = lang.getSemanticDiagnostics(filePath).filter((d) => {
+            return isNoWithinScript(scriptBoundaries, d);
         });
-        const diagnostics = [
-            ...syntaxDiagnostics,
-            ...suggestionDiagnostics,
-            ...semanticDiagnostics
-        ];
-        const fragment = await tsDoc.getFragment();
-        const sourceFile = (_e = lang.getProgram()) === null || _e === void 0 ? void 0 : _e.getSourceFile(filePath);
+        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
-            .filter(isNotGenerated(tsDoc.getText(0, tsDoc.getLength())))
             .map((diagnostic) => ({
             range: (0, utils_1.convertRange)(tsDoc, diagnostic),
             severity: (0, utils_1.mapSeverity)(diagnostic.category),
-            source: isTypescript ? 'ts' : 'js',
+            source: 'ts',
             message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
             code: diagnostic.code,
-            tags: getDiagnosticTag(diagnostic)
+            tags: getDiagnosticTag(diagnostic),
         }))
             .map(mapRange(fragment, document))
-            .filter(diag => {
+            .filter((diag) => {
             return (hasNoNegativeLines(diag) &&
                 isNoFalsePositiveInst(diag) &&
                 isNoJSXImplicitRuntimeWarning(diag) &&
@@ -77,21 +54,18 @@ class DiagnosticsProviderImpl {
         })
             .map(enhanceIfNecessary);
     }
-    async getLSAndTSDoc(document) {
-        return this.languageServiceManager.getTypeScriptDoc(document);
-    }
     getTagBoundaries(lang, tsFilePath) {
         const program = lang.getProgram();
         const sourceFile = program === null || program === void 0 ? void 0 : program.getSourceFile(tsFilePath);
         const boundaries = {
             script: [],
-            markdown: []
+            markdown: [],
         };
         if (!sourceFile) {
             return boundaries;
         }
         function findScript(parent) {
-            typescript_1.default.forEachChild(parent, node => {
+            typescript_1.default.forEachChild(parent, (node) => {
                 if (typescript_1.default.isJsxElement(node)) {
                     let tagName = node.openingElement.tagName.getText();
                     switch (tagName) {
@@ -117,10 +91,10 @@ exports.DiagnosticsProviderImpl = DiagnosticsProviderImpl;
 function getDiagnosticTag(diagnostic) {
     const tags = [];
     if (diagnostic.reportsUnnecessary) {
-        tags.push(vscode_languageserver_1.DiagnosticTag.Unnecessary);
+        tags.push(vscode_languageserver_types_1.DiagnosticTag.Unnecessary);
     }
     if (diagnostic.reportsDeprecated) {
-        tags.push(vscode_languageserver_1.DiagnosticTag.Deprecated);
+        tags.push(vscode_languageserver_types_1.DiagnosticTag.Deprecated);
     }
     return tags;
 }
@@ -144,7 +118,7 @@ function hasNoNegativeLines(diagnostic) {
 }
 function isNoFalsePositive() {
     return (diagnostic) => {
-        return (isNoJsxCannotHaveMultipleAttrsError(diagnostic));
+        return isNoJsxCannotHaveMultipleAttrsError(diagnostic);
     };
 }
 /**
@@ -226,7 +200,7 @@ function enhanceIfNecessary(diagnostic) {
                 '  import type { SvelteComponentTyped } from "svelte";\n' +
                 '  class ComponentName extends SvelteComponentTyped<{propertyName: string;}> {}\n\n' +
                 'Underlying error:\n' +
-                diagnostic.message
+                diagnostic.message,
         };
     }
     if (diagnostic.code === 2607) {
@@ -235,27 +209,14 @@ function enhanceIfNecessary(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
+                diagnostic.message,
         };
     }
     if (diagnostic.code === 1184) {
         return {
             ...diagnostic,
-            message: diagnostic.message +
-                '\nIf this is a declare statement, move it into <script context="module">..</script>'
+            message: diagnostic.message + '\nIf this is a declare statement, move it into <script context="module">..</script>',
         };
     }
     return diagnostic;
 }
-/**
- * Checks if diagnostic is not within a section that should be completely ignored
- * because it's purely generated.
- */
-function isNotGenerated(text) {
-    return (diagnostic) => {
-        if (diagnostic.start === undefined || diagnostic.length === undefined) {
-            return true;
-        }
-        return !(0, utils_2.isInGeneratedCode)(text, diagnostic.start, diagnostic.start + diagnostic.length);
-    };
-}

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

@@ -1,10 +1,9 @@
 import type { LanguageServiceManager } from '../LanguageServiceManager';
 import { Hover, Position } from 'vscode-languageserver';
-import { Document } from '../../../core/documents';
+import { AstroDocument } from '../../../core/documents';
 import { HoverProvider } from '../../interfaces';
 export declare class HoverProviderImpl implements HoverProvider {
-    private readonly lang;
-    constructor(lang: LanguageServiceManager);
-    doHover(document: Document, position: Position): Promise<Hover | null>;
-    private getLSAndTSDoc;
+    private readonly languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
+    doHover(document: AstroDocument, position: Position): Promise<Hover | null>;
 }

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

@@ -10,12 +10,12 @@ const previewer_1 = require("../previewer");
 const utils_1 = require("../utils");
 const partsMap = new Map([['JSX attribute', 'HTML attribute']]);
 class HoverProviderImpl {
-    constructor(lang) {
-        this.lang = lang;
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
     }
     async doHover(document, position) {
-        const { lang, tsDoc } = await this.getLSAndTSDoc(document);
-        const fragment = await tsDoc.getFragment();
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
+        const fragment = await tsDoc.createFragment();
         const offset = fragment.offsetAt(fragment.getGeneratedPosition(position));
         const filePath = (0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath);
         let info = lang.getQuickInfoAtPosition(filePath, offset);
@@ -23,21 +23,20 @@ class HoverProviderImpl {
             return null;
         }
         const textSpan = info.textSpan;
-        const displayParts = (info.displayParts || []).map(value => ({
+        const displayParts = (info.displayParts || []).map((value) => ({
             text: partsMap.has(value.text) ? partsMap.get(value.text) : value.text,
-            kind: value.kind
+            kind: value.kind,
         }));
         const declaration = typescript_1.default.displayPartsToString(displayParts);
         const documentation = (0, previewer_1.getMarkdownDocumentation)(info.documentation, info.tags);
         // https://microsoft.github.io/language-server-protocol/specification#textDocument_hover
-        const contents = ['```typescript', declaration, '```'].concat(documentation ? ['---', documentation] : []).join('\n');
+        const contents = ['```typescript', declaration, '```']
+            .concat(documentation ? ['---', documentation] : [])
+            .join('\n');
         return (0, documents_1.mapObjWithRangeToOriginal)(fragment, {
             range: (0, utils_1.convertRange)(fragment, textSpan),
             contents,
         });
     }
-    async getLSAndTSDoc(document) {
-        return this.lang.getTypeScriptDoc(document);
-    }
 }
 exports.HoverProviderImpl = HoverProviderImpl;

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

@@ -1,13 +1,13 @@
 import type { LanguageServiceManager } from '../LanguageServiceManager';
 import type { SignatureHelpProvider } from '../../interfaces';
 import { Position, SignatureHelpContext, SignatureHelp, CancellationToken } from 'vscode-languageserver';
-import { Document } from '../../../core/documents';
+import { AstroDocument } from '../../../core/documents';
 export declare class SignatureHelpProviderImpl implements SignatureHelpProvider {
-    private readonly lang;
-    constructor(lang: LanguageServiceManager);
+    private readonly languageServiceManager;
+    constructor(languageServiceManager: LanguageServiceManager);
     private static readonly triggerCharacters;
     private static readonly retriggerCharacters;
-    getSignatureHelp(document: Document, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
+    getSignatureHelp(document: AstroDocument, position: Position, context: SignatureHelpContext | undefined, cancellationToken?: CancellationToken): Promise<SignatureHelp | null>;
     private isReTrigger;
     private isTriggerCharacter;
     /**
@@ -18,5 +18,4 @@ export declare class SignatureHelpProviderImpl implements SignatureHelpProvider
      * adopted from https://github.com/microsoft/vscode/blob/265a2f6424dfbd3a9788652c7d376a7991d049a3/extensions/typescript-language-features/src/languageFeatures/signatureHelp.ts#L73
      */
     private toSignatureHelpInformation;
-    private isInSvelte2tsxGeneratedFunction;
 }

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

@@ -9,19 +9,20 @@ const vscode_languageserver_1 = require("vscode-languageserver");
 const previewer_1 = require("../previewer");
 const utils_1 = require("../utils");
 class SignatureHelpProviderImpl {
-    constructor(lang) {
-        this.lang = lang;
+    constructor(languageServiceManager) {
+        this.languageServiceManager = languageServiceManager;
     }
     async getSignatureHelp(document, position, context, cancellationToken) {
-        const { lang, tsDoc } = await this.lang.getTypeScriptDoc(document);
-        const fragment = await tsDoc.getFragment();
+        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 offset = fragment.offsetAt(fragment.getGeneratedPosition(position));
         const triggerReason = this.toTsTriggerReason(context);
-        const info = lang.getSignatureHelpItems((0, utils_1.toVirtualAstroFilePath)(tsDoc.filePath), offset, triggerReason ? { triggerReason } : undefined);
-        if (!info || info.items.some((signature) => this.isInSvelte2tsxGeneratedFunction(signature))) {
+        const info = lang.getSignatureHelpItems(filePath, offset, triggerReason ? { triggerReason } : undefined);
+        if (!info) {
             return null;
         }
         const signatures = info.items.map(this.toSignatureHelpInformation);
@@ -32,7 +33,9 @@ class SignatureHelpProviderImpl {
         };
     }
     isReTrigger(isRetrigger, triggerCharacter) {
-        return isRetrigger && (this.isTriggerCharacter(triggerCharacter) || SignatureHelpProviderImpl.retriggerCharacters.includes(triggerCharacter));
+        return (isRetrigger &&
+            (this.isTriggerCharacter(triggerCharacter) ||
+                SignatureHelpProviderImpl.retriggerCharacters.includes(triggerCharacter)));
     }
     isTriggerCharacter(triggerCharacter) {
         return SignatureHelpProviderImpl.triggerCharacters.includes(triggerCharacter);
@@ -66,7 +69,11 @@ class SignatureHelpProviderImpl {
      * adopted from https://github.com/microsoft/vscode/blob/265a2f6424dfbd3a9788652c7d376a7991d049a3/extensions/typescript-language-features/src/languageFeatures/signatureHelp.ts#L73
      */
     toSignatureHelpInformation(item) {
-        const [prefixLabel, separatorLabel, suffixLabel] = [item.prefixDisplayParts, item.separatorDisplayParts, item.suffixDisplayParts].map(typescript_1.default.displayPartsToString);
+        const [prefixLabel, separatorLabel, suffixLabel] = [
+            item.prefixDisplayParts,
+            item.separatorDisplayParts,
+            item.suffixDisplayParts,
+        ].map(typescript_1.default.displayPartsToString);
         let textIndex = prefixLabel.length;
         let signatureLabel = '';
         const parameters = [];
@@ -95,9 +102,6 @@ class SignatureHelpProviderImpl {
             parameters,
         };
     }
-    isInSvelte2tsxGeneratedFunction(signatureHelpItem) {
-        return signatureHelpItem.prefixDisplayParts.some((part) => part.text.includes('__sveltets'));
-    }
 }
 exports.SignatureHelpProviderImpl = SignatureHelpProviderImpl;
 SignatureHelpProviderImpl.triggerCharacters = ['(', ',', '<'];

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

@@ -1,16 +1,5 @@
-import type { SnapshotFragment, DocumentSnapshot } from '../DocumentSnapshot';
+import type { SnapshotFragment, DocumentSnapshot } from '../snapshots/DocumentSnapshot';
 import type { LanguageServiceManager } from '../LanguageServiceManager';
-import type { TextSpan } from 'typescript';
-/**
- * Checks if this a section that should be completely ignored
- * because it's purely generated.
- */
-export declare function isInGeneratedCode(text: string, start: number, end: number): boolean;
-/**
- * Checks that this isn't a text span that should be completely ignored
- * because it's purely generated.
- */
-export declare function isNoTextSpanInGeneratedCode(text: string, span: TextSpan): boolean;
 export declare class SnapshotFragmentMap {
     private languageServiceManager;
     private map;

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

@@ -1,26 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnapshotFragmentMap = exports.isNoTextSpanInGeneratedCode = exports.isInGeneratedCode = void 0;
-/**
- * Checks if this a section that should be completely ignored
- * because it's purely generated.
- */
-function isInGeneratedCode(text, start, end) {
-    const lineStart = text.lastIndexOf('\n', start);
-    const lineEnd = text.indexOf('\n', end);
-    const lastStart = text.substring(lineStart, start).lastIndexOf('/*Ωignore_startΩ*/');
-    const lastEnd = text.substring(lineStart, start).lastIndexOf('/*Ωignore_endΩ*/');
-    return lastStart > lastEnd && text.substring(end, lineEnd).includes('/*Ωignore_endΩ*/');
-}
-exports.isInGeneratedCode = isInGeneratedCode;
-/**
- * Checks that this isn't a text span that should be completely ignored
- * because it's purely generated.
- */
-function isNoTextSpanInGeneratedCode(text, span) {
-    return !isInGeneratedCode(text, span.start, span.start + span.length);
-}
-exports.isNoTextSpanInGeneratedCode = isNoTextSpanInGeneratedCode;
+exports.SnapshotFragmentMap = void 0;
 class SnapshotFragmentMap {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;
@@ -40,7 +20,7 @@ class SnapshotFragmentMap {
         let snapshotFragment = this.get(fileName);
         if (!snapshotFragment) {
             const snapshot = await this.languageServiceManager.getSnapshot(fileName);
-            const fragment = await snapshot.getFragment();
+            const fragment = await snapshot.createFragment();
             snapshotFragment = { fragment, snapshot };
             this.set(fileName, snapshotFragment);
         }

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

@@ -0,0 +1,38 @@
+import { AstroDocument } from '../../core/documents';
+import ts from 'typescript';
+import { TextDocumentContentChangeEvent } from 'vscode-languageserver';
+import { GlobalSnapshotManager, SnapshotManager } from './snapshots/SnapshotManager';
+import { DocumentSnapshot } from './snapshots/DocumentSnapshot';
+export interface LanguageServiceContainer {
+    readonly tsconfigPath: string;
+    readonly compilerOptions: ts.CompilerOptions;
+    /**
+     * @internal Public for tests only
+     */
+    readonly snapshotManager: SnapshotManager;
+    getService(): ts.LanguageService;
+    updateSnapshot(documentOrFilePath: AstroDocument | string): DocumentSnapshot;
+    deleteSnapshot(filePath: string): void;
+    updateProjectFiles(): void;
+    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): void;
+    /**
+     * Checks if a file is present in the project.
+     * Unlike `fileBelongsToProject`, this doesn't run a file search on disk.
+     */
+    hasFile(filePath: string): boolean;
+    /**
+     * Careful, don't call often, or it will hurt performance.
+     */
+    fileBelongsToProject(filePath: string): boolean;
+}
+export interface LanguageServiceDocumentContext {
+    createDocument: (fileName: string, content: string) => AstroDocument;
+    globalSnapshotManager: GlobalSnapshotManager;
+}
+export declare function getLanguageService(path: string, workspaceUris: string[], docContext: LanguageServiceDocumentContext): Promise<LanguageServiceContainer>;
+export declare function forAllLanguageServices(cb: (service: LanguageServiceContainer) => any): Promise<void>;
+/**
+ * @param tsconfigPath has to be absolute
+ * @param docContext
+ */
+export declare function getLanguageServiceForTsconfig(tsconfigPath: string, docContext: LanguageServiceDocumentContext): Promise<LanguageServiceContainer>;

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

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLanguageServiceForTsconfig = exports.forAllLanguageServices = exports.getLanguageService = void 0;
+const path_1 = require("path");
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("../../utils");
+const module_loader_1 = require("./module-loader");
+const SnapshotManager_1 = require("./snapshots/SnapshotManager");
+const utils_2 = require("./utils");
+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);
+}
+exports.getLanguageService = getLanguageService;
+async function forAllLanguageServices(cb) {
+    for (const service of services.values()) {
+        cb(await service);
+    }
+}
+exports.forAllLanguageServices = forAllLanguageServices;
+/**
+ * @param tsconfigPath has to be absolute
+ * @param docContext
+ */
+async function getLanguageServiceForTsconfig(tsconfigPath, docContext) {
+    let service;
+    if (services.has(tsconfigPath)) {
+        service = await services.get(tsconfigPath);
+    }
+    else {
+        const newService = createLanguageService(tsconfigPath, docContext);
+        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();
+    // `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 astroModuleLoader = (0, module_loader_1.createAstroModuleLoader)(getScriptSnapshot, compilerOptions);
+    const host = {
+        getNewLine: () => typescript_1.default.sys.newLine,
+        useCaseSensitiveFileNames: () => typescript_1.default.sys.useCaseSensitiveFileNames,
+        getDirectories: typescript_1.default.sys.getDirectories,
+        resolveModuleNames: astroModuleLoader.resolveModuleNames,
+        readFile: astroModuleLoader.readFile,
+        fileExists: astroModuleLoader.fileExists,
+        readDirectory: astroModuleLoader.readDirectory,
+        getCompilationSettings: () => compilerOptions,
+        getCurrentDirectory: () => workspaceRoot,
+        getDefaultLibFileName: typescript_1.default.getDefaultLibFilePath,
+        getProjectVersion: () => projectVersion.toString(),
+        getScriptFileNames: () => Array.from(new Set([...snapshotManager.getProjectFileNames(), ...snapshotManager.getFileNames()])),
+        getScriptSnapshot,
+        getScriptVersion: (fileName) => getScriptSnapshot(fileName).version.toString(),
+    };
+    let languageService = typescript_1.default.createLanguageService(host);
+    docContext.globalSnapshotManager.onChange(() => {
+        projectVersion++;
+    });
+    return {
+        tsconfigPath,
+        compilerOptions,
+        getService: () => languageService,
+        updateSnapshot,
+        deleteSnapshot,
+        updateProjectFiles,
+        updateNonAstroFile,
+        hasFile,
+        fileBelongsToProject,
+        snapshotManager,
+    };
+    function deleteSnapshot(filePath) {
+        astroModuleLoader.deleteFromModuleCache(filePath);
+        snapshotManager.delete(filePath);
+    }
+    function updateSnapshot(documentOrFilePath) {
+        return typeof documentOrFilePath === 'string'
+            ? updateSnapshotFromFilePath(documentOrFilePath)
+            : updateSnapshotFromDocument(documentOrFilePath);
+    }
+    function updateSnapshotFromDocument(document) {
+        const filePath = document.getFilePath() || '';
+        const prevSnapshot = snapshotManager.get(filePath);
+        if ((prevSnapshot === null || prevSnapshot === void 0 ? void 0 : prevSnapshot.version) === document.version) {
+            return prevSnapshot;
+        }
+        if (!prevSnapshot) {
+            astroModuleLoader.deleteUnresolvedResolutionsFromCache(filePath);
+        }
+        const newSnapshot = DocumentSnapshotUtils.createFromDocument(document);
+        snapshotManager.set(filePath, newSnapshot);
+        if (prevSnapshot && prevSnapshot.scriptKind !== newSnapshot.scriptKind) {
+            // Restart language service as it doesn't handle script kind changes.
+            languageService.dispose();
+            languageService = typescript_1.default.createLanguageService(host);
+        }
+        return newSnapshot;
+    }
+    function updateSnapshotFromFilePath(filePath) {
+        const prevSnapshot = snapshotManager.get(filePath);
+        if (prevSnapshot) {
+            return prevSnapshot;
+        }
+        astroModuleLoader.deleteUnresolvedResolutionsFromCache(filePath);
+        const newSnapshot = DocumentSnapshotUtils.createFromFilePath(filePath, docContext.createDocument);
+        snapshotManager.set(filePath, newSnapshot);
+        return newSnapshot;
+    }
+    function getScriptSnapshot(fileName) {
+        fileName = (0, utils_2.ensureRealFilePath)(fileName);
+        let doc = snapshotManager.get(fileName);
+        if (doc) {
+            return doc;
+        }
+        astroModuleLoader.deleteUnresolvedResolutionsFromCache(fileName);
+        doc = DocumentSnapshotUtils.createFromFilePath(fileName, docContext.createDocument);
+        snapshotManager.set(fileName, doc);
+        return doc;
+    }
+    function updateProjectFiles() {
+        projectVersion++;
+        snapshotManager.updateProjectFiles();
+    }
+    function hasFile(filePath) {
+        return snapshotManager.has(filePath);
+    }
+    function fileBelongsToProject(filePath) {
+        filePath = (0, utils_1.normalizePath)(filePath);
+        return hasFile(filePath) || getParsedTSConfig().fileNames.includes(filePath);
+    }
+    function updateNonAstroFile(fileName, changes) {
+        if (!snapshotManager.has(fileName)) {
+            astroModuleLoader.deleteUnresolvedResolutionsFromCache(fileName);
+        }
+        snapshotManager.updateNonAstroFile(fileName, changes);
+    }
+    function getParsedTSConfig() {
+        var _a, _b, _c;
+        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');
+        }
+        configJson.compilerOptions = Object.assign(getDefaultCompilerOptions(), 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());
+        // Everything here will always, unconditionally, be in the resulting config
+        const forcedCompilerOptions = {
+            // Our TSX is currently not typed, which unfortunately means that we can't support `noImplicitAny`
+            noImplicitAny: false,
+            noEmit: true,
+            declaration: false,
+            allowNonTsExtensions: true,
+            allowJs: true,
+            jsx: typescript_1.default.JsxEmit.Preserve,
+            module: typescript_1.default.ModuleKind.ESNext,
+            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, [
+            { 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 },
+        ]);
+        return {
+            ...project,
+            fileNames: project.fileNames.map(utils_1.normalizePath),
+            compilerOptions: {
+                ...project.options,
+                ...forcedCompilerOptions,
+            },
+        };
+    }
+}
+/**
+ * Default configuration used as a base and when the user doesn't have any
+ */
+function getDefaultCompilerOptions() {
+    return {
+        maxNodeModuleJsDepth: 2,
+        allowSyntheticDefaultImports: true,
+        types: ['astro/env'],
+    };
+}
+function getDefaultExclude() {
+    return ['dist', 'node_modules'];
+}

package/dist/plugins/typescript/module-loader.d.ts

@@ -1,11 +1,11 @@
 import ts from 'typescript';
-import type { DocumentSnapshot } from './DocumentSnapshot';
+import type { DocumentSnapshot } from './snapshots/DocumentSnapshot';
 /**
- * Creates a module loader specifically for `.astro` files.
+ * Creates a module loader specifically for `.astro` and other frameworks files.
  *
  * The typescript language service tries to look up other files that are referenced in the currently open astro file.
- * For `.ts`/`.js` files this works, for `.astro` files it does not by default.
- * Reason: The typescript language service does not know about the `.astro` file ending,
+ * For `.ts`/`.js` files this works, for `.astro` and frameworks files it does not by default.
+ * Reason: The typescript language service does not know about those file endings,
  * so it assumes it's a normal typescript file and searches for files like `../Component.astro.ts`, which is wrong.
  * In order to fix this, we need to wrap typescript's module resolution and reroute all `.astro.ts` file lookups to .astro.
  *
@@ -15,11 +15,8 @@ import type { DocumentSnapshot } from './DocumentSnapshot';
 export declare function createAstroModuleLoader(getSnapshot: (fileName: string) => DocumentSnapshot, compilerOptions: ts.CompilerOptions): {
     fileExists: (path: string) => boolean;
     readFile: (path: string, encoding?: string | undefined) => string | undefined;
-    writeFile: (path: string, data: string, writeByteOrderMark?: boolean | undefined) => void;
     readDirectory: (path: string, extensions?: readonly string[] | undefined, exclude?: readonly string[] | undefined, include?: readonly string[] | undefined, depth?: number | undefined) => string[];
-    directoryExists: (path: string) => boolean;
-    getDirectories: (path: string) => string[];
-    realpath: ((path: string) => string) | undefined;
     deleteFromModuleCache: (path: string) => void;
+    deleteUnresolvedResolutionsFromCache: (path: string) => void;
     resolveModuleNames: (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModule | undefined>;
 };