@astrojs/ts-plugin 1.0.10 → 1.1.1

package/README.md

@@ -1,3 +1,27 @@
 # @astrojs/ts-plugin
 
-Work in progress TypeScript plugin adding support for `.astro` imports in `.ts` files
+> Using the Astro VS Code extension? This plugin is automatically installed and configured for you.
+
+TypeScript plugin adding support for `.astro` imports in `.ts` files. This plugin also adds support for renaming symbols and finding references across `.ts` and `.astro` files.
+
+## Installation
+
+```bash
+npm install --save-dev @astrojs/ts-plugin
+```
+
+## Usage
+
+Add the plugin to your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "name": "@astrojs/ts-plugin"
+      }
+    ]
+  }
+}
+```

package/dist/astro2tsx.d.ts

@@ -1,2 +1,15 @@
-import type { TSXResult } from '@astrojs/compiler/types';
-export declare function astro2tsx(content: string, fileName: string): TSXResult;
+import { VirtualFile } from '@volar/language-core';
+export declare function astro2tsx(input: string, fileName: string, ts: typeof import('typescript/lib/tsserverlibrary.js')): {
+    virtualFile: VirtualFile;
+    diagnostics: import("@astrojs/compiler").DiagnosticMessage[] | {
+        code: 1000;
+        location: {
+            file: string;
+            line: number;
+            column: number;
+            length: number;
+        };
+        severity: 1;
+        text: string;
+    }[];
+};

package/dist/astro2tsx.js

@@ -1,26 +1,142 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.astro2tsx = void 0;
 const sync_1 = require("@astrojs/compiler/sync");
-function astro2tsx(content, fileName) {
+const sourcemap_codec_1 = require("@jridgewell/sourcemap-codec");
+const language_core_1 = require("@volar/language-core");
+const node_path_1 = __importDefault(require("node:path"));
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+function safeConvertToTSX(content, options) {
     try {
-        const tsx = (0, sync_1.convertToTSX)(content, { filename: fileName });
+        const tsx = (0, sync_1.convertToTSX)(content, { filename: options.filename });
         return tsx;
     }
     catch (e) {
-        console.error(`There was an error transforming ${fileName} to TSX. An empty file will be returned instead. Please create an issue: https://github.com/withastro/language-tools/issues\nError: ${e}.`);
+        console.error(`There was an error transforming ${options.filename} to TSX. An empty file will be returned instead. Please create an issue: https://github.com/withastro/language-tools/issues\nError: ${e}.`);
         return {
             code: '',
             map: {
-                file: fileName,
+                file: options.filename ?? '',
                 sources: [],
                 sourcesContent: [],
                 names: [],
                 mappings: '',
                 version: 0,
             },
-            diagnostics: [],
+            diagnostics: [
+                {
+                    code: 1000,
+                    location: { file: options.filename, line: 1, column: 1, length: content.length },
+                    severity: 1,
+                    text: `The Astro compiler encountered an unknown error while parsing this file. Please create an issue with your code and the error shown in the server's logs: https://github.com/withastro/language-tools/issues`,
+                },
+            ],
         };
     }
 }
+function astro2tsx(input, fileName, ts) {
+    const tsx = safeConvertToTSX(input, { filename: fileName });
+    return {
+        virtualFile: getVirtualFileTSX(input, tsx, fileName, ts),
+        diagnostics: tsx.diagnostics,
+    };
+}
 exports.astro2tsx = astro2tsx;
+function getVirtualFileTSX(input, tsx, fileName, ts) {
+    tsx.code = patchTSX(tsx.code, fileName);
+    const v3Mappings = (0, sourcemap_codec_1.decode)(tsx.map.mappings);
+    const sourcedDoc = vscode_languageserver_textdocument_1.TextDocument.create(fileName, 'astro', 0, input);
+    const genDoc = vscode_languageserver_textdocument_1.TextDocument.create(fileName + '.tsx', 'typescriptreact', 0, tsx.code);
+    const mappings = [];
+    let current;
+    for (let genLine = 0; genLine < v3Mappings.length; genLine++) {
+        for (const segment of v3Mappings[genLine]) {
+            const genCharacter = segment[0];
+            const genOffset = genDoc.offsetAt({ line: genLine, character: genCharacter });
+            if (current) {
+                let length = genOffset - current.genOffset;
+                const sourceText = input.substring(current.sourceOffset, current.sourceOffset + length);
+                const genText = tsx.code.substring(current.genOffset, current.genOffset + length);
+                if (sourceText !== genText) {
+                    length = 0;
+                    for (let i = 0; i < genOffset - current.genOffset; i++) {
+                        if (sourceText[i] === genText[i]) {
+                            length = i + 1;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+                if (length > 0) {
+                    const lastMapping = mappings.length ? mappings[mappings.length - 1] : undefined;
+                    if (lastMapping &&
+                        lastMapping.generatedRange[1] === current.genOffset &&
+                        lastMapping.sourceRange[1] === current.sourceOffset) {
+                        lastMapping.generatedRange[1] = current.genOffset + length;
+                        lastMapping.sourceRange[1] = current.sourceOffset + length;
+                    }
+                    else {
+                        mappings.push({
+                            sourceRange: [current.sourceOffset, current.sourceOffset + length],
+                            generatedRange: [current.genOffset, current.genOffset + length],
+                            data: language_core_1.FileRangeCapabilities.full,
+                        });
+                    }
+                }
+                current = undefined;
+            }
+            if (segment[2] !== undefined && segment[3] !== undefined) {
+                const sourceOffset = sourcedDoc.offsetAt({ line: segment[2], character: segment[3] });
+                current = {
+                    genOffset,
+                    sourceOffset,
+                };
+            }
+        }
+    }
+    const ast = ts.createSourceFile('/a.tsx', tsx.code, ts.ScriptTarget.ESNext);
+    if (ast.statements[0]) {
+        mappings.push({
+            sourceRange: [0, input.length],
+            generatedRange: [ast.statements[0].getStart(ast), tsx.code.length],
+            data: {},
+        });
+    }
+    return {
+        fileName: fileName + '.tsx',
+        kind: language_core_1.FileKind.TypeScriptHostFile,
+        capabilities: {
+            codeAction: true,
+            documentFormatting: false,
+            diagnostic: true,
+            documentSymbol: true,
+            inlayHint: true,
+            foldingRange: true,
+        },
+        codegenStacks: [],
+        snapshot: {
+            getText: (start, end) => tsx.code.substring(start, end),
+            getLength: () => tsx.code.length,
+            getChangeRange: () => undefined,
+        },
+        mappings: mappings,
+        embeddedFiles: [],
+    };
+}
+function patchTSX(code, fileName) {
+    const basename = node_path_1.default.basename(fileName, node_path_1.default.extname(fileName));
+    const isDynamic = basename.startsWith('[') && basename.endsWith(']');
+    return code.replace(/\b(\S*)__AstroComponent_/gm, (fullMatch, m1) => {
+        // If we don't have a match here, it usually means the file has a weird name that couldn't be expressed with valid identifier characters
+        if (!m1) {
+            if (basename === '404')
+                return 'FourOhFour';
+            return fullMatch;
+        }
+        return isDynamic ? `_${m1}_` : m1[0].toUpperCase() + m1.slice(1);
+    });
+}

package/dist/index.d.ts

@@ -1,8 +1,3 @@
 import type ts from 'typescript/lib/tsserverlibrary';
-declare function init(modules: {
-    typescript: typeof import('typescript/lib/tsserverlibrary');
-}): {
-    create: (info: ts.server.PluginCreateInfo) => ts.LanguageService;
-    getExternalFiles: (project: ts.server.ConfiguredProject) => string[];
-};
+declare const init: ts.server.PluginModuleFactory;
 export = init;

package/dist/index.js

@@ -1,50 +1,24 @@
 "use strict";
-const astro_snapshots_js_1 = require("./astro-snapshots.js");
-const index_js_1 = require("./language-service/index.js");
-const logger_js_1 = require("./logger.js");
-const module_loader_js_1 = require("./module-loader.js");
-const project_astro_files_js_1 = require("./project-astro-files.js");
-const utils_js_1 = require("./utils.js");
-function init(modules) {
-    const ts = modules.typescript;
-    function create(info) {
-        const logger = new logger_js_1.Logger(info.project.projectService.logger);
-        const parsedCommandLine = info.languageServiceHost.getParsedCommandLine?.((0, utils_js_1.getConfigPathForProject)(info.project));
-        if (!isAstroProject(info.project, parsedCommandLine)) {
-            logger.log('Detected that this is not an Astro project, abort patching TypeScript');
+const language_core_1 = require("@volar/language-core");
+const typescript_1 = require("@volar/typescript");
+const language_js_1 = require("./language.js");
+const externalFiles = new WeakMap();
+const init = (modules) => {
+    const { typescript: ts } = modules;
+    const pluginModule = {
+        create(info) {
+            const virtualFiles = (0, language_core_1.createVirtualFiles)([(0, language_js_1.getLanguageModule)(ts)]);
+            (0, typescript_1.decorateLanguageService)(virtualFiles, info.languageService, true);
+            (0, typescript_1.decorateLanguageServiceHost)(virtualFiles, info.languageServiceHost, ts, ['.astro']);
             return info.languageService;
-        }
-        if ((0, index_js_1.isPatched)(info.languageService)) {
-            return info.languageService;
-        }
-        logger.log('Starting Astro plugin');
-        const snapshotManager = new astro_snapshots_js_1.AstroSnapshotManager(modules.typescript, info.project.projectService, logger);
-        if (parsedCommandLine) {
-            new project_astro_files_js_1.ProjectAstroFilesManager(modules.typescript, info.project, info.serverHost, snapshotManager, parsedCommandLine);
-        }
-        (0, module_loader_js_1.patchModuleLoader)(logger, snapshotManager, modules.typescript, info.languageServiceHost, info.project);
-        return (0, index_js_1.decorateLanguageService)(info.languageService, snapshotManager, ts, logger);
-    }
-    function getExternalFiles(project) {
-        return project_astro_files_js_1.ProjectAstroFilesManager.getInstance(project.getProjectName())?.getFiles() ?? [];
-    }
-    function isAstroProject(project, parsedCommandLine) {
-        if (parsedCommandLine) {
-            const astroFiles = (0, utils_js_1.readProjectAstroFilesFromFs)(ts, project, parsedCommandLine);
-            if (astroFiles.length > 0)
-                return true;
-        }
-        try {
-            const compilerOptions = project.getCompilerOptions();
-            const hasAstroInstalled = typeof compilerOptions.configFilePath !== 'string' ||
-                require.resolve('astro', { paths: [compilerOptions.configFilePath] });
-            return hasAstroInstalled;
-        }
-        catch (e) {
-            project.projectService.logger.info(e);
-            return false;
-        }
-    }
-    return { create, getExternalFiles };
-}
+        },
+        getExternalFiles(project) {
+            if (!externalFiles.has(project)) {
+                externalFiles.set(project, (0, typescript_1.getExternalFiles)(ts, project, ['.astro']));
+            }
+            return externalFiles.get(project);
+        },
+    };
+    return pluginModule;
+};
 module.exports = init;

package/dist/language.d.ts

@@ -0,0 +1,17 @@
+import { FileCapabilities, FileKind, type Language, type VirtualFile } from '@volar/language-core';
+import type ts from 'typescript/lib/tsserverlibrary.js';
+export declare function getLanguageModule(ts: typeof import('typescript/lib/tsserverlibrary.js')): Language<AstroFile>;
+export declare class AstroFile implements VirtualFile {
+    sourceFileName: string;
+    snapshot: ts.IScriptSnapshot;
+    private readonly ts;
+    kind: FileKind;
+    capabilities: FileCapabilities;
+    fileName: string;
+    mappings: VirtualFile['mappings'];
+    embeddedFiles: VirtualFile['embeddedFiles'];
+    codegenStacks: never[];
+    constructor(sourceFileName: string, snapshot: ts.IScriptSnapshot, ts: typeof import('typescript/lib/tsserverlibrary.js'));
+    update(newSnapshot: ts.IScriptSnapshot): void;
+    onSnapshotUpdated(): void;
+}

package/dist/language.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstroFile = exports.getLanguageModule = void 0;
+const language_core_1 = require("@volar/language-core");
+const astro2tsx_js_1 = require("./astro2tsx.js");
+function getLanguageModule(ts) {
+    return {
+        createVirtualFile(fileName, snapshot) {
+            if (fileName.endsWith('.astro')) {
+                return new AstroFile(fileName, snapshot, ts);
+            }
+        },
+        updateVirtualFile(astroFile, snapshot) {
+            astroFile.update(snapshot);
+        },
+    };
+}
+exports.getLanguageModule = getLanguageModule;
+class AstroFile {
+    constructor(sourceFileName, snapshot, ts) {
+        this.sourceFileName = sourceFileName;
+        this.snapshot = snapshot;
+        this.ts = ts;
+        this.kind = language_core_1.FileKind.TextFile;
+        this.capabilities = language_core_1.FileCapabilities.full;
+        this.codegenStacks = [];
+        this.fileName = sourceFileName;
+        this.onSnapshotUpdated();
+    }
+    update(newSnapshot) {
+        this.snapshot = newSnapshot;
+        this.onSnapshotUpdated();
+    }
+    onSnapshotUpdated() {
+        this.mappings = [
+            {
+                sourceRange: [0, this.snapshot.getLength()],
+                generatedRange: [0, this.snapshot.getLength()],
+                data: language_core_1.FileRangeCapabilities.full,
+            },
+        ];
+        this.embeddedFiles = [];
+        const tsx = (0, astro2tsx_js_1.astro2tsx)(this.snapshot.getText(0, this.snapshot.getLength()), this.fileName, this.ts);
+        this.embeddedFiles.push(tsx.virtualFile);
+    }
+}
+exports.AstroFile = AstroFile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/ts-plugin",
-  "version": "1.0.10",
+  "version": "1.1.1",
   "description": "A TypeScript Plugin providing Astro intellisense",
   "main": "dist/index.js",
   "type": "commonjs",
@@ -22,8 +22,11 @@
   "author": "withastro",
   "license": "MIT",
   "dependencies": {
-    "@astrojs/compiler": "^1.5.1",
-    "@jridgewell/trace-mapping": "^0.3.18"
+    "@volar/language-core": "~1.10.0",
+    "@volar/typescript": "~1.10.0",
+    "@astrojs/compiler": "1.5.7",
+    "@jridgewell/sourcemap-codec": "^1.4.15",
+    "vscode-languageserver-textdocument": "^1.0.8"
   },
   "devDependencies": {
     "@types/chai": "^4.3.5",

package/dist/astro-snapshots.d.ts

@@ -1,44 +0,0 @@
-import { TraceMap } from '@jridgewell/trace-mapping';
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { Logger } from './logger.js';
-export declare class AstroSnapshot {
-    private typescript;
-    private fileName;
-    private astroCode;
-    private traceMap;
-    private logger;
-    private scriptInfo?;
-    private lineOffsets?;
-    private convertInternalCodePositions;
-    constructor(typescript: typeof ts, fileName: string, astroCode: string, traceMap: TraceMap, logger: Logger);
-    update(astroCode: string, traceMap: TraceMap): void;
-    getOriginalTextSpan(textSpan: ts.TextSpan): ts.TextSpan | null;
-    getOriginalOffset(generatedOffset: number): number;
-    setAndPatchScriptInfo(scriptInfo: ts.server.ScriptInfo): void;
-    /**
-     * Get the line and character based on the offset
-     * @param offset The index of the position
-     */
-    positionAt(offset: number): ts.LineAndCharacter;
-    /**
-     * Get the index of the line and character position
-     * @param position Line and character position
-     */
-    offsetAt(position: ts.LineAndCharacter): number;
-    private getLineOffsets;
-    private clamp;
-    private log;
-    private debug;
-    private toggleMappingMode;
-    private getText;
-}
-export declare class AstroSnapshotManager {
-    private typescript;
-    private projectService;
-    private logger;
-    private snapshots;
-    constructor(typescript: typeof ts, projectService: ts.server.ProjectService, logger: Logger);
-    get(fileName: string): AstroSnapshot | undefined;
-    create(fileName: string): AstroSnapshot | undefined;
-    private patchProjectServiceReadFile;
-}

package/dist/astro-snapshots.js

@@ -1,234 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AstroSnapshotManager = exports.AstroSnapshot = void 0;
-const trace_mapping_1 = require("@jridgewell/trace-mapping");
-const astro2tsx_js_1 = require("./astro2tsx.js");
-const utils_js_1 = require("./utils.js");
-class AstroSnapshot {
-    constructor(typescript, fileName, astroCode, traceMap, logger) {
-        this.typescript = typescript;
-        this.fileName = fileName;
-        this.astroCode = astroCode;
-        this.traceMap = traceMap;
-        this.logger = logger;
-        this.convertInternalCodePositions = false;
-    }
-    update(astroCode, traceMap) {
-        this.astroCode = astroCode;
-        this.traceMap = traceMap;
-        this.lineOffsets = undefined;
-        this.log('Updated Snapshot');
-    }
-    getOriginalTextSpan(textSpan) {
-        const start = this.getOriginalOffset(textSpan.start);
-        if (start === -1) {
-            return null;
-        }
-        // Assumption: We don't change identifiers itself, so we don't change ranges.
-        return {
-            start,
-            length: textSpan.length,
-        };
-    }
-    getOriginalOffset(generatedOffset) {
-        if (!this.scriptInfo) {
-            return generatedOffset;
-        }
-        this.toggleMappingMode(true);
-        const lineOffset = this.scriptInfo.positionToLineOffset(generatedOffset);
-        this.debug('try convert offset', generatedOffset, '/', lineOffset);
-        const original = (0, trace_mapping_1.originalPositionFor)(this.traceMap, {
-            line: lineOffset.line,
-            column: lineOffset.offset,
-        });
-        this.toggleMappingMode(false);
-        if (!original.line) {
-            return -1;
-        }
-        const originalOffset = this.scriptInfo.lineOffsetToPosition(original.line, original.column);
-        this.debug('converted offset to', original, '/', originalOffset);
-        return originalOffset;
-    }
-    setAndPatchScriptInfo(scriptInfo) {
-        // @ts-expect-error
-        scriptInfo.scriptKind = this.typescript.ScriptKind.TSX;
-        const positionToLineOffset = scriptInfo.positionToLineOffset.bind(scriptInfo);
-        scriptInfo.positionToLineOffset = (position) => {
-            if (this.convertInternalCodePositions) {
-                const lineOffset = positionToLineOffset(position);
-                this.debug('positionToLineOffset for generated code', position, lineOffset);
-                return lineOffset;
-            }
-            const lineOffset = this.positionAt(position);
-            this.debug('positionToLineOffset for original code', position, lineOffset);
-            return { line: lineOffset.line + 1, offset: lineOffset.character + 1 };
-        };
-        const lineOffsetToPosition = scriptInfo.lineOffsetToPosition.bind(scriptInfo);
-        scriptInfo.lineOffsetToPosition = (line, offset) => {
-            if (this.convertInternalCodePositions) {
-                const position = lineOffsetToPosition(line, offset);
-                this.debug('lineOffsetToPosition for generated code', { line, offset }, position);
-                return position;
-            }
-            const position = this.offsetAt({ line: line - 1, character: offset - 1 });
-            this.debug('lineOffsetToPosition for original code', { line, offset }, position);
-            return position;
-        };
-        this.scriptInfo = scriptInfo;
-        this.log('patched scriptInfo');
-    }
-    /**
-     * Get the line and character based on the offset
-     * @param offset The index of the position
-     */
-    positionAt(offset) {
-        offset = this.clamp(offset, 0, this.astroCode.length);
-        const lineOffsets = this.getLineOffsets();
-        let low = 0;
-        let high = lineOffsets.length;
-        if (high === 0) {
-            return { line: 0, character: offset };
-        }
-        while (low < high) {
-            const mid = Math.floor((low + high) / 2);
-            if (lineOffsets[mid] > offset) {
-                high = mid;
-            }
-            else {
-                low = mid + 1;
-            }
-        }
-        // low is the least x for which the line offset is larger than the current offset
-        // or array.length if no line offset is larger than the current offset
-        const line = low - 1;
-        return { line, character: offset - lineOffsets[line] };
-    }
-    /**
-     * Get the index of the line and character position
-     * @param position Line and character position
-     */
-    offsetAt(position) {
-        const lineOffsets = this.getLineOffsets();
-        if (position.line >= lineOffsets.length) {
-            return this.astroCode.length;
-        }
-        else if (position.line < 0) {
-            return 0;
-        }
-        const lineOffset = lineOffsets[position.line];
-        const nextLineOffset = position.line + 1 < lineOffsets.length
-            ? lineOffsets[position.line + 1]
-            : this.astroCode.length;
-        return this.clamp(nextLineOffset, lineOffset, lineOffset + position.character);
-    }
-    getLineOffsets() {
-        if (this.lineOffsets) {
-            return this.lineOffsets;
-        }
-        const lineOffsets = [];
-        const text = this.astroCode;
-        let isLineStart = true;
-        for (let i = 0; i < text.length; i++) {
-            if (isLineStart) {
-                lineOffsets.push(i);
-                isLineStart = false;
-            }
-            const ch = text.charAt(i);
-            isLineStart = ch === '\r' || ch === '\n';
-            if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {
-                i++;
-            }
-        }
-        if (isLineStart && text.length > 0) {
-            lineOffsets.push(text.length);
-        }
-        this.lineOffsets = lineOffsets;
-        return lineOffsets;
-    }
-    clamp(num, min, max) {
-        return Math.max(min, Math.min(max, num));
-    }
-    log(...args) {
-        this.logger.log('AstroSnapshot:', this.fileName, '-', ...args);
-    }
-    debug(...args) {
-        this.logger.debug('AstroSnapshot:', this.fileName, '-', ...args);
-    }
-    toggleMappingMode(convertInternalCodePositions) {
-        this.convertInternalCodePositions = convertInternalCodePositions;
-    }
-    getText() {
-        const snapshot = this.scriptInfo?.getSnapshot();
-        if (!snapshot) {
-            return '';
-        }
-        return snapshot.getText(0, snapshot.getLength());
-    }
-}
-exports.AstroSnapshot = AstroSnapshot;
-class AstroSnapshotManager {
-    constructor(typescript, projectService, logger) {
-        this.typescript = typescript;
-        this.projectService = projectService;
-        this.logger = logger;
-        this.snapshots = new Map();
-        this.patchProjectServiceReadFile();
-    }
-    get(fileName) {
-        return this.snapshots.get(fileName);
-    }
-    create(fileName) {
-        if (this.snapshots.has(fileName)) {
-            return this.snapshots.get(fileName);
-        }
-        // This will trigger projectService.host.readFile which is patched below
-        const scriptInfo = this.projectService.getOrCreateScriptInfoForNormalizedPath(this.typescript.server.toNormalizedPath(fileName), false);
-        if (!scriptInfo) {
-            this.logger.log('Was not able get snapshot for', fileName);
-            return;
-        }
-        try {
-            scriptInfo.getSnapshot(); // needed to trigger readFile
-        }
-        catch (e) {
-            this.logger.log('Loading Snapshot failed', fileName);
-        }
-        const snapshot = this.snapshots.get(fileName);
-        if (!snapshot) {
-            this.logger.log('Astro snapshot was not found after trying to load script snapshot for', fileName);
-            return; // should never get here
-        }
-        snapshot.setAndPatchScriptInfo(scriptInfo);
-        this.snapshots.set(fileName, snapshot);
-        return snapshot;
-    }
-    patchProjectServiceReadFile() {
-        const readFile = this.projectService.host.readFile;
-        this.projectService.host.readFile = (path) => {
-            if ((0, utils_js_1.isAstroFilePath)(path)) {
-                this.logger.debug('Read Astro file:', path);
-                const astroCode = readFile(path) || '';
-                try {
-                    const result = (0, astro2tsx_js_1.astro2tsx)(astroCode, path);
-                    const existingSnapshot = this.snapshots.get(path);
-                    if (existingSnapshot) {
-                        existingSnapshot.update(astroCode, new trace_mapping_1.TraceMap(result.map));
-                    }
-                    else {
-                        this.snapshots.set(path, new AstroSnapshot(this.typescript, path, astroCode, new trace_mapping_1.TraceMap(result.map), this.logger));
-                    }
-                    this.logger.log('Successfully read Astro file contents of', path);
-                    return result.code;
-                }
-                catch (e) {
-                    this.logger.log('Error loading Astro file:', path);
-                    this.logger.debug('Error:', e);
-                }
-            }
-            else {
-                return readFile(path);
-            }
-        };
-    }
-}
-exports.AstroSnapshotManager = AstroSnapshotManager;

package/dist/astro-sys.d.ts

@@ -1,6 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { Logger } from './logger.js';
-/**
- * This should only be accessed by TS astro module resolution.
- */
-export declare function createAstroSys(logger: Logger, typescript: typeof import('typescript/lib/tsserverlibrary')): ts.System;