vite-esbuild-typescript-checker/dist/esm/vue/type-script-embedded-extension.js

* Speeds up [TypeScript](https://github.com/Microsoft/TypeScript) type checking * Supports [Vue Single File Component](https://vuejs.org/v2/guide/single-file-components.html) * Displays nice error messages with the [code frame](https://babeljs.io/docs/en/

import { extname } from 'path';
function createTypeScriptEmbeddedExtension({ embeddedExtensions, getEmbeddedSource }) {
    const embeddedSourceCache = new Map();
    function getCachedEmbeddedSource(fileName) {
        if (!embeddedSourceCache.has(fileName)) {
            embeddedSourceCache.set(fileName, getEmbeddedSource(fileName));
        }
        return embeddedSourceCache.get(fileName);
    }
    function parsePotentiallyEmbeddedFileName(fileName) {
        const extension = extname(fileName);
        const embeddedFileName = fileName.slice(0, fileName.length - extension.length);
        const embeddedExtension = extname(embeddedFileName);
        return {
            extension,
            embeddedFileName,
            embeddedExtension
        };
    }
    function createEmbeddedFileExists(fileExists) {
        return function embeddedFileExists(fileName) {
            const { embeddedExtension, embeddedFileName, extension } = parsePotentiallyEmbeddedFileName(fileName);
            if (embeddedExtensions.includes(embeddedExtension) && fileExists(embeddedFileName)) {
                const embeddedSource = getCachedEmbeddedSource(embeddedFileName);
                return !!(embeddedSource && embeddedSource.extension === extension);
            }
            return fileExists(fileName);
        };
    }
    function createEmbeddedReadFile(readFile) {
        return function embeddedReadFile(fileName, encoding) {
            const { embeddedExtension, embeddedFileName, extension } = parsePotentiallyEmbeddedFileName(fileName);
            if (embeddedExtensions.includes(embeddedExtension)) {
                const embeddedSource = getCachedEmbeddedSource(embeddedFileName);
                if (embeddedSource && embeddedSource.extension === extension) {
                    return embeddedSource.sourceText;
                }
            }
            return readFile(fileName, encoding);
        };
    }
    return {
        extendIssues (issues) {
            return issues.map((issue)=>{
                if (issue.file) {
                    const { embeddedExtension, embeddedFileName } = parsePotentiallyEmbeddedFileName(issue.file);
                    if (embeddedExtensions.includes(embeddedExtension)) {
                        return {
                            ...issue,
                            file: embeddedFileName
                        };
                    }
                }
                return issue;
            });
        },
        extendWatchCompilerHost (host) {
            return {
                ...host,
                watchFile (fileName, callback, poolingInterval) {
                    const { embeddedExtension, embeddedFileName } = parsePotentiallyEmbeddedFileName(fileName);
                    if (embeddedExtensions.includes(embeddedExtension)) {
                        return host.watchFile(embeddedFileName, (innerFileName, eventKind)=>{
                            embeddedSourceCache.delete(embeddedFileName);
                            return callback(fileName, eventKind);
                        }, poolingInterval);
                    } else {
                        return host.watchFile(fileName, callback, poolingInterval);
                    }
                },
                readFile: createEmbeddedReadFile(host.readFile),
                fileExists: createEmbeddedFileExists(host.fileExists)
            };
        },
        extendCompilerHost (host) {
            return {
                ...host,
                readFile: createEmbeddedReadFile(host.readFile),
                fileExists: createEmbeddedFileExists(host.fileExists)
            };
        },
        extendParseConfigFileHost (host) {
            return {
                ...host,
                readDirectory (rootDir, extensions, excludes, includes, depth) {
                    return host.readDirectory(rootDir, [
                        ...extensions,
                        ...embeddedExtensions
                    ], excludes, includes, depth).map((fileName)=>{
                        const isEmbeddedFile = embeddedExtensions.some((embeddedExtension)=>fileName.endsWith(embeddedExtension));
                        if (isEmbeddedFile) {
                            const embeddedSource = getCachedEmbeddedSource(fileName);
                            return embeddedSource ? `${fileName}${embeddedSource.extension}` : fileName;
                        } else {
                            return fileName;
                        }
                    });
                }
            };
        },
        extendDependencies (dependencies) {
            return {
                ...dependencies,
                files: dependencies.files.map((fileName)=>{
                    const { embeddedExtension, embeddedFileName, extension } = parsePotentiallyEmbeddedFileName(fileName);
                    if (embeddedExtensions.includes(embeddedExtension)) {
                        const embeddedSource = getCachedEmbeddedSource(embeddedFileName);
                        if (embeddedSource && embeddedSource.extension === extension) {
                            return embeddedFileName;
                        }
                    }
                    return fileName;
                }),
                extensions: [
                    ...dependencies.extensions,
                    ...embeddedExtensions
                ]
            };
        }
    };
}
export { createTypeScriptEmbeddedExtension };