sourcemaps.ts

import {
    base64decode,
    computeLineAndCharacterOfPosition,
    createDocumentPositionMapper,
    createGetCanonicalFileName,
    DocumentPosition,
    DocumentPositionMapper,
    DocumentPositionMapperHost,
    Extension,
    getDeclarationEmitOutputFilePathWorker,
    getDirectoryPath,
    getDocumentPositionMapper as ts_getDocumentPositionMapper,
    getLineInfo,
    getLineStarts,
    getNormalizedAbsolutePath,
    identitySourceMapConsumer,
    isDeclarationFileName,
    isString,
    LineAndCharacter,
    LineInfo,
    Program,
    removeFileExtension,
    SourceFileLike,
    sys,
    toPath as ts_toPath,
    tryGetSourceMappingURL,
    tryParseRawSourceMap,
} from "./_namespaces/ts.js";

const base64UrlRegExp = /^data:(?:application\/json;charset=[uU][tT][fF]-8;base64,([A-Za-z0-9+/=]+)$)?/;

/** @internal */
export interface SourceMapper {
    toLineColumnOffset(fileName: string, position: number): LineAndCharacter;
    tryGetSourcePosition(info: DocumentPosition): DocumentPosition | undefined;
    tryGetGeneratedPosition(info: DocumentPosition): DocumentPosition | undefined;
    clearCache(): void;
    documentPositionMappers: Map<string, DocumentPositionMapper>;
}

/** @internal */
export interface SourceMapperHost {
    useCaseSensitiveFileNames(): boolean;
    getCurrentDirectory(): string;
    getProgram(): Program | undefined;
    fileExists?(path: string): boolean;
    readFile?(path: string, encoding?: string): string | undefined;
    getSourceFileLike?(fileName: string): SourceFileLike | undefined;
    getDocumentPositionMapper?(generatedFileName: string, sourceFileName?: string): DocumentPositionMapper | undefined;
    log(s: string): void;
}

/** @internal */
export function getSourceMapper(host: SourceMapperHost): SourceMapper {
    const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
    const currentDirectory = host.getCurrentDirectory();
    const sourceFileLike = new Map<string, SourceFileLike | false>();
    const documentPositionMappers = new Map<string, DocumentPositionMapper>();
    return {
        tryGetSourcePosition,
        tryGetGeneratedPosition,
        toLineColumnOffset,
        clearCache,
        documentPositionMappers,
    };

    function toPath(fileName: string) {
        return ts_toPath(fileName, currentDirectory, getCanonicalFileName);
    }

    function getDocumentPositionMapper(generatedFileName: string, sourceFileName?: string) {
        const path = toPath(generatedFileName);
        const value = documentPositionMappers.get(path);
        if (value) return value;

        let mapper: DocumentPositionMapper | undefined;
        if (host.getDocumentPositionMapper) {
            mapper = host.getDocumentPositionMapper(generatedFileName, sourceFileName);
        }
        else if (host.readFile) {
            const file = getSourceFileLike(generatedFileName);
            mapper = file && ts_getDocumentPositionMapper(
                { getSourceFileLike, getCanonicalFileName, log: s => host.log(s) },
                generatedFileName,
                getLineInfo(file.text, getLineStarts(file)),
                f => !host.fileExists || host.fileExists(f) ? host.readFile!(f) : undefined,
            );
        }
        documentPositionMappers.set(path, mapper || identitySourceMapConsumer);
        return mapper || identitySourceMapConsumer;
    }

    function tryGetSourcePosition(info: DocumentPosition): DocumentPosition | undefined {
        if (!isDeclarationFileName(info.fileName)) return undefined;

        const file = getSourceFile(info.fileName);
        if (!file) return undefined;

        const newLoc = getDocumentPositionMapper(info.fileName).getSourcePosition(info);
        return !newLoc || newLoc === info ? undefined : tryGetSourcePosition(newLoc) || newLoc;
    }

    function tryGetGeneratedPosition(info: DocumentPosition): DocumentPosition | undefined {
        if (isDeclarationFileName(info.fileName)) return undefined;

        const sourceFile = getSourceFile(info.fileName);
        if (!sourceFile) return undefined;

        const program = host.getProgram()!;
        // If this is source file of project reference source (instead of redirect) there is no generated position
        if (program.isSourceOfProjectReferenceRedirect(sourceFile.fileName)) {
            return undefined;
        }

        const options = program.getCompilerOptions();
        const outPath = options.outFile;

        const declarationPath = outPath ?
            removeFileExtension(outPath) + Extension.Dts :
            getDeclarationEmitOutputFilePathWorker(info.fileName, program.getCompilerOptions(), program);
        if (declarationPath === undefined) return undefined;

        const newLoc = getDocumentPositionMapper(declarationPath, info.fileName).getGeneratedPosition(info);
        return newLoc === info ? undefined : newLoc;
    }

    function getSourceFile(fileName: string) {
        const program = host.getProgram();
        if (!program) return undefined;

        const path = toPath(fileName);
        // file returned here could be .d.ts when asked for .ts file if projectReferences and module resolution created this source file
        const file = program.getSourceFileByPath(path);
        return file && file.resolvedPath === path ? file : undefined;
    }

    function getOrCreateSourceFileLike(fileName: string): SourceFileLike | undefined {
        const path = toPath(fileName);
        const fileFromCache = sourceFileLike.get(path);
        if (fileFromCache !== undefined) return fileFromCache ? fileFromCache : undefined;

        if (!host.readFile || host.fileExists && !host.fileExists(fileName)) {
            sourceFileLike.set(path, false);
            return undefined;
        }

        // And failing that, check the disk
        const text = host.readFile(fileName);
        const file = text ? createSourceFileLike(text) : false;
        sourceFileLike.set(path, file);
        return file ? file : undefined;
    }

    // This can be called from source mapper in either source program or program that includes generated file
    function getSourceFileLike(fileName: string) {
        return !host.getSourceFileLike ?
            getSourceFile(fileName) || getOrCreateSourceFileLike(fileName) :
            host.getSourceFileLike(fileName);
    }

    function toLineColumnOffset(fileName: string, position: number): LineAndCharacter {
        const file = getSourceFileLike(fileName)!; // TODO: GH#18217
        return file.getLineAndCharacterOfPosition(position);
    }

    function clearCache(): void {
        sourceFileLike.clear();
        documentPositionMappers.clear();
    }
}

/**
 * string | undefined to contents of map file to create DocumentPositionMapper from it
 * DocumentPositionMapper | false to give back cached DocumentPositionMapper
 *
 * @internal
 */
export type ReadMapFile = (mapFileName: string, mapFileNameFromDts: string | undefined) => string | undefined | DocumentPositionMapper | false;

/** @internal */
export function getDocumentPositionMapper(
    host: DocumentPositionMapperHost,
    generatedFileName: string,
    generatedFileLineInfo: LineInfo,
    readMapFile: ReadMapFile,
): DocumentPositionMapper | undefined {
    let mapFileName = tryGetSourceMappingURL(generatedFileLineInfo);
    if (mapFileName) {
        const match = base64UrlRegExp.exec(mapFileName);
        if (match) {
            if (match[1]) {
                const base64Object = match[1];
                return convertDocumentToSourceMapper(host, base64decode(sys, base64Object), generatedFileName);
            }
            // Not a data URL we can parse, skip it
            mapFileName = undefined;
        }
    }
    const possibleMapLocations: string[] = [];
    if (mapFileName) {
        possibleMapLocations.push(mapFileName);
    }
    possibleMapLocations.push(generatedFileName + ".map");
    const originalMapFileName = mapFileName && getNormalizedAbsolutePath(mapFileName, getDirectoryPath(generatedFileName));
    for (const location of possibleMapLocations) {
        const mapFileName = getNormalizedAbsolutePath(location, getDirectoryPath(generatedFileName));
        const mapFileContents = readMapFile(mapFileName, originalMapFileName);
        if (isString(mapFileContents)) {
            return convertDocumentToSourceMapper(host, mapFileContents, mapFileName);
        }
        if (mapFileContents !== undefined) {
            return mapFileContents || undefined;
        }
    }
    return undefined;
}

function convertDocumentToSourceMapper(host: DocumentPositionMapperHost, contents: string, mapFileName: string) {
    const map = tryParseRawSourceMap(contents);
    if (!map || !map.sources || !map.file || !map.mappings) {
        // obviously invalid map
        return undefined;
    }

    // Dont support sourcemaps that contain inlined sources
    if (map.sourcesContent && map.sourcesContent.some(isString)) return undefined;

    return createDocumentPositionMapper(host, map, mapFileName);
}

function createSourceFileLike(text: string, lineMap?: SourceFileLike["lineMap"]): SourceFileLike {
    return {
        text,
        lineMap,
        getLineAndCharacterOfPosition(pos: number) {
            return computeLineAndCharacterOfPosition(getLineStarts(this), pos);
        },
    };
}