"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Runfiles = void 0;
const fs = require("fs");
const path = require("path");
const paths_1 = require("./paths");
const repository_1 = require("./repository");
/**
 * Class that provides methods for resolving Bazel runfiles.
 */
class Runfiles {
    constructor(_env = process.env) {
        this._env = _env;
        // If Bazel sets a variable pointing to a runfiles manifest,
        // we'll always use it.
        // Note that this has a slight performance implication on Mac/Linux
        // where we could use the runfiles tree already laid out on disk
        // but this just costs one file read for the external npm/node_modules
        // and one for each first-party module, not one per file.
        if (!!_env['RUNFILES_MANIFEST_FILE']) {
            this.manifest = this.loadRunfilesManifest(_env['RUNFILES_MANIFEST_FILE']);
        }
        else if (!!_env['RUNFILES_DIR']) {
            this.runfilesDir = path.resolve(_env['RUNFILES_DIR']);
            this.repoMappings = this.parseRepoMapping(this.runfilesDir);
        }
        else if (!!_env['RUNFILES']) {
            this.runfilesDir = path.resolve(_env['RUNFILES']);
            this.repoMappings = this.parseRepoMapping(this.runfilesDir);
        }
        else {
            throw new Error('Every node program run under Bazel must have a $RUNFILES_DIR, $RUNFILES or $RUNFILES_MANIFEST_FILE environment variable');
        }
        // Under --noenable_runfiles (in particular on Windows)
        // Bazel sets RUNFILES_MANIFEST_ONLY=1.
        // When this happens, we need to read the manifest file to locate
        // inputs
        if (_env['RUNFILES_MANIFEST_ONLY'] === '1' && !_env['RUNFILES_MANIFEST_FILE']) {
            console.warn(`Workaround https://github.com/bazelbuild/bazel/issues/7994
                 RUNFILES_MANIFEST_FILE should have been set but wasn't.
                 falling back to using runfiles symlinks.
                 If you want to test runfiles manifest behavior, add
                 --spawn_strategy=standalone to the command line.`);
        }
        // Bazel starts actions with pwd=execroot/my_wksp or pwd=runfiles/my_wksp
        this.workspace = _env['BAZEL_WORKSPACE'] || _env['JS_BINARY__WORKSPACE'] || undefined;
        // If target is from an external workspace such as @npm//rollup/bin:rollup
        // resolvePackageRelative is not supported since package is in an external
        // workspace.
        let target = _env['BAZEL_TARGET'] || _env['JS_BINARY__TARGET'];
        if (!!target && !target.startsWith('@')) {
            // //path/to:target -> path/to
            this.package = target.split(':')[0].replace(/^\/\//, '');
        }
    }
    /** Resolves the given path from the runfile manifest. */
    _resolveFromManifest(searchPath) {
        if (!this.manifest)
            return undefined;
        let result;
        for (const [k, v] of this.manifest) {
            // Account for Bazel --legacy_external_runfiles
            // which pollutes the workspace with 'my_wksp/external/...'
            if (k.startsWith(`${searchPath}/external`))
                continue;
            // If the manifest entry fully matches, return the value path without
            // considering other manifest entries. We already have an exact match.
            if (k === searchPath) {
                return v;
            }
            // Consider a case where `npm/node_modules` is resolved, and we have the following
            // manifest: `npm/node_modules/semver/LICENSE
            // /path/to/external/npm/node_modules/semver/LICENSE` To resolve the directory, we look for
            // entries that either fully match, or refer to contents within the directory we are looking
            // for. We can then subtract the child path to resolve the directory. e.g. in the case above
            // we subtract `length(`/semver/LICENSE`)` from the entry value.
            if (k.startsWith(`${searchPath}/`)) {
                const l = k.length - searchPath.length;
                const maybe = v.substring(0, v.length - l);
                if (maybe.match(paths_1.BAZEL_OUT_REGEX)) {
                    return maybe;
                }
                else {
                    result = maybe;
                }
            }
        }
        return result;
    }
    /**
     * The runfiles manifest maps from short_path
     * https://docs.bazel.build/versions/main/skylark/lib/File.html#short_path
     * to the actual location on disk where the file can be read.
     *
     * In a sandboxed execution, it does not exist. In that case, runfiles must be
     * resolved from a symlink tree under the runfiles dir.
     * See https://github.com/bazelbuild/bazel/issues/3726
     */
    loadRunfilesManifest(manifestPath) {
        const runfilesEntries = new Map();
        const input = fs.readFileSync(manifestPath, { encoding: 'utf-8' });
        for (const line of input.split('\n')) {
            if (!line)
                continue;
            const [runfilesPath, realPath] = line.split(' ');
            runfilesEntries.set(runfilesPath, realPath);
        }
        return runfilesEntries;
    }
    parseRepoMapping(runfilesDir) {
        var _a;
        const repoMappingPath = path.join(runfilesDir, paths_1.REPO_MAPPING_RLOCATION);
        if (!fs.existsSync(repoMappingPath)) {
            // The repo mapping manifest only exists with Bzlmod, so it's not an
            // error if it's missing. Since any repository name not contained in the
            // mapping is assumed to be already canonical, no map is equivalent to
            // not applying any mapping.
            return undefined;
        }
        const repoMappings = Object.create(null);
        const mappings = fs.readFileSync(repoMappingPath, { encoding: "utf-8" });
        // Each line of the repository mapping manifest has the form:
        // canonical name of source repo,apparent name of target repo,target repo runfiles directory
        // https://cs.opensource.google/bazel/bazel/+/1b073ac0a719a09c9b2d1a52680517ab22dc971e:src/main/java/com/google/devtools/build/lib/analysis/RepoMappingManifestAction.java;l=117
        for (const line of mappings.split("\n")) {
            if (!line)
                continue;
            const [sourceRepo, targetRepoApparentName, targetRepoDirectory] = line.split(",");
            ((_a = repoMappings[sourceRepo]) !== null && _a !== void 0 ? _a : (repoMappings[sourceRepo] = Object.create(null)))[targetRepoApparentName] = targetRepoDirectory;
        }
        return repoMappings;
    }
    /** Resolves the given module path. */
    resolve(modulePath, sourceRepo) {
        // Normalize path by converting to forward slashes and removing all trailing
        // forward slashes
        modulePath = modulePath.replace(/\\/g, '/').replace(/\/+$/g, '');
        if (path.isAbsolute(modulePath)) {
            return modulePath;
        }
        if (this.repoMappings) {
            // Determine the repository which runfiles is being invoked from by default.
            if (sourceRepo === undefined) {
                sourceRepo = (0, repository_1.callerRepository)();
            }
            // If the repository mappings were loaded ensure the source repository is valid.
            if (!(sourceRepo in this.repoMappings)) {
                throw new Error(`source repository "${sourceRepo}" not found in repo mappings: ${JSON.stringify(this.repoMappings, null, 2)}`);
            }
        }
        const result = this._resolve(sourceRepo, modulePath, undefined);
        if (result) {
            return result;
        }
        const e = new Error(`could not resolve module "${modulePath}" from repository "${sourceRepo}"`);
        e.code = 'MODULE_NOT_FOUND';
        throw e;
    }
    /** Resolves the given path relative to the current Bazel workspace. */
    resolveWorkspaceRelative(modulePath) {
        // Normalize path by converting to forward slashes and removing all trailing
        // forward slashes
        modulePath = modulePath.replace(/\\/g, '/').replace(/\/+$/g, '');
        if (!this.workspace) {
            throw new Error('workspace could not be determined from the environment; make sure BAZEL_WORKSPACE is set');
        }
        return this.resolve(path.posix.join(this.workspace, modulePath));
    }
    /** Resolves the given path relative to the current Bazel package. */
    resolvePackageRelative(modulePath) {
        // Normalize path by converting to forward slashes and removing all trailing
        // forward slashes
        modulePath = modulePath.replace(/\\/g, '/').replace(/\/+$/g, '');
        if (!this.workspace) {
            throw new Error('workspace could not be determined from the environment; make sure BAZEL_WORKSPACE is set');
        }
        // NB: this.package may be '' if at the root of the workspace
        if (this.package === undefined) {
            throw new Error('package could not be determined from the environment; make sure BAZEL_TARGET is set');
        }
        return this.resolve(path.posix.join(this.workspace, this.package, modulePath));
    }
    /**
     * Patches the default Node.js resolution to support runfile resolution.
     * @deprecated Use the runfile helpers directly instead.
     **/
    patchRequire() {
        const requirePatch = this._env['BAZEL_NODE_PATCH_REQUIRE'];
        if (!requirePatch) {
            throw new Error('require patch location could not be determined from the environment');
        }
        require(requirePatch);
    }
    /** Helper for resolving a given module recursively in the runfiles. */
    _resolve(sourceRepo, moduleBase, moduleTail) {
        if (this.manifest) {
            const result = this._resolveFromManifest(moduleBase);
            if (result) {
                if (moduleTail) {
                    const maybe = path.join(result, moduleTail || '');
                    if (fs.existsSync(maybe)) {
                        return maybe;
                    }
                }
                else {
                    return result;
                }
            }
        }
        // Apply repo mappings to the moduleBase if it is a known repo.
        if (this.repoMappings && moduleBase in this.repoMappings[sourceRepo]) {
            const mappedRepo = this.repoMappings[sourceRepo][moduleBase];
            if (mappedRepo !== moduleBase) {
                const maybe = this._resolve(sourceRepo, mappedRepo, moduleTail);
                if (maybe !== undefined) {
                    return maybe;
                }
            }
        }
        if (this.runfilesDir) {
            const maybe = path.join(this.runfilesDir, moduleBase, moduleTail || '');
            if (fs.existsSync(maybe)) {
                return maybe;
            }
        }
        const dirname = path.dirname(moduleBase);
        if (dirname == '.') {
            // no match
            return undefined;
        }
        return this._resolve(sourceRepo, dirname, path.join(path.basename(moduleBase), moduleTail || ""));
    }
}
exports.Runfiles = Runfiles;
