[cleanup] Fix yargs type

Uses ParseSync else the result is Promise<T> | T.
This give IDE better types to work with.

Bug: none
Change-Id: I4d6014aeccd7428ec03bfde90c5d728c6182c1f7
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6387381
Commit-Queue: Nikolay Vitkov <[email protected]>
Reviewed-by: Jack Franklin <[email protected]>

Author: Lightning00Blade

scripts/deps/sync-build-gn-imports.js

@@ -202,31 +202,30 @@ function parseSourceFileForImports(code, fileName) {
  * @returns {ComparisonResult}
  */
 function compareDeps({buildGN, sourceCode}) {
-  const sourceImportsWithFileNameRemoved =
-      sourceCode.imports
-          .map(importPath => {
-            // If a file imports `../core/sdk/sdk.js`, in the BUILD.gn that is
-            // listed as `../core/sdk:bundle`. In BUILD.gn DEPS you never depend on the
-            // specific file, but the directory that file is in. Therefore we drop the
-            // filename from the import.
-            return path.dirname(importPath);
-          })
-          .filter(dirName => {
-            // This caters for the case where the import is `import X from './Foo.js'`.
-            // Any sibling import doesn't need to be a DEP in BUILD.GN as they are in
-            // the same module, but we will check later that it's in the sources entry.
-            return dirName !== '.';
-          })
-          .map(importPath => {
-            // If we now have './helpers' we want to replace that with just
-            // 'helpers'. We do this because in the BUILD.gn file the dep will be
-            // listed as something like "helpers:bundle", so the starting "./" will
-            // break comparisons if we keep it around.
-            if (importPath.startsWith('./')) {
-              return importPath.slice(2);
-            }
-            return importPath;
-          });
+  const sourceImportsWithFileNameRemoved = sourceCode.imports
+                                               .map(importPath => {
+                                                 // If a file imports `../core/sdk/sdk.js`, in the BUILD.gn that is
+                                                 // listed as `../core/sdk:bundle`. In BUILD.gn DEPS you never depend on the
+                                                 // specific file, but the directory that file is in. Therefore we drop the
+                                                 // filename from the import.
+                                                 return path.dirname(importPath);
+                                               })
+                                               .filter(dirName => {
+                                                 // This caters for the case where the import is `import X from './Foo.js'`.
+                                                 // Any sibling import doesn't need to be a DEP in BUILD.GN as they are in
+                                                 // the same module, but we will check later that it's in the sources entry.
+                                                 return dirName !== '.';
+                                               })
+                                               .map(importPath => {
+                                                 // If we now have './helpers' we want to replace that with just
+                                                 // 'helpers'. We do this because in the BUILD.gn file the dep will be
+                                                 // listed as something like "helpers:bundle", so the starting "./" will
+                                                 // break comparisons if we keep it around.
+                                                 if (importPath.startsWith('./')) {
+                                                   return importPath.slice(2);
+                                                 }
+                                                 return importPath;
+                                               });
 
   // Now we have to find the BUILD.gn module that contains this source file
   // We check each section of the BUILD.gn and look for this file in the `sources` list.
@@ -239,7 +238,9 @@ function compareDeps({buildGN, sourceCode}) {
   });
 
   if (!buildGNModule) {
-    throw new Error(`Could not find module in BUILD.gn for ${sourceCode.filePath}`);
+    throw new Error(
+        `Could not find module in BUILD.gn for ${sourceCode.filePath}`,
+    );
   }
 
   // Special case: if we are linting an entrypoint, we have to find the
@@ -251,11 +252,15 @@ function compareDeps({buildGN, sourceCode}) {
     // We are going to use the dependencies from the relevant devtools_module
     // find the `deps = [':foo']` line, and return 'foo'
     const moduleDep = buildGNModule.deps[0].slice(1);
-    buildGNModule = buildGN.find(buildModule => buildModule.moduleName === moduleDep);
+    buildGNModule = buildGN.find(
+        buildModule => buildModule.moduleName === moduleDep,
+    );
   }
 
   if (!buildGNModule) {
-    throw new Error(`Could not find devtools_module in BUILD.gn for the devtools_entrypoint of ${sourceCode.filePath}`);
+    throw new Error(
+        `Could not find devtools_module in BUILD.gn for the devtools_entrypoint of ${sourceCode.filePath}`,
+    );
   }
 
   const buildGNDepsWithTargetRemoved = buildGNModule.deps.map(dep => {
@@ -334,30 +339,35 @@ function validateDirectory(dirPath) {
   const sourceFiles = directoryChildren.filter(child => {
     const isFile = fs.lstatSync(path.join(dirPath, child)).isFile();
     // TODO: longer term we may want to support .css files here too.
-    return (isFile && path.extname(child) === '.ts') && !child.endsWith('.test.ts');
+    return (isFile && path.extname(child) === '.ts' && !child.endsWith('.test.ts'));
   });
 
   /** @type {ValidateDirectoryResult} */
   const result = {
     missingBuildGNDeps: [],
     // We assume that all BUILD.GN deps are unused, and as we find them in
     // source code files we remove them from this set.
-    unusedBuildGNDeps: new Set(parsedBuildGN.flatMap(mod => {
-      // We don't worry about any deps that start with a colon, we are only
-      // interested in DEPS that are actual files.
-      return mod.deps.filter(dep => !dep.startsWith(':')).map(dep => {
-        // Drop the :bundle part from a dep, otherwise we can't compare it
-        // against the import statements from the source code.
-        const withoutBundle = dep.split(':')[0];
-        return withoutBundle;
-      });
-    }))
+    unusedBuildGNDeps: new Set(
+        parsedBuildGN.flatMap(mod => {
+          // We don't worry about any deps that start with a colon, we are only
+          // interested in DEPS that are actual files.
+          return mod.deps.filter(dep => !dep.startsWith(':')).map(dep => {
+            // Drop the :bundle part from a dep, otherwise we can't compare it
+            // against the import statements from the source code.
+            const withoutBundle = dep.split(':')[0];
+            return withoutBundle;
+          });
+        }),
+        ),
   };
 
   for (const sourceFile of sourceFiles) {
     const sourceCode = fs.readFileSync(path.join(dirPath, sourceFile), 'utf8');
     const parsedSource = parseSourceFileForImports(sourceCode, sourceFile);
-    const diffWithGN = compareDeps({buildGN: parsedBuildGN, sourceCode: parsedSource});
+    const diffWithGN = compareDeps({
+      buildGN: parsedBuildGN,
+      sourceCode: parsedSource,
+    });
     if (!diffWithGN) {
       continue;
     }
@@ -377,15 +387,19 @@ module.exports = {
   compareDeps,
   parseBuildGN,
   parseSourceFileForImports,
-  validateDirectory
+  validateDirectory,
 };
 
 // If invoked as CLI
 if (require.main === module) {
   const yargs = require('yargs')
-                    .option('directory', {type: 'string', desc: 'The directory to validate', demandOption: true})
+                    .option('directory', {
+                      type: 'string',
+                      desc: 'The directory to validate',
+                      demandOption: true,
+                    })
                     .strict()
-                    .argv;
+                    .parseSync();
 
   const directory = path.join(process.cwd(), yargs.directory);
   const result = validateDirectory(directory);

scripts/migration/web-tests-esm/rename-legacy-global.mjs

@@ -14,28 +14,29 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import yargs from 'yargs';
 
-const yargsObject = yargs(process.argv.slice(2), process.cwd()).option('web-test-directory', {
-                          type: 'string',
-                          demandOption: true,
-                        })
-                        .option('import', {
-                          type: 'string',
-                          demandOption: true,
-                        })
-                        .option('from', {
-                          type: 'string',
-                          demandOption: true,
-                        })
-                        .option('to', {
-                          type: 'string',
-                          demandOption: true,
-                        })
-                        .strict()
-                        .argv;
+const yargsObject = yargs(process.argv.slice(2), process.cwd())
+  .option('web-test-directory', {
+    type: 'string',
+    demandOption: true,
+  })
+  .option('import', {
+    type: 'string',
+    demandOption: true,
+  })
+  .option('from', {
+    type: 'string',
+    demandOption: true,
+  })
+  .option('to', {
+    type: 'string',
+    demandOption: true,
+  })
+  .strict()
+  .parseSync();
 
 // `createPlainTextSearchRegex` is stolen from string-utilities.ts.
 const SPECIAL_REGEX_CHARACTERS = '^[]{}()\\.^$*+?|-,';
-const createPlainTextSearchRegex = function(query) {
+const createPlainTextSearchRegex = function (query) {
   // This should be kept the same as the one in StringUtil.cpp.
   let regex = '';
   for (let i = 0; i < query.length; ++i) {
@@ -56,7 +57,9 @@ async function findWebTests(dir) {
   const entries = await fs.readdir(dir, { withFileTypes: true });
   const pathPromises = entries.map(async entry => {
     const p = path.resolve(dir, entry.name);
-    if (entry.isDirectory() && entry.name !== 'resources') {return findWebTests(p);}
+    if (entry.isDirectory() && entry.name !== 'resources') {
+      return findWebTests(p);
+    }
     if (entry.isFile() && entry.name.endsWith('.js')) {
       return [p];
     }
@@ -71,7 +74,9 @@ async function findWebTests(dir) {
  * it to an existing one.
  */
 function addImportIfNecessary(content, importLine) {
-  if (content.includes(importLine)) {return content;}
+  if (content.includes(importLine)) {
+    return content;
+  }
 
   // Find where to insert `importLine`. We'll add it either to
   // an existing import * as block or start a new one below the import {TestRunner} block.
@@ -87,7 +92,9 @@ function addImportIfNecessary(content, importLine) {
     }
   }
 
-  const linesToInsert = onlyHasTestRunnerImports ? ['', importLine] : [importLine];
+  const linesToInsert = onlyHasTestRunnerImports
+    ? ['', importLine]
+    : [importLine];
   lines.splice(lastImportIndex + 1, 0, ...linesToInsert);
   return lines.join('\n');
 }
@@ -96,7 +103,7 @@ const fromRegex = createPlainTextSearchRegex(yargsObject.from);
 const webTestPaths = await findWebTests(yargsObject.webTestDirectory);
 
 for (const filePath of webTestPaths) {
-  const content = await fs.readFile(filePath, { encoding: 'utf-8'});
+  const content = await fs.readFile(filePath, { encoding: 'utf-8' });
 
   let replacedContent = content;
   if (yargsObject.from === yargsObject.to && !content.match(fromRegex)) {
@@ -105,11 +112,13 @@ for (const filePath of webTestPaths) {
     continue;
   } else if (yargsObject.from !== yargsObject.to) {
     replacedContent = content.replaceAll(fromRegex, yargsObject.to);
-    if (replacedContent === content) {continue;}
+    if (replacedContent === content) {
+      continue;
+    }
   }
 
   replacedContent = addImportIfNecessary(replacedContent, yargsObject.import);
-  await fs.writeFile(filePath, replacedContent, {encoding: 'utf-8'});
+  await fs.writeFile(filePath, replacedContent, { encoding: 'utf-8' });
 }
 
 const suggestedCommitMessage = `

scripts/run_on_target.mjs

@@ -9,18 +9,17 @@ import yargs from 'yargs';
 import unparse from 'yargs-unparser';
 
 const argv = yargs(process.argv.slice(2))
-                 .command('$0 [script]')
-                 .option('target', {alias: 't', type: 'string', default: 'Default'})
-                 .help(false)
-                 .version(false)
-                 .argv;
+  .command('$0 [script]')
+  .option('target', { alias: 't', type: 'string', default: 'Default' })
+  .help(false)
+  .version(false)
+  .parseSync();
 
-const target = argv['target'];
-let script = argv['script'];
+const target = argv.target;
+let script = argv.script;
 
-delete argv['target'];
-delete argv['t'];
-delete argv['script'];
+delete argv.target;
+delete argv.script;
 
 let sourceRoot = path.dirname(path.dirname(path.resolve(argv['$0'])));
 
@@ -33,8 +32,13 @@ let cwd = path.join(sourceRoot, 'out', target);
 
 if (!fs.existsSync(cwd)) {
   // Check if we are in a Chromium checkout and look for the out folder there.
-  const maybeChromiumRoot = path.dirname(path.dirname(path.dirname(sourceRoot)));
-  if (sourceRoot === path.join(maybeChromiumRoot, 'third_party', 'devtools-frontend', 'src')) {
+  const maybeChromiumRoot = path.dirname(
+    path.dirname(path.dirname(sourceRoot)),
+  );
+  if (
+    sourceRoot ===
+    path.join(maybeChromiumRoot, 'third_party', 'devtools-frontend', 'src')
+  ) {
     sourceRoot = maybeChromiumRoot;
     cwd = path.join(sourceRoot, 'out', target);
     const pathParts = script.split(path.sep);
@@ -46,15 +50,24 @@ if (!fs.existsSync(cwd)) {
   }
 }
 
-if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory() || !fs.existsSync(path.join(cwd, 'build.ninja'))) {
+if (
+  !fs.existsSync(cwd) ||
+  !fs.statSync(cwd).isDirectory() ||
+  !fs.existsSync(path.join(cwd, 'build.ninja'))
+) {
   console.error(
-      `Target path ${cwd} does not exist or is not a directory. Please run 'gn gen out/${target}' first.`);
+    `Target path ${cwd} does not exist or is not a directory. Please run 'gn gen out/${target}' first.`,
+  );
   process.exit(1);
 }
 const scriptPath = path.resolve(cwd, script);
 if (!fs.existsSync(scriptPath)) {
   console.error(`Script path ${scriptPath} does not exist, trying ninja...`);
-  const {error, status} = childProcess.spawnSync('autoninja', ['-C', cwd, script], {stdio: 'inherit', cwd: sourceRoot});
+  const { error, status } = childProcess.spawnSync(
+    'autoninja',
+    ['-C', cwd, script],
+    { stdio: 'inherit', cwd: sourceRoot },
+  );
   if (error) {
     throw error;
   }
@@ -63,6 +76,10 @@ if (!fs.existsSync(scriptPath)) {
   }
 }
 
-const {argv0} = process;
-const {status} = childProcess.spawnSync(argv0, [scriptPath, ...unparse(argv)], {stdio: 'inherit', env});
+const { argv0 } = process;
+const { status } = childProcess.spawnSync(
+  argv0,
+  [scriptPath, ...unparse(argv)],
+  { stdio: 'inherit', env },
+);
 process.exit(status);