@astrojs/ts-plugin 1.0.10 → 1.1.1

package/dist/module-loader.js

@@ -1,146 +0,0 @@
-"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.d.ts

@@ -1,28 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-import type { AstroSnapshotManager } from './astro-snapshots';
-export declare class ProjectAstroFilesManager {
-    private readonly typescript;
-    private readonly project;
-    private readonly serverHost;
-    private readonly snapshotManager;
-    private parsedCommandLine;
-    private files;
-    private directoryWatchers;
-    private static instances;
-    static getInstance(projectName: string): ProjectAstroFilesManager | undefined;
-    constructor(typescript: typeof ts, project: ts.server.Project, serverHost: ts.server.ServerHost, snapshotManager: AstroSnapshotManager, parsedCommandLine: ts.ParsedCommandLine);
-    updateProjectConfig(serviceHost: ts.LanguageServiceHost): void;
-    getFiles(): string[];
-    /**
-     * 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
-     */
-    private setupWatchers;
-    private watcherCallback;
-    private updateProjectAstroFiles;
-    private addFileToProject;
-    private removeFileFromProject;
-    private disposeWatchersAndFiles;
-    dispose(): void;
-}

package/dist/project-astro-files.js

@@ -1,102 +0,0 @@
-"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.d.ts

@@ -1,16 +0,0 @@
-import type ts from 'typescript/lib/tsserverlibrary';
-export declare function isAstroFilePath(filePath: string): boolean;
-export declare function isVirtualAstroFilePath(filePath: string): boolean;
-export declare function toRealAstroFilePath(filePath: string): string;
-export declare function ensureRealAstroFilePath(filePath: string): string;
-export declare function isNotNullOrUndefined<T>(val: T | undefined | null): val is T;
-/**
- * Replace all occurrences of a string within an object with another string,
- */
-export declare function replaceDeep<T extends Record<string, any>>(obj: T, searchStr: string | RegExp, replacementStr: string): T;
-export declare function getConfigPathForProject(project: ts.server.Project): ts.server.NormalizedPath;
-export declare function readProjectAstroFilesFromFs(ts: typeof import('typescript/lib/tsserverlibrary'), project: ts.server.Project, parsedCommandLine: ts.ParsedCommandLine): ts.server.NormalizedPath[];
-export interface TsFilesSpec {
-    include?: readonly string[];
-    exclude?: readonly string[];
-}

package/dist/utils.js

@@ -1,61 +0,0 @@
-"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;