@astrojs/language-server 0.11.0 → 0.13.0

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

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

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

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

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,230 @@
+"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);
+    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'));
+    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(), astroTSXFile])),
+        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 = {
+            noEmit: true,
+            declaration: false,
+            allowNonTsExtensions: true,
+            allowJs: true,
+            jsx: typescript_1.default.JsxEmit.Preserve,
+            jsxImportSource: undefined,
+            jsxFactory: 'astroHTML',
+            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>;
 };