npm - chrome-devtools-frontend - Versions diffs - 1.0.946920 → 1.0.948445 - Mend

chrome-devtools-frontend 1.0.946920 → 1.0.948445

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (201) hide show

package/front_end/third_party/lighthouse/report-assets/standalone-template.html DELETED Viewed

@@ -1,38 +0,0 @@
-<!--
-@license
-Copyright 2018 The Lighthouse Authors. All Rights Reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS-IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1">
-  <link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAEhklEQVR4AWJxL/BhIAesev1U5tcflpncgNrKIsqNIwzC9feMpDUzs70kOczMzMzJJcxwCTMzncPMnOwtzBwzMzPb0vRfeZPp0VhPS5I39V5fdiXV1/VD+9QC7OVn9BsyH1XIoEI1PfmJvLFowVV564+34DFUHudbmfDh4kVXh//7XwE+WjS/YfXZe3yr4j2rqj1AIhSB7hZ8ZtPZu/zw8cK523U4wE1/rvPfWrz4zs0m9ZdC9yUJAlASdBAgocRegfF/f3/h/PuaFsxMdwjAR0vm1+06eMMfIrhLqTWqdH4EumU2SPfMhigJAlRQbZrgrRsl9U+Y2DYDFCz3ILC9kiAiqSrMwbWT0nceEnR+9Kggc2zjOJCASDENkg0a5HfZZgDP81CM3CrQs2Z1+o7DJ6ePr8sK0AOCHv5Jjdt3evyYSaZ351VIStIxPRAUtrBYbxC6w+BZ0ivVSBKkIhJhemSyZpfB00EiPO2VjzYkxhcqXQqCWCShGplvi3y0QxqbuBurMjyJeWnkHZuAEgIQGsUBqwrfjZ+IlBgKyRJzVVYF8O6qFWdh86YzQzMrZigYmxAyfvHgLZQ/LC1CbeniW2Hkqr/PH16SgvGuf2/uzNMBwJA/njxizGPtSyAf7EziJCMGRDRdhoAC4PL1A/SrKQMAAQkEfpJAcRQdrBJ7gNwjSpJsdwK+CANBkqa1LgQB4IicV9nYUct7gaxuDJUErQIiEAiMxLVOFlKzIktPpT0ggpdpC/8YAHnxbgkUY4tAAFSR7AAXNyAAWHJrA/kHGjzg5nleuwFO7Nd/IoDw4Pm58+4jNLmYG0wRA5bErc2Mr3Y+dXTDW1VvwqbJkzMCHQ4S1GTCBOIgUHJrGdEwqzR+jAp/o2qAZelUDoQnruEEdDclJI6576AlNVfc+22XN/+Y1vnJD0Yind6UpEEvn/Hqq15EYjCW7jZCJEpnNvDgkyelDjs106kuux2AAXCSobULOWP8mLhYlpoDMK4qAFXJGk+grtH8YXVz5KJblqaG1+VUdTc0I290bmUQAriGITRbdQnom0aoFj8kx1+wMD2ifncAXUQE4SkDqN1hE0jEophs1SUwZAOhUAiMCLwRtamtTZtbbmZErSAUHbSysaoEmnrsakiMiUAURi283gN6wans9oX8rOCrj7/JP35DFD+iQ7Au/K2KE1jzx6ujjUnXFH9KjEq6ZlhsTBICrNLJf47Pv/pkHzvup1w4dmUbEei0+bcXRqJuh5kVARQ8byyYxOwNGr7A87xh1tp8sGT+uMInrwi++Xj7TQz2d27NvwEkrOflAFQGIDA5khASBCGdO2/Z/MnLPwYfv5TFhjW7QhVKAB6afwe2LpFlFsCnlQEosgQgDsdOG1/LKeNqJS4JCSPJ/i+TakwEARor7gER1Iva5JmPOJK0RUqmoPnnlzFCtmIAhAAQEIQRgDaiYPIauNXcnDlRIrWNFY3hm7PG9YRqr7IV7HrCgAC17befjEvRq2nGhAHtBqDpOuI/I1diUUAMYIxEdyejBJqLnNoszGZtfiX/CztGv2mq+sdaAAAAAElFTkSuQmCC">
-  <title>Lighthouse Report</title>
-  <style>body {margin: 0}</style>
-</head>
-<body>
-  <noscript>Lighthouse report requires JavaScript. Please enable.</noscript>
-  <div id="lh-log"></div>
-  <script>window.__LIGHTHOUSE_JSON__ = %%LIGHTHOUSE_JSON%%;</script>
-  <script>%%LIGHTHOUSE_JAVASCRIPT%%
-  __initLighthouseReport__();
-  //# sourceURL=compiled-reportrenderer.js
-  </script>
-  <script>console.log('window.__LIGHTHOUSE_JSON__', __LIGHTHOUSE_JSON__);</script>
-</body>
-</html>

package/front_end/ui/components/helpers/get-stylesheet.ts DELETED Viewed

@@ -1,45 +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 * as Root from '../../../core/root/root.js';
-const sheetsCache = new Map<string, {sheets: CSSStyleSheet[]}>();
-/**
- * Helper for importing a legacy stylesheet into a component.
- *
- * Given a path to a stylesheet, it returns a CSSStyleSheet that can then be
- * adopted by your component.
- */
-export function legacyGetStyleSheets(path: string): CSSStyleSheet[] {
-  const cachedResult = sheetsCache.get(path);
-  if (cachedResult) {
-    return cachedResult.sheets;
-  }
-  const content = Root.Runtime.cachedResources.get(path) || '';
-  if (!content) {
-    throw new Error(`${path} not preloaded.`);
-  }
-  const originalStylesheet = new CSSStyleSheet();
-  originalStylesheet.replaceSync(content);
-  sheetsCache.set(path, {sheets: [originalStylesheet]});
-  return [originalStylesheet];
-}
-/*
- * This is now legacy. Please do not add any more CSS Files to this list. Refer to
- * https://crbug.com/1106746 for the new way of implementing CSS in DevTools.
- *
- * The legacyGetStylesheet helper in components reads styles out of the runtime cache.
- * In a proper build this is populated but in test runs because we don't load
- * all of DevTools it's not. Therefore we fetch the required CSS files and populate
- * the cache before any tests are run.
- *
- * The out/Release/gen/front_end URL is prepended so within the Karma config we can proxy
- * them through to the right place, respecting Karma's ROOT_DIRECTORY setting.
- */
-export const CSS_RESOURCES_TO_LOAD_INTO_RUNTIME = [
-  'panels/application/serviceWorkerUpdateCycleView.css',
-];

package/scripts/build/build_release_applications.py DELETED Viewed

@@ -1,216 +0,0 @@
-#!/usr/bin/env vpython
-# -*- coding: utf-8 -*-
-#
-# Copyright 2016 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.
-"""
-Builds applications in release mode:
-- Concatenates autostart modules, application modules' module.json descriptors,
-and the application loader into a single script.
-"""
-from io import StringIO
-from os import path
-from os.path import join
-import copy
-import os
-import re
-import shutil
-import sys
-import subprocess
-from modular_build import read_file, write_file, bail_error
-import modular_build
-import rjsmin
-try:
-    import simplejson as json
-except ImportError:
-    import json
-try:
-    original_sys_path = sys.path
-    sys.path = sys.path + [path.join(os.path.dirname(os.path.realpath(__file__)), '..')]
-    import devtools_paths
-finally:
-    sys.path = original_sys_path
-FRONT_END_DIRECTORY = path.join(os.path.dirname(path.abspath(__file__)), '..', '..', 'front_end')
-def main(argv):
-    try:
-        input_path_flag_index = argv.index('--input_path')
-        input_path = argv[input_path_flag_index + 1]
-        output_path_gen_flag_index = argv.index('--output_path_gen')
-        output_path_gen = argv[output_path_gen_flag_index + 1]
-        application_names = argv[1:input_path_flag_index]
-        use_rollup = '--rollup' in argv
-    except:
-        print('Usage: %s app_1 app_2 ... app_N --input_path <input_path> --output_path <output_path> --rollup true' % argv[0])
-        raise
-    loader = modular_build.DescriptorLoader(input_path)
-    for app in application_names:
-        descriptors = loader.load_application(app)
-        builder = ReleaseBuilder(app, descriptors, input_path, output_path_gen,
-                                 use_rollup)
-        builder.build_app()
-def resource_source_url(url):
-    return '\n/*# sourceURL=' + url + ' */'
-def minify_js(javascript):
-    return rjsmin.jsmin(javascript)
-def concatenated_module_filename(module_name, output_dir):
-    return join(output_dir,
-                module_name + '/' + path.basename(module_name) + '_module.js')
-# Outputs:
-#   <app_name>.js
-#   <module_name>_module.js
-class ReleaseBuilder(object):
-    def __init__(self, application_name, descriptors, application_dir,
-                 output_path_gen_dir, use_rollup):
-        self.application_name = application_name
-        self.descriptors = descriptors
-        self.application_dir = application_dir
-        self.output_path_gen_dir = output_path_gen_dir
-        self.use_rollup = use_rollup
-    def app_file(self, extension):
-        return path.join('entrypoints', self.application_name,
-                         self.application_name + '.' + extension)
-    def autorun_resource_names(self):
-        result = []
-        for module in self.descriptors.sorted_modules():
-            if self.descriptors.application[module].get('type') != 'autostart':
-                continue
-            resources = self.descriptors.modules[module].get('resources')
-            if not resources:
-                continue
-            for resource_name in resources:
-                result.append(path.join(module, resource_name))
-        return result
-    def build_app(self):
-        self._build_app_script()
-        for module in filter(lambda desc: (not desc.get('type')),
-                             self.descriptors.application.values()):
-            self._concatenate_dynamic_module(module['name'])
-    def _build_app_script(self):
-        script_name = self.app_file('js')
-        output = StringIO()
-        self._concatenate_application_script(output)
-        minified_content = minify_js(output.getvalue())
-        write_file(join(self.output_path_gen_dir, script_name),
-                   minified_content)
-        output.close()
-    def _release_module_descriptors(self):
-        module_descriptors = self.descriptors.modules
-        result = []
-        for name in module_descriptors:
-            module = copy.copy(module_descriptors[name])
-            module_type = self.descriptors.application[name].get('type')
-            resources = module.get('resources', None)
-            if resources:
-                # Resources are already baked into _module.
-                del module['resources']
-                if not module_type == 'autostart':
-                    # We load the entrypoint of a module no matter what.
-                    # Therefore, we don't need to declare any files for
-                    # the default case. However, if a module still has
-                    # a legacy file, the Runtime performs an array
-                    # contains check and will load that instead.
-                    module_files_to_load = []
-                    declared_module_files = module.get('modules', [])
-                    legacyFileName = path.basename(name) + '-legacy.js'
-                    if legacyFileName in declared_module_files:
-                        module_files_to_load += [legacyFileName]
-                    # Non-autostart modules are vulcanized.
-                    module['modules'] = [path.basename(name) + '_module.js'
-                                         ] + module_files_to_load
-            result.append(module)
-        return json.dumps(result)
-    def _write_module_resources(self, resource_names, output):
-        for resource_name in resource_names:
-            resource_name = path.normpath(resource_name).replace('\\', '/')
-            output.write('RootModule.Runtime.cachedResources.set("%s", "' %
-                         resource_name)
-            resource_content = read_file(path.join(self.application_dir, resource_name))
-            if not (resource_name.endswith('.html')
-                    or resource_name.endswith('md')):
-                resource_content += resource_source_url(resource_name)
-            resource_content = resource_content.replace('\\', '\\\\')
-            resource_content = resource_content.replace('\n', '\\n')
-            resource_content = resource_content.replace('"', '\\"')
-            output.write(resource_content)
-            output.write('");\n')
-    def _concatenate_autostart_modules(self, output):
-        non_autostart = set()
-        sorted_module_names = self.descriptors.sorted_modules()
-        for name in sorted_module_names:
-            desc = self.descriptors.modules[name]
-            name = desc['name']
-            type = self.descriptors.application[name].get('type')
-            if type == 'autostart':
-                deps = set(desc.get('dependencies', []))
-                non_autostart_deps = deps & non_autostart
-                if len(non_autostart_deps):
-                    bail_error(
-                        'Non-autostart dependencies specified for the autostarted module "%s": %s' % (name, non_autostart_deps))
-            else:
-                non_autostart.add(name)
-    def _concatenate_application_script(self, output):
-        output.write('Root.allDescriptors.push(...%s);' % self._release_module_descriptors())
-        if self.descriptors.extends:
-            output.write(
-                'Root.applicationDescriptor.modules.push(...%s);' %
-                json.dumps(list(self.descriptors.application.values())))
-        else:
-            output.write('Root.applicationDescriptor = %s;' % self.descriptors.application_json())
-        output.write("import * as RootModule from '../../core/root/root.js';")
-        self._write_module_resources(self.autorun_resource_names(), output)
-        output.write(minify_js(read_file(join(self.application_dir, self.app_file('js')))))
-        self._concatenate_autostart_modules(output)
-    def _concatenate_dynamic_module(self, module_name):
-        module = self.descriptors.modules[module_name]
-        modules = module.get('modules')
-        resources = self.descriptors.module_resources(module_name)
-        module_dir = join(self.application_dir, module_name)
-        output = StringIO()
-        if resources:
-            relative_file_name = '../core/root/root.js'
-            if "/" in module_name:
-                relative_file_name = (
-                    '../' * module_name.count('/')) + relative_file_name
-            output.write("import * as RootModule from '%s';" %
-                         relative_file_name)
-            self._write_module_resources(resources, output)
-        minified_content = minify_js(output.getvalue())
-        write_file(
-            concatenated_module_filename(module_name,
-                                         self.output_path_gen_dir),
-            minified_content)
-        output.close()
-if __name__ == '__main__':
-    sys.exit(main(sys.argv))

package/scripts/build/modular_build.py DELETED Viewed

@@ -1,184 +0,0 @@
-#!/usr/bin/env vpython
-#
-# Copyright 2014 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.
-"""
-Utilities for the modular DevTools build.
-"""
-from __future__ import print_function
-import collections
-from os import path
-import os
-try:
-    import simplejson as json
-except ImportError:
-    import json
-def read_file(filename):
-    with open(path.normpath(filename), 'rt', encoding='utf-8') as input:
-        return input.read()
-def write_file(filename, content):
-    if path.exists(filename):
-        os.remove(filename)
-    directory = path.dirname(filename)
-    if not path.exists(directory):
-        os.makedirs(directory)
-    with open(filename, 'wt', encoding='utf-8') as output:
-        output.write(content)
-def bail_error(message):
-    raise Exception(message)
-def load_and_parse_json(filename):
-    try:
-        return json.loads(read_file(filename))
-    except:
-        print('ERROR: Failed to parse %s' % filename)
-        raise
-class Descriptors:
-    def __init__(self, application_name, application_dir,
-                 application_descriptor, module_descriptors, extends, worker):
-        self.application_name = application_name
-        self.application_dir = application_dir
-        self.application = application_descriptor
-        self._cached_sorted_modules = None
-        self.modules = module_descriptors
-        self.extends = extends
-        self.worker = worker
-    def application_json(self):
-        result = dict()
-        result['modules'] = list(self.application.values())
-        return json.dumps(result)
-    def module_resources(self, name):
-        return [name + '/' + resource for resource in self.modules[name].get('resources', [])]
-    def sorted_modules(self):
-        if self._cached_sorted_modules:
-            return self._cached_sorted_modules
-        result = []
-        # Use dict instead of set for deterministic iteration order.
-        unvisited_modules = {module: None for module in self.modules}
-        temp_modules = set()
-        def visit(parent, name):
-            if name not in unvisited_modules:
-                return None
-            if name not in self.modules:
-                return (parent, name)
-            if name in temp_modules:
-                bail_error('Dependency cycle found at module "%s"' % name)
-            temp_modules.add(name)
-            deps = self.modules[name].get('dependencies')
-            if deps:
-                for dep_name in deps:
-                    bad_dep = visit(name, dep_name)
-                    if bad_dep:
-                        return bad_dep
-            del unvisited_modules[name]
-            temp_modules.remove(name)
-            result.append(name)
-            return None
-        while len(unvisited_modules):
-            for next in unvisited_modules:
-                break
-            failure = visit(None, next)
-            if failure:
-                # failure[0] can never be None
-                bail_error('Unknown module "%s" encountered in dependencies of "%s"' % (failure[1], failure[0]))
-        self._cached_sorted_modules = result
-        return result
-    def sorted_dependencies_closure(self, module_name):
-        visited = set()
-        def sorted_deps_for_module(name):
-            result = []
-            desc = self.modules[name]
-            deps = desc.get('dependencies', [])
-            for dep in deps:
-                result += sorted_deps_for_module(dep)
-            if name not in visited:
-                result.append(name)
-                visited.add(name)
-            return result
-        return sorted_deps_for_module(module_name)
-class DescriptorLoader:
-    def __init__(self, application_dir):
-        self.application_dir = application_dir
-    def load_application(self, application_descriptor_name):
-        all_module_descriptors = {}
-        result = self._load_application(application_descriptor_name, all_module_descriptors)
-        return result
-    def load_applications(self, application_descriptor_names):
-        all_module_descriptors = {}
-        all_application_descriptors = {}
-        for application_descriptor_name in application_descriptor_names:
-            descriptors = {}
-            result = self._load_application(application_descriptor_name, descriptors)
-            for name in descriptors:
-                all_module_descriptors[name] = descriptors[name]
-            for name in result.application:
-                all_application_descriptors[name] = result.application[name]
-        return Descriptors('all', self.application_dir,
-                           all_application_descriptors, all_module_descriptors,
-                           None, False)
-    def _load_application(self, application_descriptor_name, all_module_descriptors):
-        module_descriptors = {}
-        application_descriptor_filename = path.join(
-            self.application_dir, 'entrypoints', application_descriptor_name,
-            application_descriptor_name + '.json')
-        descriptor_json = load_and_parse_json(application_descriptor_filename)
-        application_descriptor = {desc['name']: desc for desc in descriptor_json['modules']}
-        extends = descriptor_json['extends'] if 'extends' in descriptor_json else None
-        if extends:
-            extends = self._load_application(extends, all_module_descriptors)
-        worker = True if 'worker' in descriptor_json and descriptor_json['worker'] else False
-        for (module_name, module) in application_descriptor.items():
-            if all_module_descriptors.get(module_name):
-                bail_error('Duplicate definition of module "%s" in %s' % (module_name, application_descriptor_filename))
-            module_descriptors[module_name] = self._read_module_descriptor(module_name, application_descriptor_filename)
-            all_module_descriptors[module_name] = module_descriptors[module_name]
-        for module in module_descriptors.values():
-            for dep in module.get('dependencies', []):
-                if dep not in all_module_descriptors:
-                    bail_error('Module "%s" (dependency of "%s") not listed in application descriptor %s' %
-                               (dep, module['name'], application_descriptor_filename))
-        return Descriptors(application_descriptor_name, self.application_dir,
-                           application_descriptor, module_descriptors, extends,
-                           worker)
-    def _read_module_descriptor(self, module_name, application_descriptor_filename):
-        json_filename = path.join(self.application_dir, module_name, 'module.json')
-        if not path.exists(json_filename):
-            bail_error('Module descriptor %s referenced in %s is missing' % (json_filename, application_descriptor_filename))
-        module_json = load_and_parse_json(json_filename)
-        module_json['name'] = module_name
-        return module_json

package/scripts/check_gn.js DELETED Viewed

@@ -1,119 +0,0 @@
-// Copyright 2017 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.
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const FRONTEND_PATH = path.resolve(__dirname, '..', 'front_end');
-const manifestModules = [];
-for (const config of ['inspector', 'devtools_app', 'js_app', 'worker_app']) {
-  manifestModules.push(...require(path.resolve(FRONTEND_PATH, 'entrypoints', config, `${config}.json`)).modules);
-}
-const gnPath = path.resolve(__dirname, '..', 'BUILD.gn');
-const gnFile = fs.readFileSync(gnPath, 'utf-8');
-const gnLines = gnFile.split('\n');
-/**
- * Ensures that all source files (according to the various module.json files) are
- * listed in BUILD.gn.
- */
-function checkAllDevToolsFiles() {
-  return checkGNVariable('all_devtools_files', 'all_devtools_files', moduleJSON => {
-    const resources = moduleJSON.resources || [];
-    return [
-      'module.json',
-      ...resources,
-    ];
-  });
-}
-function checkGNVariable(fileName, gnVariable, obtainFiles, obtainRelativePath) {
-  const filePath = path.resolve(__dirname, '..', 'config', 'gni', `${fileName}.gni`);
-  const fileContent = fs.readFileSync(filePath, 'utf-8');
-  const linesToCheck = fileContent.split('\n');
-  const errors = [];
-  const excludedFiles =
-      ['axe.js', 'entrypoints/formatter_worker/', 'third_party/lighthouse/', 'third_party/i18n/'].map(path.normalize);
-  const lines = selectGNLines(`${gnVariable} = [`, ']', linesToCheck).map(path.normalize);
-  if (!lines.length) {
-    return [
-      `Could not identify ${gnVariable} list in gn file`,
-      'Please look at: ' + __filename,
-    ];
-  }
-  const gnFiles = new Set(lines);
-  let moduleFiles = [];
-  function addModuleFilesForDirectory(moduleJSONPath, buildGNPath, folderName) {
-    const moduleJSON = require(moduleJSONPath);
-    const files = obtainFiles(moduleJSON, folderName)
-                      .map(obtainRelativePath && obtainRelativePath(buildGNPath) || relativePathFromBuildGN)
-                      .filter(file => excludedFiles.every(excludedFile => !file.includes(excludedFile)));
-    moduleFiles = moduleFiles.concat(files);
-    function relativePathFromBuildGN(filename) {
-      const relativePath = path.normalize(`front_end/${buildGNPath}/${filename}`);
-      return `"${relativePath}",`;
-    }
-  }
-  function traverseDirectoriesForModuleJSONFiles(folderName, buildGNPath) {
-    if (!fs.lstatSync(folderName).isDirectory()) {
-      return;
-    }
-    const moduleJSONPath = path.join(folderName, 'module.json');
-    if (fs.existsSync(moduleJSONPath)) {
-      addModuleFilesForDirectory(moduleJSONPath, buildGNPath, path.basename(folderName));
-    }
-    fs.readdirSync(folderName).forEach(nestedModuleName => {
-      traverseDirectoriesForModuleJSONFiles(
-          path.join(folderName, nestedModuleName), `${buildGNPath}/${nestedModuleName}`);
-    });
-  }
-  fs.readdirSync(FRONTEND_PATH).forEach(moduleName => {
-    traverseDirectoriesForModuleJSONFiles(path.join(FRONTEND_PATH, moduleName), moduleName);
-  });
-  for (const file of moduleFiles) {
-    if (!gnFiles.has(file)) {
-      errors.push(`Missing file in BUILD.gn for ${gnVariable}: ` + file);
-    }
-  }
-  return errors;
-}
-function selectGNLines(startLine, endLine, linesToCheck = gnLines) {
-  const lines = linesToCheck.map(line => line.trim());
-  const startIndex = lines.indexOf(startLine);
-  if (startIndex === -1) {
-    return [];
-  }
-  const endIndex = lines.indexOf(endLine, startIndex);
-  if (endIndex === -1) {
-    return [];
-  }
-  return lines.slice(startIndex + 1, endIndex);
-}
-function main() {
-  const errors = [
-    ...checkAllDevToolsFiles(),
-  ];
-  if (errors.length) {
-    console.log('DevTools BUILD.gn checker detected errors!');
-    console.log(`There's an issue with: ${gnPath}`);
-    console.log(errors.join('\n'));
-    process.exit(1);
-  }
-  console.log('DevTools BUILD.gn checker passed');
-}
-main();

package/scripts/json_validator/module.schema.json DELETED Viewed

@@ -1,19 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-04/schema#",
-  "type": "object",
-  "additionalProperties": false,
-  "properties": {
-    "dependencies": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    },
-    "resources": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      }
-    }
-  }
-}

package/scripts/json_validator/validate_module_json.js DELETED Viewed

@@ -1,44 +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.
-const fs = require('fs');
-const path = require('path');
-const FRONTEND_PATH = path.resolve(__dirname, '..', '..', 'front_end');
-const modules = [];
-for (const dir of fs.readdirSync(FRONTEND_PATH)) {
-  if (!fs.lstatSync(path.resolve(FRONTEND_PATH, dir)).isDirectory()) {
-    continue;
-  }
-  if (fs.existsSync(path.resolve(FRONTEND_PATH, dir, 'module.json'))) {
-    modules.push(dir);
-  }
-}
-const Ajv = require('ajv');
-const ajv = new Ajv({schemaId: 'id'});
-// This seems to be the most widely supported version of the schema.
-ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json'));
-const schema = JSON.parse(fs.readFileSync(path.resolve(__dirname, 'module.schema.json')));
-const validate = ajv.compile(schema);
-let totalErrors = 0;
-for (const module of modules) {
-  const moduleObject = JSON.parse(fs.readFileSync(path.resolve(FRONTEND_PATH, module, 'module.json')));
-  const valid = validate(moduleObject);
-  if (!valid) {
-    console.log('Issue with ./front_end/' + module + '/module.json:');
-    totalErrors++;
-    validate.errors.sort((a, b) => b.dataPath.length - a.dataPath.length);
-    const error = validate.errors[0];
-    console.log('  ', error.dataPath, error.message, error.params);
-    console.log('');
-  }
-}
-if (totalErrors) {
-  console.log('module.json errors:', totalErrors);
-}
-process.exit(totalErrors);