@astrojs/language-server 0.9.3 → 0.12.1

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;

package/dist/plugins/typescript/{DocumentSnapshot.d.ts → snapshots/DocumentSnapshot.d.ts}

@@ -1,26 +1,11 @@
-import * as ts from 'typescript';
-import { TextDocumentContentChangeEvent, Position, Range } from 'vscode-languageserver';
-import { Document, DocumentMapper } from '../../core/documents';
-/**
- * The mapper to get from original snapshot positions to generated and vice versa.
- */
-export interface SnapshotFragment extends DocumentMapper {
-    positionAt(offset: number): Position;
-    offsetAt(position: Position): number;
-}
-/**
- * An error which occured while trying to parse/preprocess the Astro file contents.
- */
-export interface ParserError {
-    message: string;
-    range: Range;
-    code: number;
-}
+import ts from 'typescript';
+import { Position, TextDocumentContentChangeEvent } from 'vscode-languageserver';
+import { AstroDocument, DocumentMapper, IdentityMapper } from '../../../core/documents';
+import { FrameworkExt } from '../utils';
 export interface DocumentSnapshot extends ts.IScriptSnapshot {
     version: number;
     filePath: string;
     scriptKind: ts.ScriptKind;
-    parserError: ParserError | null;
     positionAt(offset: number): Position;
     /**
      * Instantiates a source mapper.
@@ -28,7 +13,7 @@ export interface DocumentSnapshot extends ts.IScriptSnapshot {
      * it's no longer needed / the class should be cleaned up
      * in order to prevent memory leaks.
      */
-    getFragment(): Promise<DocumentFragmentSnapshot>;
+    createFragment(): Promise<SnapshotFragment>;
     /**
      * Needs to be called when source mapper
      * is no longer needed / the class should be cleaned up
@@ -40,48 +25,66 @@ export interface DocumentSnapshot extends ts.IScriptSnapshot {
      */
     getFullText(): string;
 }
-export declare const createDocumentSnapshot: (filePath: string, currentText: string | null, createDocument?: ((_filePath: string, text: string, overrideText: boolean) => Document) | undefined) => DocumentSnapshot;
-export declare class DocumentFragmentSnapshot implements Omit<DocumentSnapshot, 'getFragment' | 'destroyFragment'>, SnapshotFragment {
-    private mapper;
-    private parent;
+/**
+ * The mapper to get from original snapshot positions to generated and vice versa.
+ */
+export interface SnapshotFragment extends DocumentMapper {
+    positionAt(offset: number): Position;
+    offsetAt(position: Position): number;
+}
+/**
+ * Snapshots used for Astro files
+ */
+export declare class AstroSnapshot implements DocumentSnapshot {
+    private readonly parent;
+    private readonly text;
+    readonly scriptKind: ts.ScriptKind;
+    private fragment?;
     version: number;
-    filePath: string;
-    url: string;
-    text: string;
-    parserError: null;
-    scriptKind: ts.ScriptKind;
-    scriptInfo: null;
-    constructor(mapper: any, parent: Document);
+    constructor(parent: AstroDocument, text: string, scriptKind: ts.ScriptKind);
+    createFragment(): Promise<AstroSnapshotFragment>;
+    destroyFragment(): null;
+    get filePath(): string;
     getText(start: number, end: number): string;
     getLength(): number;
     getFullText(): string;
     getChangeRange(): undefined;
-    positionAt(offset: number): import("vscode-html-languageservice").Position;
-    getLineContainingOffset(offset: number): string;
+    positionAt(offset: number): Position;
+}
+export declare class AstroSnapshotFragment implements SnapshotFragment {
+    private readonly mapper;
+    readonly parent: AstroDocument;
+    readonly text: string;
+    private readonly url;
+    private lineOffsets;
+    constructor(mapper: DocumentMapper, parent: AstroDocument, text: string, url: string);
+    positionAt(offset: number): Position;
     offsetAt(position: Position): number;
     getOriginalPosition(pos: Position): Position;
     getGeneratedPosition(pos: Position): Position;
     isInGenerated(pos: Position): boolean;
     getURL(): string;
 }
-export declare class TypeScriptDocumentSnapshot implements DocumentSnapshot {
+/**
+ * Snapshot used for anything that is not an Astro file
+ * It's both used for .js(x)/.ts(x) files and .svelte/.vue files
+ */
+export declare class TypeScriptDocumentSnapshot extends IdentityMapper implements DocumentSnapshot, SnapshotFragment {
     version: number;
     readonly filePath: string;
     private text;
+    readonly framework?: FrameworkExt | undefined;
     scriptKind: ts.ScriptKind;
-    scriptInfo: null;
-    parserError: null;
-    url: string;
-    constructor(version: number, filePath: string, text: string);
+    private lineOffsets?;
+    constructor(version: number, filePath: string, text: string, scriptKind?: ts.ScriptKind, framework?: FrameworkExt | undefined);
     getText(start: number, end: number): string;
     getLength(): number;
     getFullText(): string;
     getChangeRange(): undefined;
-    positionAt(offset: number): import("vscode-html-languageservice").Position;
+    positionAt(offset: number): Position;
     offsetAt(position: Position): number;
-    getFragment(): Promise<DocumentFragmentSnapshot>;
-    getOriginalPosition(pos: Position): Position;
+    createFragment(): Promise<this>;
     destroyFragment(): void;
-    getLineContainingOffset(offset: number): string;
     update(changes: TextDocumentContentChangeEvent[]): void;
+    private getLineOffsets;
 }

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptDocumentSnapshot = exports.AstroSnapshotFragment = exports.AstroSnapshot = void 0;
+const documents_1 = require("../../../core/documents");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+/**
+ * Snapshots used for Astro files
+ */
+class AstroSnapshot {
+    constructor(parent, text, scriptKind) {
+        this.parent = parent;
+        this.text = text;
+        this.scriptKind = scriptKind;
+        this.version = this.parent.version;
+    }
+    async createFragment() {
+        if (!this.fragment) {
+            const uri = (0, utils_1.pathToUrl)(this.filePath);
+            this.fragment = new AstroSnapshotFragment(new documents_1.IdentityMapper(uri), this.parent, this.text, uri);
+        }
+        return this.fragment;
+    }
+    destroyFragment() {
+        return null;
+    }
+    get filePath() {
+        return this.parent.getFilePath() || '';
+    }
+    getText(start, end) {
+        return this.text.substring(start, end);
+    }
+    getLength() {
+        return this.text.length;
+    }
+    getFullText() {
+        return this.text;
+    }
+    getChangeRange() {
+        return undefined;
+    }
+    positionAt(offset) {
+        return (0, documents_1.positionAt)(offset, this.text);
+    }
+}
+exports.AstroSnapshot = AstroSnapshot;
+class AstroSnapshotFragment {
+    constructor(mapper, parent, text, url) {
+        this.mapper = mapper;
+        this.parent = parent;
+        this.text = text;
+        this.url = url;
+        this.lineOffsets = (0, documents_1.getLineOffsets)(this.text);
+    }
+    positionAt(offset) {
+        return (0, documents_1.positionAt)(offset, this.text, this.lineOffsets);
+    }
+    offsetAt(position) {
+        return (0, documents_1.offsetAt)(position, this.text, this.lineOffsets);
+    }
+    getOriginalPosition(pos) {
+        return this.mapper.getOriginalPosition(pos);
+    }
+    getGeneratedPosition(pos) {
+        return this.mapper.getGeneratedPosition(pos);
+    }
+    isInGenerated(pos) {
+        throw new Error('Method not implemented.');
+    }
+    getURL() {
+        return this.url;
+    }
+}
+exports.AstroSnapshotFragment = AstroSnapshotFragment;
+/**
+ * Snapshot used for anything that is not an Astro file
+ * It's both used for .js(x)/.ts(x) files and .svelte/.vue files
+ */
+class TypeScriptDocumentSnapshot extends documents_1.IdentityMapper {
+    constructor(version, filePath, text, scriptKind, framework) {
+        super((0, utils_1.pathToUrl)(filePath));
+        this.version = version;
+        this.filePath = filePath;
+        this.text = text;
+        this.framework = framework;
+        scriptKind ? (this.scriptKind = scriptKind) : (this.scriptKind = (0, utils_2.getScriptKindFromFileName)(filePath));
+    }
+    getText(start, end) {
+        return this.text.substring(start, end);
+    }
+    getLength() {
+        return this.text.length;
+    }
+    getFullText() {
+        return this.text;
+    }
+    getChangeRange() {
+        return undefined;
+    }
+    positionAt(offset) {
+        return (0, documents_1.positionAt)(offset, this.text, this.getLineOffsets());
+    }
+    offsetAt(position) {
+        return (0, documents_1.offsetAt)(position, this.text, this.getLineOffsets());
+    }
+    async createFragment() {
+        return this;
+    }
+    destroyFragment() {
+        // nothing to clean up
+    }
+    update(changes) {
+        for (const change of changes) {
+            let start = 0;
+            let end = 0;
+            if ('range' in change) {
+                start = this.offsetAt(change.range.start);
+                end = this.offsetAt(change.range.end);
+            }
+            else {
+                end = this.getLength();
+            }
+            this.text = this.text.slice(0, start) + change.text + this.text.slice(end);
+        }
+        this.version++;
+        this.lineOffsets = undefined;
+    }
+    getLineOffsets() {
+        if (!this.lineOffsets) {
+            this.lineOffsets = (0, documents_1.getLineOffsets)(this.text);
+        }
+        return this.lineOffsets;
+    }
+}
+exports.TypeScriptDocumentSnapshot = TypeScriptDocumentSnapshot;

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

@@ -0,0 +1,42 @@
+import { DocumentSnapshot, TypeScriptDocumentSnapshot } from './DocumentSnapshot';
+import { TextDocumentContentChangeEvent } from 'vscode-languageserver';
+/**
+ * Every snapshot corresponds to a unique file on disk.
+ * A snapshot can be part of multiple projects, but for a given file path
+ * there can be only one snapshot.
+ */
+export declare class GlobalSnapshotManager {
+    private emitter;
+    private documents;
+    get(fileName: string): DocumentSnapshot | undefined;
+    set(fileName: string, document: DocumentSnapshot): void;
+    delete(fileName: string): void;
+    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): TypeScriptDocumentSnapshot | undefined;
+    onChange(listener: (fileName: string, newDocument: DocumentSnapshot | undefined) => void): void;
+}
+export interface TsFilesSpec {
+    include?: readonly string[];
+    exclude?: readonly string[];
+}
+/**
+ * Should only be used by `language-service.ts`
+ */
+export declare class SnapshotManager {
+    private globalSnapshotsManager;
+    private projectFiles;
+    private fileSpec;
+    private workspaceRoot;
+    private documents;
+    private lastLogged;
+    private readonly watchExtensions;
+    constructor(globalSnapshotsManager: GlobalSnapshotManager, projectFiles: string[], fileSpec: TsFilesSpec, workspaceRoot: string);
+    updateProjectFiles(): void;
+    updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): void;
+    has(fileName: string): boolean;
+    set(fileName: string, snapshot: DocumentSnapshot): void;
+    get(fileName: string): DocumentSnapshot | undefined;
+    delete(fileName: string): void;
+    getFileNames(): string[];
+    getProjectFileNames(): string[];
+    private logStatistics;
+}

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

@@ -0,0 +1,197 @@
+"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.SnapshotManager = exports.GlobalSnapshotManager = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const DocumentSnapshot_1 = require("./DocumentSnapshot");
+const utils_1 = require("../../../utils");
+const events_1 = require("events");
+const DocumentSnapshotUtils = __importStar(require("./utils"));
+const utils_2 = require("../utils");
+/**
+ * Every snapshot corresponds to a unique file on disk.
+ * A snapshot can be part of multiple projects, but for a given file path
+ * there can be only one snapshot.
+ */
+class GlobalSnapshotManager {
+    constructor() {
+        this.emitter = new events_1.EventEmitter();
+        this.documents = new Map();
+    }
+    get(fileName) {
+        fileName = (0, utils_1.normalizePath)(fileName);
+        return this.documents.get(fileName);
+    }
+    set(fileName, document) {
+        fileName = (0, utils_1.normalizePath)(fileName);
+        const prev = this.get(fileName);
+        if (prev) {
+            prev.destroyFragment();
+        }
+        this.documents.set(fileName, document);
+        this.emitter.emit('change', fileName, document);
+    }
+    delete(fileName) {
+        fileName = (0, utils_1.normalizePath)(fileName);
+        this.documents.delete(fileName);
+        this.emitter.emit('change', fileName, undefined);
+    }
+    updateNonAstroFile(fileName, changes) {
+        fileName = (0, utils_1.normalizePath)(fileName);
+        const previousSnapshot = this.get(fileName);
+        if (changes) {
+            // We don't support incremental changes for Framework files, as they need to be rebuilt completely on every change
+            if (!(previousSnapshot instanceof DocumentSnapshot_1.TypeScriptDocumentSnapshot) || previousSnapshot.framework) {
+                return;
+            }
+            previousSnapshot.update(changes);
+            this.emitter.emit('change', fileName, previousSnapshot);
+            return previousSnapshot;
+        }
+        else {
+            const newSnapshot = DocumentSnapshotUtils.createFromNonAstroFilePath(fileName);
+            if (previousSnapshot) {
+                newSnapshot.version = previousSnapshot.version + 1;
+            }
+            else {
+                // ensure it's greater than initial version
+                // so that ts server picks up the change
+                newSnapshot.version += 1;
+            }
+            this.set(fileName, newSnapshot);
+            return newSnapshot;
+        }
+    }
+    onChange(listener) {
+        this.emitter.on('change', listener);
+    }
+}
+exports.GlobalSnapshotManager = GlobalSnapshotManager;
+/**
+ * Should only be used by `language-service.ts`
+ */
+class SnapshotManager {
+    constructor(globalSnapshotsManager, projectFiles, fileSpec, workspaceRoot) {
+        this.globalSnapshotsManager = globalSnapshotsManager;
+        this.projectFiles = projectFiles;
+        this.fileSpec = fileSpec;
+        this.workspaceRoot = workspaceRoot;
+        this.documents = new Map();
+        this.lastLogged = new Date(new Date().getTime() - 60001);
+        this.watchExtensions = [
+            typescript_1.default.Extension.Dts,
+            typescript_1.default.Extension.Js,
+            typescript_1.default.Extension.Jsx,
+            typescript_1.default.Extension.Ts,
+            typescript_1.default.Extension.Tsx,
+            typescript_1.default.Extension.Json,
+        ];
+        this.globalSnapshotsManager.onChange((fileName, document) => {
+            // Only delete/update snapshots, don't add new ones,
+            // as they could be from another TS service and this
+            // snapshot manager can't reach this file.
+            // For these, instead wait on a `get` method invocation
+            // and set them "manually" in the set/update methods.
+            if (!document) {
+                this.documents.delete(fileName);
+            }
+            else if (this.documents.has(fileName)) {
+                this.documents.set(fileName, document);
+            }
+        });
+    }
+    updateProjectFiles() {
+        const { include, exclude } = this.fileSpec;
+        // Since we default to not include anything,
+        //  just don't waste time on this
+        if ((include === null || include === void 0 ? void 0 : include.length) === 0) {
+            return;
+        }
+        const projectFiles = typescript_1.default.sys
+            .readDirectory(this.workspaceRoot, this.watchExtensions, exclude, include)
+            .map(utils_1.normalizePath);
+        this.projectFiles = Array.from(new Set([...this.projectFiles, ...projectFiles]));
+    }
+    updateNonAstroFile(fileName, changes) {
+        const snapshot = this.globalSnapshotsManager.updateNonAstroFile(fileName, changes);
+        // This isn't duplicated logic to the listener, because this could
+        // be a new snapshot which the listener wouldn't add.
+        if (snapshot) {
+            this.documents.set((0, utils_1.normalizePath)(fileName), snapshot);
+        }
+    }
+    has(fileName) {
+        fileName = (0, utils_1.normalizePath)(fileName);
+        return this.projectFiles.includes(fileName) || this.getFileNames().includes(fileName);
+    }
+    set(fileName, snapshot) {
+        this.globalSnapshotsManager.set(fileName, snapshot);
+        // This isn't duplicated logic to the listener, because this could
+        // be a new snapshot which the listener wouldn't add.
+        this.documents.set((0, utils_1.normalizePath)(fileName), snapshot);
+    }
+    get(fileName) {
+        fileName = (0, utils_1.normalizePath)(fileName);
+        let snapshot = this.documents.get(fileName);
+        if (!snapshot) {
+            snapshot = this.globalSnapshotsManager.get(fileName);
+            if (snapshot) {
+                this.documents.set(fileName, snapshot);
+            }
+        }
+        return snapshot;
+    }
+    delete(fileName) {
+        fileName = (0, utils_1.normalizePath)(fileName);
+        this.projectFiles = this.projectFiles.filter((s) => s !== fileName);
+        this.globalSnapshotsManager.delete(fileName);
+    }
+    getFileNames() {
+        return Array.from(this.documents.keys()).map((fileName) => (0, utils_2.toVirtualFilePath)(fileName));
+    }
+    getProjectFileNames() {
+        return this.projectFiles.map((file) => {
+            return (0, utils_2.toVirtualFilePath)(file);
+        });
+    }
+    logStatistics() {
+        const date = new Date();
+        // Don't use setInterval because that will keep tests running forever
+        if (date.getTime() - this.lastLogged.getTime() > 60000) {
+            this.lastLogged = date;
+            const projectFiles = this.getProjectFileNames();
+            const allFiles = Array.from(new Set([...projectFiles, ...this.getFileNames()]));
+            console.log('SnapshotManager File Statistics:\n' +
+                `Project files: ${projectFiles.length}\n` +
+                `Astro files: ${allFiles.filter((name) => name.endsWith('.astro')).length}\n` +
+                `From node_modules: ${allFiles.filter((name) => name.includes('node_modules')).length}\n` +
+                `Total: ${allFiles.length}`);
+        }
+    }
+}
+exports.SnapshotManager = SnapshotManager;

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

@@ -0,0 +1,28 @@
+import { AstroDocument } from '../../../core/documents';
+import { FrameworkExt } from '../utils';
+import { AstroSnapshot, TypeScriptDocumentSnapshot } from './DocumentSnapshot';
+export declare function createFromDocument(document: AstroDocument): AstroSnapshot;
+/**
+ * Returns an Astro or Framework or a ts/js snapshot from a file path, depending on the file contents.
+ * @param filePath path to the file
+ * @param createDocument function that is used to create a document in case it's an Astro file
+ */
+export declare function createFromFilePath(filePath: string, createDocument: (filePath: string, text: string) => AstroDocument): AstroSnapshot | TypeScriptDocumentSnapshot;
+/**
+ * Return a Framework or a TS snapshot from a file path, depending on the file contents
+ * Unlike createFromFilePath, this does not support creating an Astro snapshot
+ */
+export declare function createFromNonAstroFilePath(filePath: string): TypeScriptDocumentSnapshot;
+/**
+ * Returns a ts/js snapshot from a file path.
+ * @param filePath path to the js/ts file
+ * @param options options that apply in case it's a svelte file
+ */
+export declare function createFromTSFilePath(filePath: string): TypeScriptDocumentSnapshot;
+/**
+ * Returns an Astro snapshot from a file path.
+ * @param filePath path to the Astro file
+ * @param createDocument function that is used to create a document
+ */
+export declare function createFromAstroFilePath(filePath: string, createDocument: (filePath: string, text: string) => AstroDocument): AstroSnapshot;
+export declare function createFromFrameworkFilePath(filePath: string, framework: FrameworkExt): TypeScriptDocumentSnapshot;