scripts/devtools_paths.js

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

/**
 * This file contains helpers to load the correct path to various scripts and
 * directories. It is the Node equivalent of devtools_paths.py.
 *
 * Note that not all paths implemented in devtools_paths.py are implemented
 * here. Please add any paths you need that are missing.
 */

import os from 'node:os';
import path from 'node:path';

/**
 * You would think we can use import.meta.filename here but we cannot because import.meta.filename
 * has any symlinks resolved. This means we can't use it to tell if the user is
 * using the external repo with a standalone build setup because the symlink
 * from chromium/src/third_party/devtools-frontend => devtools-frontend repo
 * gets resolved by Node before it gives us import.meta.filename.
 *
 * We can use process.argv[1], which is the path to the file currently being
 * executed without any symlinks resolution. If we assume that file is always in
 * the devtools-frontend repository/directory, we can use that file as the
 * starting point for figuring out if we're in Chromium or not. until we find
 * the scripts directory, at which point we've found this file and can use it
 * for all subsequent logic.
 *
 * e.g. the user executes a script: scripts/lint/run_lint_check.mjs
 *
 * process.argv[1] =
 * /full/path/devtools-frontend/src/scripts/lint/run_lint_check.mjs
 */
const PATH_TO_EXECUTED_FILE = process.argv[1];

const _lookUpCaches = new Map();
/**
 * This function figures out if we're within a chromium directory, and therefore
 * we are in the integrated workflow mode, rather than working in a standalone
 * devtools-frontend repository.
 *
 * @returns {{isInChromium: boolean, chromiumDirectory: string}}
 */
export function isInChromiumDirectory() {
  const cached = _lookUpCaches.get('chromium');
  if (cached) {
    return cached;
  }

  const normalizedPath = PATH_TO_EXECUTED_FILE.split(path.sep).join('/');
  const devtoolsPath = 'third_party/devtools-frontend/src';
  const isInChromium = normalizedPath.includes(devtoolsPath);
  const potentialChromiumDir = PATH_TO_EXECUTED_FILE.substring(
      0,
      normalizedPath.indexOf(devtoolsPath),
  );
  const result = {isInChromium, chromiumDirectory: potentialChromiumDir};
  _lookUpCaches.set('chromium', result);
  return result;
}
/**
 * Returns the path to the root of the devtools-frontend repository.
 *
 * If we're in Chromium, this will be /path/to/chromium/src/third_party/devtools-frontend/src
 * If it's standalone, it will be /path/to/devtools-frontend
 */
export function devtoolsRootPath() {
  return path.dirname(import.meta.dirname);
}

/**
 * Returns the path to the root of the main repository we're in.
 * if we're in Chromium, this is /path/to/chromium/src
 * if we're in standalone, this is /path/to/devtools-frontend
 *
 * Note this is different to devtoolsRootPath(), which always returns the path
 * to the devtools-frontend source code.
 */
export function rootPath() {
  const {isInChromium, chromiumDirectory} = isInChromiumDirectory();
  if (isInChromium) {
    return chromiumDirectory;
  }
  return devtoolsRootPath();
}

/**
 * Path to the third_party directory. Used because if we're running in Chromium
 * land we need to use e.g. the Node executable from Chromium's third_party
 * directory, not from the devtools-frontend third_party directory.
 */
export function thirdPartyPath() {
  return path.join(rootPath(), 'third_party');
}

export function devToolsThirdPartyPath() {
  const {isInChromium} = isInChromiumDirectory();
  if (isInChromium) {
    return path.join(
        rootPath(),
        'third_party',
        'devtools-frontend',
        'src',
        'third_party',
    );
  }
  return thirdPartyPath();
}

export function nodePath() {
  const paths = {
    darwin: path.join(
        process.arch === 'arm64' ? 'mac_arm64' : 'mac',
        process.arch === 'arm64' ? 'node-darwin-arm64' : 'node-darwin-x64',
        'bin',
        'node',
        ),
    linux: path.join('linux', 'node-linux-x64', 'bin', 'node'),
    win32: path.join('win', 'node.exe'),
  };
  return path.join(thirdPartyPath(), 'node', paths[os.platform()]);
}

/**
 * The path to the devtools-frontend node_modules folder.
 */
export function nodeModulesPath() {
  return path.join(devtoolsRootPath(), 'node_modules');
}

export function autoninjaPyPath() {
  return path.join(thirdPartyPath(), 'depot_tools', 'autoninja.py');
}

export function vpython3ExecutablePath() {
  return path.join(
      thirdPartyPath(),
      'depot_tools',
      os.platform() === 'win32' ? 'vpython3.bat' : 'vpython3',
  );
}

export function gnPyPath() {
  return path.join(thirdPartyPath(), 'depot_tools', 'gn.py');
}

export function stylelintExecutablePath() {
  return path.join(nodeModulesPath(), 'stylelint', 'bin', 'stylelint.js');
}

export function mochaExecutablePath() {
  return path.join(nodeModulesPath(), 'mocha', 'bin', 'mocha');
}

export function litAnalyzerExecutablePath() {
  return path.join(nodeModulesPath(), 'lit-analyzer', 'cli.js');
}

/**
 * Computes the path to the toplevel `tsconfig.json`.
 *
 * @returns the path to the toplevel `tsconfig.json`.
 */
export function tsconfigJsonPath() {
  return path.join(devtoolsRootPath(), 'front_end', 'tsconfig.json');
}

export function typescriptPyPath() {
  return path.join(devtoolsRootPath(), 'third_party', 'typescript', 'typescript.py');
}

export function downloadedChromeBinaryPath() {
  const arch = os.arch() === 'arm64' ? 'arm64' : 'x64';
  const paths = {
    linux: path.join('chrome-linux', 'chrome-linux64', 'chrome'),
    darwin: path.join(
        `chrome-mac-${arch}`,
        `chrome-mac-${arch}`,
        'Google Chrome for Testing.app',
        'Contents',
        'MacOS',
        'Google Chrome for Testing',
        ),
    win32: path.join('chrome-win', 'chrome-win64', 'chrome.exe'),
  };
  return path.join(devToolsThirdPartyPath(), 'chrome', paths[os.platform()]);
}