@astrojs/language-server 0.9.2 → 0.12.0

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;

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

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFromFrameworkFilePath = exports.createFromAstroFilePath = exports.createFromTSFilePath = exports.createFromNonAstroFilePath = exports.createFromFilePath = exports.createFromDocument = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const astro2tsx_1 = __importDefault(require("../astro2tsx"));
+const utils_1 = require("../utils");
+const DocumentSnapshot_1 = require("./DocumentSnapshot");
+const svelte_language_integration_1 = require("@astrojs/svelte-language-integration");
+// Utilities to create Snapshots from different contexts
+function createFromDocument(document) {
+    const { code } = (0, astro2tsx_1.default)(document.getText());
+    return new DocumentSnapshot_1.AstroSnapshot(document, code, typescript_1.default.ScriptKind.TSX);
+}
+exports.createFromDocument = createFromDocument;
+/**
+ * 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
+ */
+function createFromFilePath(filePath, createDocument) {
+    if ((0, utils_1.isAstroFilePath)(filePath)) {
+        return createFromAstroFilePath(filePath, createDocument);
+    }
+    else if ((0, utils_1.isFrameworkFilePath)(filePath)) {
+        const framework = (0, utils_1.getFrameworkFromFilePath)(filePath);
+        return createFromFrameworkFilePath(filePath, framework);
+    }
+    else {
+        return createFromTSFilePath(filePath);
+    }
+}
+exports.createFromFilePath = createFromFilePath;
+/**
+ * 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
+ */
+function createFromNonAstroFilePath(filePath) {
+    if ((0, utils_1.isFrameworkFilePath)(filePath)) {
+        const framework = (0, utils_1.getFrameworkFromFilePath)(filePath);
+        return createFromFrameworkFilePath(filePath, framework);
+    }
+    else {
+        return createFromTSFilePath(filePath);
+    }
+}
+exports.createFromNonAstroFilePath = createFromNonAstroFilePath;
+/**
+ * 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
+ */
+function createFromTSFilePath(filePath) {
+    var _a;
+    const originalText = (_a = typescript_1.default.sys.readFile(filePath)) !== null && _a !== void 0 ? _a : '';
+    return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(0, filePath, originalText);
+}
+exports.createFromTSFilePath = createFromTSFilePath;
+/**
+ * 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
+ */
+function createFromAstroFilePath(filePath, createDocument) {
+    var _a;
+    const originalText = (_a = typescript_1.default.sys.readFile(filePath)) !== null && _a !== void 0 ? _a : '';
+    return createFromDocument(createDocument(filePath, originalText));
+}
+exports.createFromAstroFilePath = createFromAstroFilePath;
+function createFromFrameworkFilePath(filePath, framework) {
+    var _a;
+    const originalText = (_a = typescript_1.default.sys.readFile(filePath)) !== null && _a !== void 0 ? _a : '';
+    let code = '';
+    if (framework === 'svelte') {
+        code = (0, svelte_language_integration_1.toTSX)(originalText);
+    }
+    else {
+        code = 'export default function() {}';
+    }
+    return new DocumentSnapshot_1.TypeScriptDocumentSnapshot(0, filePath, code, typescript_1.default.ScriptKind.TSX);
+}
+exports.createFromFrameworkFilePath = createFromFrameworkFilePath;

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

@@ -1,11 +1,13 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 import { CompletionItemKind, DiagnosticSeverity, Position, Range } from 'vscode-languageserver';
-import { SnapshotFragment } from './DocumentSnapshot';
+import { SnapshotFragment } from './snapshots/DocumentSnapshot';
 export declare function scriptElementKindToCompletionItemKind(kind: ts.ScriptElementKind): CompletionItemKind;
 export declare function getCommitCharactersForScriptElement(kind: ts.ScriptElementKind): string[] | undefined;
-export declare function mapSeverity(category: ts.DiagnosticCategory): DiagnosticSeverity;
-export declare function getScriptKindFromFileName(fileName: string): ts.ScriptKind;
 export declare function getExtensionFromScriptKind(kind: ts.ScriptKind | undefined): ts.Extension;
+export declare function findTsConfigPath(fileName: string, rootUris: string[]): string;
+export declare function isSubPath(uri: string, possibleSubPath: string): boolean;
+export declare function getScriptKindFromFileName(fileName: string): ts.ScriptKind;
+export declare function mapSeverity(category: ts.DiagnosticCategory): DiagnosticSeverity;
 export declare function convertRange(document: {
     positionAt: (offset: number) => Position;
 }, range: {
@@ -13,22 +15,19 @@ export declare function convertRange(document: {
     length?: number;
 }): Range;
 export declare function convertToLocationRange(defDoc: SnapshotFragment, textSpan: ts.TextSpan): Range;
-declare type FrameworkExt = 'astro' | 'vue' | 'jsx' | 'tsx' | 'svelte';
+export declare type FrameworkExt = 'astro' | 'vue' | 'jsx' | 'tsx' | 'svelte';
 declare type FrameworkVirtualExt = 'ts' | 'tsx';
+export declare function getFrameworkFromFilePath(filePath: string): FrameworkExt;
 export declare function isVirtualFrameworkFilePath(ext: FrameworkExt, virtualExt: FrameworkVirtualExt, filePath: string): boolean;
 export declare function isAstroFilePath(filePath: string): boolean;
+export declare function isFrameworkFilePath(filePath: string): boolean;
 export declare function isVirtualAstroFilePath(filePath: string): boolean;
 export declare function isVirtualVueFilePath(filePath: string): boolean;
-export declare function isVirtualJsxFilePath(filePath: string): boolean;
 export declare function isVirtualSvelteFilePath(filePath: string): boolean;
 export declare function isVirtualFilePath(filePath: string): boolean;
 export declare function toVirtualAstroFilePath(filePath: string): string;
+export declare function toVirtualFilePath(filePath: string): string;
 export declare function toRealAstroFilePath(filePath: string): string;
 export declare function ensureRealAstroFilePath(filePath: string): string;
 export declare function ensureRealFilePath(filePath: string): string;
-export declare function findTsConfigPath(fileName: string, rootUris: string[]): string;
-/**  */
-export declare function isSubPath(uri: string, possibleSubPath: string): boolean;
-/** Substitutes */
-export declare function substituteWithWhitespace(result: string, start: number, end: number, oldContent: string, before: string, after: string): string;
 export {};