@astrojs/language-server 0.9.2 → 0.12.0

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,227 @@
+"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, _d;
+        let configJson = (tsconfigPath && typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile).config) || {};
+        // If our user has types in their config but it doesn't include the types needed for Astro, add them to the config
+        if (((_a = configJson.compilerOptions) === null || _a === void 0 ? void 0 : _a.types) && !((_b = configJson.compilerOptions) === null || _b === void 0 ? void 0 : _b.types.includes('astro/env'))) {
+            configJson.compilerOptions.types.push('astro/env');
+        }
+        configJson.compilerOptions = Object.assign(getDefaultCompilerOptions(), configJson.compilerOptions);
+        // If the user supplied exclude, let's use theirs
+        (_c = configJson.exclude) !== null && _c !== void 0 ? _c : (configJson.exclude = getDefaultExclude());
+        // 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
+        (_d = configJson.exclude) !== null && _d !== void 0 ? _d : (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,
+            // Most of the code people write in an .astro file is in the frontmatter which is executed server side
+            // Thus, we don't want the DOM lib. We'll need to overwrite this for script tags however
+            lib: ['ESNext'],
+            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>;
 };

package/dist/plugins/typescript/module-loader.js

@@ -7,6 +7,7 @@ exports.createAstroModuleLoader = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const utils_1 = require("./utils");
 const astro_sys_1 = require("./astro-sys");
+const utils_2 = require("../../utils");
 /**
  * Caches resolved modules.
  */
@@ -21,12 +22,15 @@ class ModuleResolutionCache {
         return this.cache.get(this.getKey(moduleName, containingFile));
     }
     /**
-     * Caches resolved module, if it is not undefined.
+     * Checks if has cached module.
+     */
+    has(moduleName, containingFile) {
+        return this.cache.has(this.getKey(moduleName, containingFile));
+    }
+    /**
+     * Caches resolved module (or undefined).
      */
     set(moduleName, containingFile, resolvedModule) {
-        if (!resolvedModule) {
-            return;
-        }
         this.cache.set(this.getKey(moduleName, containingFile), resolvedModule);
     }
     /**
@@ -35,21 +39,34 @@ class ModuleResolutionCache {
      */
     delete(resolvedModuleName) {
         this.cache.forEach((val, key) => {
-            if (val.resolvedFileName === resolvedModuleName) {
+            if ((val === null || val === void 0 ? void 0 : val.resolvedFileName) === resolvedModuleName) {
+                this.cache.delete(key);
+            }
+        });
+    }
+    /**
+     * Deletes everything from cache that resolved to `undefined`
+     * and which might match the path.
+     */
+    deleteUnresolvedResolutionsFromCache(path) {
+        const fileNameWithoutEnding = (0, utils_2.getLastPartOfPath)(path).split('.').shift() || '';
+        this.cache.forEach((val, key) => {
+            const moduleName = key.split(':::').pop() || '';
+            if (!val && moduleName.includes(fileNameWithoutEnding)) {
                 this.cache.delete(key);
             }
         });
     }
     getKey(moduleName, containingFile) {
-        return containingFile + ':::' + (0, utils_1.ensureRealAstroFilePath)(moduleName);
+        return containingFile + ':::' + (0, utils_1.ensureRealFilePath)(moduleName);
     }
 }
 /**
- * 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.
  *
@@ -62,19 +79,21 @@ function createAstroModuleLoader(getSnapshot, compilerOptions) {
     return {
         fileExists: astroSys.fileExists,
         readFile: astroSys.readFile,
-        writeFile: astroSys.writeFile,
         readDirectory: astroSys.readDirectory,
-        directoryExists: astroSys.directoryExists,
-        getDirectories: astroSys.getDirectories,
-        realpath: astroSys.realpath,
-        deleteFromModuleCache: (path) => moduleCache.delete(path),
+        deleteFromModuleCache: (path) => {
+            astroSys.deleteFromCache(path);
+            moduleCache.delete(path);
+        },
+        deleteUnresolvedResolutionsFromCache: (path) => {
+            astroSys.deleteFromCache(path);
+            moduleCache.deleteUnresolvedResolutionsFromCache(path);
+        },
         resolveModuleNames,
     };
     function resolveModuleNames(moduleNames, containingFile) {
         return moduleNames.map((moduleName) => {
-            const cachedModule = moduleCache.get(moduleName, containingFile);
-            if (cachedModule) {
-                return cachedModule;
+            if (moduleCache.has(moduleName, containingFile)) {
+                return moduleCache.get(moduleName, containingFile);
             }
             const resolvedModule = resolveModuleName(moduleName, containingFile);
             moduleCache.set(moduleName, containingFile, resolvedModule);
@@ -84,22 +103,23 @@ function createAstroModuleLoader(getSnapshot, compilerOptions) {
     function resolveModuleName(name, containingFile) {
         // Delegate to the TS resolver first.
         // If that does not bring up anything, try the Astro Module loader
-        // which is able to deal with .astro files.
+        // which is able to deal with .astro and other frameworks files.
         const tsResolvedModule = typescript_1.default.resolveModuleName(name, containingFile, compilerOptions, typescript_1.default.sys).resolvedModule;
-        if (tsResolvedModule && !(0, utils_1.isVirtualAstroFilePath)(tsResolvedModule.resolvedFileName)) {
+        if (tsResolvedModule && !(0, utils_1.isVirtualFilePath)(tsResolvedModule.resolvedFileName)) {
             return tsResolvedModule;
         }
         const astroResolvedModule = typescript_1.default.resolveModuleName(name, containingFile, compilerOptions, astroSys).resolvedModule;
-        if (!astroResolvedModule || !(0, utils_1.isVirtualAstroFilePath)(astroResolvedModule.resolvedFileName)) {
+        if (!astroResolvedModule || !(0, utils_1.isVirtualFilePath)(astroResolvedModule.resolvedFileName)) {
             return astroResolvedModule;
         }
-        const resolvedFileName = (0, utils_1.ensureRealAstroFilePath)(astroResolvedModule.resolvedFileName);
+        const resolvedFileName = (0, utils_1.ensureRealFilePath)(astroResolvedModule.resolvedFileName);
         const snapshot = getSnapshot(resolvedFileName);
-        const resolvedastroModule = {
+        const resolvedAstroModule = {
             extension: (0, utils_1.getExtensionFromScriptKind)(snapshot && snapshot.scriptKind),
             resolvedFileName,
+            isExternalLibraryImport: astroResolvedModule.isExternalLibraryImport,
         };
-        return resolvedastroModule;
+        return resolvedAstroModule;
     }
 }
 exports.createAstroModuleLoader = createAstroModuleLoader;