@astrojs/ts-plugin 1.0.9 → 1.0.10

package/dist/language-service/line-column-offset.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateLineColumnOffset = void 0;
+const utils_1 = require("../utils");
+function decorateLineColumnOffset(ls, snapshotManager) {
+    if (!ls.toLineColumnOffset) {
+        return;
+    }
+    // We need to patch this because (according to source, only) getDefinition uses this
+    const toLineColumnOffset = ls.toLineColumnOffset;
+    ls.toLineColumnOffset = (fileName, position) => {
+        if ((0, utils_1.isAstroFilePath)(fileName)) {
+            const snapshot = snapshotManager.get(fileName);
+            if (snapshot) {
+                return snapshot.positionAt(position);
+            }
+        }
+        return toLineColumnOffset(fileName, position);
+    };
+}
+exports.decorateLineColumnOffset = decorateLineColumnOffset;

package/dist/language-service/rename.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateRename = void 0;
+const utils_js_1 = require("../utils.js");
+function decorateRename(ls, snapshotManager, logger) {
+    const findRenameLocations = ls.findRenameLocations;
+    ls.findRenameLocations = (fileName, position, findInStrings, findInComments, preferences) => {
+        const renameLocations = findRenameLocations(fileName, position, findInStrings, findInComments, preferences);
+        return renameLocations
+            ?.map((renameLocation) => {
+            const snapshot = snapshotManager.get(renameLocation.fileName);
+            if (!(0, utils_js_1.isAstroFilePath)(renameLocation.fileName) || !snapshot) {
+                return renameLocation;
+            }
+            // TODO more needed to filter invalid locations, see RenameProvider
+            const textSpan = snapshot.getOriginalTextSpan(renameLocation.textSpan);
+            if (!textSpan) {
+                return null;
+            }
+            const converted = {
+                ...renameLocation,
+                textSpan,
+            };
+            if (converted.contextSpan) {
+                // Not important, spare the work
+                converted.contextSpan = undefined;
+            }
+            logger.debug('Converted rename location ', converted);
+            return converted;
+        })
+            .filter(utils_js_1.isNotNullOrUndefined);
+    };
+}
+exports.decorateRename = decorateRename;

package/dist/logger.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    constructor(tsLogService, suppressNonAstroLogs = false, logDebug = false) {
+        this.tsLogService = tsLogService;
+        this.logDebug = logDebug;
+        if (suppressNonAstroLogs) {
+            const log = this.tsLogService.info.bind(this.tsLogService);
+            this.tsLogService.info = (s) => {
+                if (s.startsWith('-Astro Plugin-')) {
+                    log(s);
+                }
+            };
+        }
+    }
+    log(...args) {
+        const str = args
+            .map((arg) => {
+            if (typeof arg === 'object') {
+                try {
+                    return JSON.stringify(arg);
+                }
+                catch (e) {
+                    return '[object that cannot by stringified]';
+                }
+            }
+            return arg;
+        })
+            .join(' ');
+        this.tsLogService.info('-Astro Plugin- ' + str);
+    }
+    debug(...args) {
+        if (!this.logDebug) {
+            return;
+        }
+        this.log(...args);
+    }
+}
+exports.Logger = Logger;

package/dist/module-loader.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchModuleLoader = void 0;
+const astro_sys_js_1 = require("./astro-sys.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Caches resolved modules.
+ */
+class ModuleResolutionCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    /**
+     * Tries to get a cached module.
+     */
+    get(moduleName, containingFile) {
+        return this.cache.get(this.getKey(moduleName, containingFile));
+    }
+    /**
+     * Caches resolved module, if it is not undefined.
+     */
+    set(moduleName, containingFile, resolvedModule) {
+        if (!resolvedModule) {
+            return;
+        }
+        this.cache.set(this.getKey(moduleName, containingFile), resolvedModule);
+    }
+    /**
+     * Deletes module from cache. Call this if a file was deleted.
+     * @param resolvedModuleName full path of the module
+     */
+    delete(resolvedModuleName) {
+        this.cache.forEach((val, key) => {
+            if (val.resolvedFileName === resolvedModuleName) {
+                this.cache.delete(key);
+            }
+        });
+    }
+    getKey(moduleName, containingFile) {
+        return containingFile + ':::' + (0, utils_js_1.ensureRealAstroFilePath)(moduleName);
+    }
+}
+/**
+ * Creates a module loader than can also resolve `.astro` 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,
+ * 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.
+ */
+function patchModuleLoader(logger, snapshotManager, typescript, lsHost, project) {
+    const astroSys = (0, astro_sys_js_1.createAstroSys)(logger, typescript);
+    const moduleCache = new ModuleResolutionCache();
+    const origResolveModuleNames = lsHost.resolveModuleNames?.bind(lsHost);
+    const origResolveModuleNamLiterals = lsHost.resolveModuleNameLiterals?.bind(lsHost);
+    if (lsHost.resolveModuleNameLiterals) {
+        lsHost.resolveModuleNameLiterals = resolveModuleNameLiterals;
+    }
+    else {
+        lsHost.resolveModuleNames = resolveModuleNames;
+    }
+    const origRemoveFile = project.removeFile.bind(project);
+    project.removeFile = (info, fileExists, detachFromProject) => {
+        logger.log('File is being removed. Delete from cache: ', info.fileName);
+        moduleCache.delete(info.fileName);
+        return origRemoveFile(info, fileExists, detachFromProject);
+    };
+    // Patch readDirectory so we get completions for .astro files
+    const origReadDirectory = project.readDirectory.bind(project);
+    project.readDirectory = (path, extensions, exclude, include, depth) => {
+        const extensionsWithAstro = (extensions ?? []).concat('.astro', '.md', '.mdx');
+        return origReadDirectory(path, extensionsWithAstro, exclude, include, depth);
+    };
+    function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions) {
+        // logger.log('Resolving modules names for ' + containingFile);
+        // Try resolving all module names with the original method first.
+        // The ones that are undefined will be re-checked if they are a
+        // astro file and if so, are resolved, too. This way we can defer
+        // all module resolving logic except for astro files to TypeScript.
+        const resolved = origResolveModuleNames?.(moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions) || Array.from(Array(moduleNames.length));
+        return resolved.map((moduleName, idx) => {
+            const fileName = moduleNames[idx];
+            if (moduleName || !(0, utils_js_1.ensureRealAstroFilePath)(fileName).endsWith('.astro')) {
+                return moduleName;
+            }
+            const cachedModule = moduleCache.get(fileName, containingFile);
+            if (cachedModule) {
+                return cachedModule;
+            }
+            const resolvedModule = resolveModuleName(fileName, containingFile, compilerOptions);
+            moduleCache.set(fileName, containingFile, resolvedModule);
+            return resolvedModule;
+        });
+    }
+    function resolveModuleName(name, containingFile, compilerOptions) {
+        const astroResolvedModule = typescript.resolveModuleName(name, containingFile, compilerOptions, astroSys).resolvedModule;
+        if (!astroResolvedModule || !(0, utils_js_1.isVirtualAstroFilePath)(astroResolvedModule.resolvedFileName)) {
+            return astroResolvedModule;
+        }
+        const resolvedFileName = (0, utils_js_1.ensureRealAstroFilePath)(astroResolvedModule.resolvedFileName);
+        logger.log('Resolved', name, 'to astro file', resolvedFileName);
+        const snapshot = snapshotManager.create(resolvedFileName);
+        if (!snapshot) {
+            return undefined;
+        }
+        const resolvedAstroModule = {
+            extension: typescript.Extension.Tsx,
+            resolvedFileName,
+        };
+        return resolvedAstroModule;
+    }
+    function resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
+        logger.log('Resolving modules names for ' + containingFile);
+        // Try resolving all module names with the original method first.
+        // The ones that are undefined will be re-checked if they are a
+        // Astro file and if so, are resolved, too. This way we can defer
+        // all module resolving logic except for Astro files to TypeScript.
+        const resolved = origResolveModuleNamLiterals?.(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) ??
+            moduleLiterals.map(() => ({
+                resolvedModule: undefined,
+            }));
+        return resolved.map((tsResolvedModule, idx) => {
+            const moduleName = moduleLiterals[idx].text;
+            if (tsResolvedModule.resolvedModule ||
+                !(0, utils_js_1.ensureRealAstroFilePath)(moduleName).endsWith('.astro')) {
+                return tsResolvedModule;
+            }
+            return resolveAstroModuleNameFromCache(moduleName, containingFile, options);
+        });
+    }
+    function resolveAstroModuleNameFromCache(moduleName, containingFile, options) {
+        const cachedModule = moduleCache.get(moduleName, containingFile);
+        if (cachedModule) {
+            return {
+                resolvedModule: cachedModule,
+            };
+        }
+        const resolvedModule = resolveModuleName(moduleName, containingFile, options);
+        moduleCache.set(moduleName, containingFile, resolvedModule);
+        return {
+            resolvedModule: resolvedModule,
+        };
+    }
+}
+exports.patchModuleLoader = patchModuleLoader;

package/dist/project-astro-files.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectAstroFilesManager = void 0;
+const utils_1 = require("./utils");
+class ProjectAstroFilesManager {
+    static getInstance(projectName) {
+        return this.instances.get(projectName);
+    }
+    constructor(typescript, project, serverHost, snapshotManager, parsedCommandLine) {
+        this.typescript = typescript;
+        this.project = project;
+        this.serverHost = serverHost;
+        this.snapshotManager = snapshotManager;
+        this.parsedCommandLine = parsedCommandLine;
+        this.files = new Set();
+        this.directoryWatchers = new Set();
+        this.setupWatchers();
+        this.updateProjectAstroFiles();
+        ProjectAstroFilesManager.instances.set(project.getProjectName(), this);
+    }
+    updateProjectConfig(serviceHost) {
+        const parsedCommandLine = serviceHost.getParsedCommandLine?.((0, utils_1.getConfigPathForProject)(this.project));
+        if (!parsedCommandLine) {
+            return;
+        }
+        this.disposeWatchersAndFiles();
+        this.parsedCommandLine = parsedCommandLine;
+        this.setupWatchers();
+        this.updateProjectAstroFiles();
+    }
+    getFiles() {
+        return Array.from(this.files);
+    }
+    /**
+     * Create directory watcher for include and exclude
+     * The watcher in tsserver doesn't support astro file
+     * It won't add new created astro file to root
+     */
+    setupWatchers() {
+        for (const directory in this.parsedCommandLine.wildcardDirectories) {
+            if (!Object.prototype.hasOwnProperty.call(this.parsedCommandLine.wildcardDirectories, directory)) {
+                continue;
+            }
+            const watchDirectoryFlags = this.parsedCommandLine.wildcardDirectories[directory];
+            const watcher = this.serverHost.watchDirectory(directory, this.watcherCallback.bind(this), watchDirectoryFlags === this.typescript.WatchDirectoryFlags.Recursive, this.parsedCommandLine.watchOptions);
+            this.directoryWatchers.add(watcher);
+        }
+    }
+    watcherCallback(fileName) {
+        if (!(0, utils_1.isAstroFilePath)(fileName)) {
+            return;
+        }
+        // We can't just add the file to the project directly, because
+        // - the casing of fileName is different
+        // - we don't know whether the file was added or deleted
+        this.updateProjectAstroFiles();
+    }
+    updateProjectAstroFiles() {
+        const fileNamesAfter = (0, utils_1.readProjectAstroFilesFromFs)(this.typescript, this.project, this.parsedCommandLine);
+        const removedFiles = new Set(...this.files);
+        const newFiles = fileNamesAfter.filter((fileName) => {
+            const has = this.files.has(fileName);
+            if (has) {
+                removedFiles.delete(fileName);
+            }
+            return !has;
+        });
+        for (const newFile of newFiles) {
+            this.addFileToProject(newFile);
+            this.files.add(newFile);
+        }
+        for (const removedFile of removedFiles) {
+            this.removeFileFromProject(removedFile, false);
+            this.files.delete(removedFile);
+        }
+    }
+    addFileToProject(newFile) {
+        this.snapshotManager.create(newFile);
+        const snapshot = this.project.projectService.getScriptInfo(newFile);
+        if (snapshot) {
+            this.project.addRoot(snapshot);
+        }
+    }
+    removeFileFromProject(file, exists = true) {
+        const info = this.project.getScriptInfo(file);
+        if (info) {
+            this.project.removeFile(info, exists, true);
+        }
+    }
+    disposeWatchersAndFiles() {
+        this.directoryWatchers.forEach((watcher) => watcher.close());
+        this.directoryWatchers.clear();
+        this.files.forEach((file) => this.removeFileFromProject(file));
+        this.files.clear();
+    }
+    dispose() {
+        this.disposeWatchersAndFiles();
+        ProjectAstroFilesManager.instances.delete(this.project.getProjectName());
+    }
+}
+exports.ProjectAstroFilesManager = ProjectAstroFilesManager;
+ProjectAstroFilesManager.instances = new Map();

package/dist/utils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectAstroFilesFromFs = exports.getConfigPathForProject = exports.replaceDeep = exports.isNotNullOrUndefined = exports.ensureRealAstroFilePath = exports.toRealAstroFilePath = exports.isVirtualAstroFilePath = exports.isAstroFilePath = void 0;
+function isAstroFilePath(filePath) {
+    return filePath.endsWith('.astro');
+}
+exports.isAstroFilePath = isAstroFilePath;
+function isVirtualAstroFilePath(filePath) {
+    return filePath.endsWith('.astro.ts');
+}
+exports.isVirtualAstroFilePath = isVirtualAstroFilePath;
+function toRealAstroFilePath(filePath) {
+    return filePath.slice(0, -'.ts'.length);
+}
+exports.toRealAstroFilePath = toRealAstroFilePath;
+function ensureRealAstroFilePath(filePath) {
+    return isVirtualAstroFilePath(filePath) ? toRealAstroFilePath(filePath) : filePath;
+}
+exports.ensureRealAstroFilePath = ensureRealAstroFilePath;
+function isNotNullOrUndefined(val) {
+    return val !== undefined && val !== null;
+}
+exports.isNotNullOrUndefined = isNotNullOrUndefined;
+/**
+ * Replace all occurrences of a string within an object with another string,
+ */
+function replaceDeep(obj, searchStr, replacementStr) {
+    return _replaceDeep(obj);
+    function _replaceDeep(_obj) {
+        if (typeof _obj === 'string') {
+            return _obj.replace(searchStr, replacementStr);
+        }
+        if (Array.isArray(_obj)) {
+            return _obj.map((entry) => _replaceDeep(entry));
+        }
+        if (typeof _obj === 'object') {
+            return Object.keys(_obj).reduce((_o, key) => {
+                _o[key] = _replaceDeep(_obj[key]);
+                return _o;
+            }, {});
+        }
+        return _obj;
+    }
+}
+exports.replaceDeep = replaceDeep;
+function getConfigPathForProject(project) {
+    return (project.canonicalConfigFilePath ??
+        project.getCompilerOptions().configFilePath);
+}
+exports.getConfigPathForProject = getConfigPathForProject;
+function readProjectAstroFilesFromFs(ts, project, parsedCommandLine) {
+    const fileSpec = parsedCommandLine.raw;
+    const { include, exclude } = fileSpec;
+    if (include?.length === 0) {
+        return [];
+    }
+    return ts.sys
+        .readDirectory(project.getCurrentDirectory() || process.cwd(), ['.astro'], exclude, include)
+        .map(ts.server.toNormalizedPath);
+}
+exports.readProjectAstroFilesFromFs = readProjectAstroFilesFromFs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/ts-plugin",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "A TypeScript Plugin providing Astro intellisense",
   "main": "dist/index.js",
   "type": "commonjs",
@@ -15,6 +15,10 @@
     "javascript",
     "plugin"
   ],
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
   "author": "withastro",
   "license": "MIT",
   "dependencies": {

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> @astrojs/ts-plugin@1.0.9 build /home/runner/work/language-tools/language-tools/packages/ts-plugin
-> tsc
-

package/CHANGELOG.md

@@ -1,113 +0,0 @@
-# @astrojs/ts-plugin
-
-## 1.0.9
-
-### Patch Changes
-
-- b6a98e0: Better handle when the Astro compiler fails to parse a file
-
-## 1.0.8
-
-### Patch Changes
-
-- 170a193: Update dependencies
-
-## 1.0.7
-
-### Patch Changes
-
-- c6cf1d7: Update Prettier plugin version
-
-## 1.0.6
-
-### Patch Changes
-
-- 3fcbc1a: Fix TypeScript plugin crashing at start in certain circumstances
-
-## 1.0.5
-
-### Patch Changes
-
-- ae15420: Fix importing `.astro` files in `.ts` files not working with TypeScript 5.0+
-
-## 1.0.4
-
-### Patch Changes
-
-- eaefe96: Fix packaging error
-
-## 1.0.3
-
-### Patch Changes
-
-- 685513b: Improve stability related to converting files to TSX
-
-## 1.0.0
-
-### Major Changes
-
-- 39a7669: 1.0! This release includes no new changes by itself, but symbolize the official release of what was previously the pre-release version of the extension. For changelogs, please refer to the changelog from `0.29.0` to now.
-
-## 0.4.5
-
-### Patch Changes
-
-- 8ff8bdf: Update compiler version to fix Windows mapping issue
-
-## 0.4.4
-
-### Patch Changes
-
-- c04adf3: Upgrade compiler version to 1.1.1
-
-## 0.4.3
-
-### Patch Changes
-
-- 6b81412: Added an explanation on how to generate types for content collections to the error message for the `astro:content` import
-
-## 0.4.2
-
-### Patch Changes
-
-- 94a9b61: Add proper support for renaming symbols inside Astro (.astro) files
-
-## 0.4.1
-
-### Patch Changes
-
-- 985515d: Update `@astrojs/compiler`, fixing a few bugs
-
-## 0.4.0
-
-### Minor Changes
-
-- c8cdef9: Improved support for `.astro` imports inside JavaScript/TypeScript files:
-  - Added support for finding file references inside Astro files
-  - Added support for path completions for .astro, .md and .mdx files
-  - Fixed cases where our TypeScript plugin would fail to load under certain circumstance
-  - Fixed certain cases where Go to definition / implementation would fail
-
-## 0.3.0
-
-### Minor Changes
-
-- b66ae70: Update the VS Code extension to use a bundled version of the language server for better performance and compatibility with running the extension in the web
-
-## 0.2.1
-
-### Patch Changes
-
-- d056cd5: Fixes production bugs in extension
-
-## 0.2.0
-
-### Minor Changes
-
-- 6b6b47a: Remove internal astro.d.ts files, instead prefer the one provided by Astro itself
-
-## 0.1.1
-
-### Patch Changes
-
-- f1f3091: Fix commenting, namespaced elements, and Fragment typings