chrome-devtools-frontend 1.0.1473514 → 1.0.1510180

package/scripts/devtools_paths.js

@@ -1,193 +0,0 @@
-// Copyright 2020 The Chromium Authors. All rights reserved.
-// 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.
- */
-
-const os = require('os');
-const path = require('path');
-
-/**
- * You would think we can use __filename here but we cannot because __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 __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/test/run_lint_check.mjs
- *
- * process.argv[1] =
- * /full/path/devtools-frontend/src/scripts/test/run_lint_check.mjs
- */
-const PATH_TO_EXECUTED_FILE = process.argv[1];
-
-const _lookUpCaches = new Map([['chromium', null]]);
-/**
- * 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.
- */
-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
- */
-function devtoolsRootPath() {
-  return path.dirname(__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.
- */
-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.
- */
-function thirdPartyPath() {
-  return path.join(rootPath(), 'third_party');
-}
-
-function devToolsThirdPartyPath() {
-  const {isInChromium} = isInChromiumDirectory();
-  if (isInChromium) {
-    return path.join(
-        rootPath(),
-        'third_party',
-        'devtools-frontend',
-        'src',
-        'third_party',
-    );
-  }
-  return thirdPartyPath();
-}
-
-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.
- */
-function nodeModulesPath() {
-  return path.join(devtoolsRootPath(), 'node_modules');
-}
-
-function autoninjaPyPath() {
-  return path.join(thirdPartyPath(), 'depot_tools', 'autoninja.py');
-}
-
-function vpython3ExecutablePath() {
-  return path.join(thirdPartyPath(), 'depot_tools', os.platform() === 'win32' ? 'vpython3.bat' : 'vpython3');
-}
-
-function gnPyPath() {
-  return path.join(thirdPartyPath(), 'depot_tools', 'gn.py');
-}
-
-function stylelintExecutablePath() {
-  return path.join(nodeModulesPath(), 'stylelint', 'bin', 'stylelint.js');
-}
-
-function mochaExecutablePath() {
-  return path.join(nodeModulesPath(), 'mocha', 'bin', 'mocha');
-}
-
-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`.
- */
-function tsconfigJsonPath() {
-  return path.join(devtoolsRootPath(), 'front_end', 'tsconfig.json');
-}
-
-function downloadedChromeBinaryPath() {
-  const paths = {
-    linux: path.join('chrome-linux', 'chrome'),
-    darwin: path.join(
-        'chrome-mac',
-        'Google Chrome for Testing.app',
-        'Contents',
-        'MacOS',
-        'Google Chrome for Testing',
-        ),
-    win32: path.join('chrome-win', 'chrome.exe'),
-  };
-  return path.join(devToolsThirdPartyPath(), 'chrome', paths[os.platform()]);
-}
-
-module.exports = {
-  autoninjaPyPath,
-  devtoolsRootPath,
-  downloadedChromeBinaryPath,
-  isInChromiumDirectory,
-  gnPyPath,
-  litAnalyzerExecutablePath,
-  mochaExecutablePath,
-  nodeModulesPath,
-  nodePath,
-  rootPath,
-  stylelintExecutablePath,
-  thirdPartyPath,
-  tsconfigJsonPath,
-  vpython3ExecutablePath,
-};

package/scripts/devtools_paths.py

@@ -1,132 +0,0 @@
-# Copyright 2019 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-"""
-Helper to find the path to the correct third_party directory
-"""
-
-from os import path
-import sys
-import platform
-
-
-# Find the root path of the checkout.
-# In the Chromium repository, this is the src/chromium directory.
-# In the external repository, standalone build, this is the devtools-frontend directory.
-# In the external repository, integrated build, this is the src/chromium directory.
-def root_path():
-    SCRIPTS_PATH = path.dirname(path.abspath(__file__))
-    ABS_DEVTOOLS_PATH = path.dirname(SCRIPTS_PATH)
-    PARENT_PATH = path.dirname(ABS_DEVTOOLS_PATH)
-    # TODO(1011259): remove Chromium repository handling
-    if path.basename(PARENT_PATH) == 'renderer':
-        # Chromium repository
-        return path.dirname(path.dirname(path.dirname(PARENT_PATH)))
-    elif path.basename(PARENT_PATH) == 'devtools-frontend' or path.basename(
-            PARENT_PATH) == 'devtools-frontend-internal':
-        # External repository, integrated build
-        return path.dirname(path.dirname(PARENT_PATH))
-    else:
-        # External repository, standalone build
-        return ABS_DEVTOOLS_PATH
-
-
-# This is the third_party path relative to the root of the checkout.
-def third_party_path():
-    return path.join(root_path(), 'third_party')
-
-
-# This points to the node binary downloaded as part of the checkout.
-def node_path():
-    try:
-        old_sys_path = sys.path[:]
-        sys.path.append(path.join(third_party_path(), 'node'))
-        import node
-    finally:
-        sys.path = old_sys_path
-    return node.GetBinaryPath()
-
-
-def devtools_root_path():
-    return path.dirname((path.dirname(path.abspath(__file__))))
-
-
-def node_modules_path():
-    return path.join(devtools_root_path(), 'node_modules')
-
-
-def eslint_path():
-    return path.join(node_modules_path(), 'eslint', 'bin', 'eslint.js')
-
-
-def mocha_path():
-    return path.join(node_modules_path(), 'mocha', 'bin', 'mocha.js')
-
-
-def karma_path():
-    return path.join(node_modules_path(), 'karma', 'bin', 'karma')
-
-
-def typescript_compiler_path():
-    return path.join(node_modules_path(), 'typescript', 'bin', 'tsc')
-
-
-def hosted_mode_script_path():
-    return path.join(devtools_root_path(), 'scripts', 'hosted_mode',
-                     'server.js')
-
-
-def esbuild_path():
-    return path.join(devtools_root_path(), 'third_party', 'esbuild', 'esbuild')
-
-
-def autoninja_path():
-    return path.join(devtools_root_path(), 'third_party', 'depot_tools',
-                     'autoninja')
-
-
-def downloaded_chrome_binary_path():
-    return path.abspath(
-        path.join(
-            *{
-                'Linux': (devtools_root_path(), 'third_party', 'chrome',
-                          'chrome-linux', 'chrome'),
-                'Darwin': (devtools_root_path(), 'third_party', 'chrome',
-                           'chrome-mac', 'Google Chrome for Testing.app',
-                           'Contents', 'MacOS', 'Google Chrome for Testing'),
-                'Windows': (devtools_root_path(), 'third_party', 'chrome',
-                            'chrome-win', 'chrome.exe'),
-            }[platform.system()]))
-
-
-def license_checker_path():
-    return path.join(node_modules_path(), 'license-checker', 'bin',
-                     'license-checker')
-
-
-def rollup_path():
-    return path.join(
-        node_modules_path(),
-        '@rollup',
-        'wasm-node',
-        'dist',
-        'bin',
-        'rollup',
-    )
-
-
-def package_lock_json_path():
-    return path.join(devtools_root_path(), 'package-lock.json')
-
-
-def package_json_path():
-    return path.join(devtools_root_path(), 'package.json')
-
-
-def browser_protocol_path():
-    return path.join(third_party_path(), 'blink', 'public',
-                     'devtools_protocol', 'browser_protocol.pdl')
-
-
-def custom_devtools_frontend_path(target):
-    return path.join(root_path(), 'out', target, 'gen', 'front_end')

package/scripts/eslint_rules/README.md

@@ -1,27 +0,0 @@
-# Custom ESLint rules for Chromium DevTools
-
-The [`lib/` folder](./lib/) contains a set of [ESLint](https://eslint.org) rules
-specific to Chromium DevTools. These rules are executed as part of the
-
-```
-npm run lint
-```
-
-command and implicitly via the [Presubmit checks](../../test/README.md#Presubmit-checks).
-
-We follow the ESLint [Rule Naming Conventions](https://eslint.org/docs/latest/contribute/core-rules#rule-naming-conventions)
-and consistently use dashes to separate words (instead of underscores), and prefix
-all rules that disallow something with `no-`.
-
-## Testing the rules
-
-When writing a custom ESLint rule, place the logic into a file `lib/foo.js` and
-add a corresponding test for the logic to `tests/foo.test.js`.
-
-You can use
-
-```
-npm run test -- ./scripts/eslint_rules/tests
-```
-
-to run the tests for the custom ESLint rules.

package/scripts/eslint_rules/lib/canvas-context-tracking.ts

@@ -1,154 +0,0 @@
-// Copyright 2023 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type {TSESTree} from '@typescript-eslint/utils';
-
-import {createRule} from './utils/ruleCreator.ts';
-
-type Node = TSESTree.Node;
-type MemberExpression = TSESTree.MemberExpression;
-type BlockStatement = TSESTree.BlockStatement;
-type ForStatement = TSESTree.ForStatement;
-type ForInStatement = TSESTree.ForInStatement;
-type ForOfStatement = TSESTree.ForOfStatement;
-type SwitchStatement = TSESTree.SwitchStatement;
-type CatchClause = TSESTree.CatchClause;
-type StaticBlock = TSESTree.StaticBlock;
-
-type CanvasCall = 'save'|'restore';
-
-export default createRule({
-  name: 'canvas-context-tracking',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Track context.save() and context.restores() across scopes',
-      category: 'Possible Errors',
-    },
-    fixable: 'code',
-    messages: {
-      saveNotRestored: 'Found a block that has more context.save() calls than context.restore() calls',
-      uselessRestore: 'Found a context.restore() call with no context.save() prior to it',
-    },
-    schema: [],  // no options
-  },
-  defaultOptions: [],
-  create: function(context) {
-    // To track canvas calls across scopes we keep a stack which we push nodes on with every new scope that we find.
-    // When we then leave a scope, we can check all the calls in that scope and see if they align or not.
-    let stack: Node[] = [];
-
-    // The key is a node's range as a string. The value is a stack of
-    // context.save calls. When we see a restore, we pop the stack. Therefore,
-    // if we get to the end of a scope and the stack is not empty, it means the
-    // user has not balanced their calls correctly.
-    const scopeToCanvasCalls = new Map<string, CanvasCall[]>();
-
-    function nodeToKeyForMap(node: Node): string {
-      return JSON.stringify(node.range);
-    }
-
-    function enterScope(node: Node): void {
-      stack.push(node);
-    }
-
-    /**
-     * Pops the last block scope and checks it for a mismatch of save and restore calls.
-     */
-    function exitScope(): void {
-      const lastScope = stack.pop();
-      if (!lastScope) {
-        return;
-      }
-
-      const stackForCurrentScope = scopeToCanvasCalls.get(
-          nodeToKeyForMap(lastScope),
-      );
-
-      // We have no issues to report if:
-      // 1. No calls to save() or restore().
-      // 2. The amount of save() and restore() calls balanced perfectly, leaving the stack empty.
-      if (!stackForCurrentScope || stackForCurrentScope.length === 0) {
-        return;
-      }
-
-      // If we got here it means the stack for the scope has items in, which means that it is unbalanced.
-      context.report({
-        node: lastScope,
-        messageId: 'saveNotRestored',
-      });
-    }
-
-    /**
-     * Updates the counter for the current scope.
-     * @param {'save'|'restore'} methodName
-     **/
-    function trackContextCall(methodName: CanvasCall): void {
-      const currentScopeNode = stack.at(-1);
-      if (!currentScopeNode) {
-        return;
-      }
-      const currentScopeKey = nodeToKeyForMap(currentScopeNode);
-      const stackForCurrentScope = scopeToCanvasCalls.get(currentScopeKey) || [];
-
-      if (methodName === 'save') {
-        stackForCurrentScope.push('save');
-      } else if (methodName === 'restore') {
-        // If we get a restore() call but the stack is empty, this means that
-        // we have nothing to restore as we did not save anything in this
-        // scope. Either the user has forgotten a save() call, or this
-        // restore() has been accidentally left behind after a refactor and
-        // should be removed.
-        if (stackForCurrentScope.length === 0) {
-          context.report({
-            messageId: 'uselessRestore',
-            // Report on the specific call if possible, otherwise the scope.
-            // The original code reported on currentScopeNode.
-            node: currentScopeNode,
-          });
-        } else {
-          // Pop the stack, so that the last save() is accounted for.
-          stackForCurrentScope.pop();
-        }
-      }
-
-      scopeToCanvasCalls.set(
-          currentScopeKey,
-          stackForCurrentScope,
-      );
-    }
-
-    return {
-      Program(node) {
-        stack = [node];
-        // Initialize map for the program scope
-        scopeToCanvasCalls.set(nodeToKeyForMap(node), []);
-      },
-      MemberExpression(node: MemberExpression) {
-        const methodCallsToTrack = ['save', 'restore'];
-        if (node.object.type === 'Identifier' && node.object?.name === 'context' &&
-            node.property.type === 'Identifier' &&
-            // Use type assertion because .includes doesn't narrow the type
-            methodCallsToTrack.includes(node.property?.name as CanvasCall)) {
-          trackContextCall(node.property.name as CanvasCall);
-        }
-      },
-      // All the different types of scope we have to deal with.
-      BlockStatement: (node: BlockStatement) => enterScope(node),
-      'BlockStatement:exit': exitScope,
-      ForStatement: (node: ForStatement) => enterScope(node),
-      'ForStatement:exit': exitScope,
-      ForInStatement: (node: ForInStatement) => enterScope(node),
-      'ForInStatement:exit': exitScope,
-      ForOfStatement: (node: ForOfStatement) => enterScope(node),
-      'ForOfStatement:exit': exitScope,
-      SwitchStatement: (node: SwitchStatement) => enterScope(node),
-      'SwitchStatement:exit': exitScope,
-      CatchClause: (node: CatchClause) => enterScope(node),
-      'CatchClause:exit': exitScope,
-      StaticBlock: (node: StaticBlock) => enterScope(node),
-      'StaticBlock:exit': exitScope,
-    };
-  },
-});

package/scripts/eslint_rules/lib/check-css-import.ts

@@ -1,52 +0,0 @@
-// Copyright 2021 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-/**
- * @fileoverview Prevent usage of customElements.define() and use the helper
- * function instead
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-import {createRule} from './utils/ruleCreator.ts';
-
-export default createRule({
-  name: 'check-css-import',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'check CSS file imports',
-      category: 'Possible Errors',
-    },
-    fixable: 'code',
-    messages: {
-      fileDoesNotExist: 'File {{filename}} does not exist. Check you are importing the correct file.',
-    },
-    schema: [],  // no options
-  },
-  defaultOptions: [],
-  create: function(context) {
-    const filename = context.getFilename();
-    return {
-      ImportDeclaration(node) {
-        const importPath = path.normalize(`${node.source.value}`);
-
-        if (importPath.endsWith('.css.js')) {
-          const importingFileName = path.resolve(filename);
-          const exportingFileName = path.resolve(path.dirname(importingFileName), importPath);
-          const importedCSS = exportingFileName.replace(/\.js$/, '');
-
-          if (!fs.existsSync(importedCSS)) {
-            context.report({
-              node,
-              messageId: 'fileDoesNotExist',
-              data: {filename: path.basename(importedCSS)},
-            });
-          }
-        }
-      },
-    };
-  },
-});

package/scripts/eslint_rules/lib/check-enumerated-histograms.ts

@@ -1,42 +0,0 @@
-// Copyright 2020 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import {createRule} from './utils/ruleCreator.ts';
-
-export default createRule({
-  name: 'check-enumerated-histograms',
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'check arguments when recording enumerated histograms',
-      category: 'Possible Errors',
-    },
-    fixable: 'code',
-    messages: {
-      invalidArgument:
-          'When calling \'recordEnumeratedHistogram\' the third argument should be of the form \'SomeEnum.MAX_VALUE\'.',
-    },
-    schema: [],  // no options
-  },
-  defaultOptions: [],
-  create: function(context) {
-    return {
-      CallExpression(node) {
-        if (node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' &&
-            node.callee.object.name === 'InspectorFrontendHostInstance' && node.callee.property.type === 'Identifier' &&
-            node.callee.property.name === 'recordEnumeratedHistogram') {
-          const argumentNode = node.arguments[2];
-
-          if (argumentNode.type !== 'MemberExpression' || argumentNode.property.type !== 'Identifier' ||
-              argumentNode.property.name !== 'MAX_VALUE') {
-            context.report({
-              node,
-              messageId: 'invalidArgument',
-            });
-          }
-        }
-      },
-    };
-  },
-});