chrome-devtools-frontend 1.0.962581 → 1.0.964938

package/scripts/build/rollup.config.js

@@ -5,41 +5,10 @@
 // @ts-check
 
 import {defaultStrategy} from 'minify-html-literals/src/strategy';  // eslint-disable-line rulesdir/es_modules_import
-import * as path from 'path';
 import minifyHTML from 'rollup-plugin-minify-html-template-literals';
 import {terser} from 'rollup-plugin-terser';
 
-/**
- * `path.dirname` does not include trailing slashes. If we would always
- * use `path.dirname` and then later perform comparisons on the paths that
- * it returns, we could run into false positives. For example, given the
- * the following two paths:
- *
- *     front_end/timeline_model/TimelineModel.js
- *     front_end/timeline/Timeline.js
- *
- * And that would have the following values for `path.dirname`:
- *
- *     front_end/timeline_model
- *     front_end/timeline
- *
- * If we would do a simple `.startswith` on the `path.dirname` of both of
- * these paths, then the first path would start with the dirname of the
- * second. However, they *are* part of different folders. To fix that problem,
- * we need to force a path separator after each folder. That makes sure we
- * and up with the following comparison of path dirnames:
- *
- *     front_end/timeline_model/
- *     front_end/timeline/
- *
- * Now, the first path does *not* start with the second one, as expected.
- *
- * @param {string} file
- * @return {string}
- */
-function dirnameWithSeparator(file) {
-  return path.dirname(file) + path.sep;
-}
+const devtools_plugin = require('./devtools_plugin.js');
 
 /**
  * @type {import("minify-html-literals").Strategy<import("html-minifier").Options, unknown>}
@@ -91,67 +60,8 @@ export default commandLineArgs => ({
     {
       name: 'devtools-plugin',
       resolveId(source, importer) {
-        if (!importer) {
-          return null;
-        }
-        const currentDirectory = path.normalize(dirnameWithSeparator(importer));
-        const importedFilelocation = path.normalize(path.join(currentDirectory, source));
-        const importedFileDirectory = dirnameWithSeparator(importedFilelocation);
-
-        // Generated files are part of other directories, as they are only imported once
-        if (path.basename(importedFileDirectory) === 'generated') {
-          return null;
-        }
-
-        // An import is considered external (and therefore a separate
-        // bundle) if its filename matches its immediate parent's folder
-        // name (without the extension). For example:
-        // import * as Components from './components/components.js' = external
-        // import * as UI from '../ui/ui.js' = external
-        // import * as LitHtml from '../third_party/lit-html/lit-html.js' = external
-        // import {DataGrid} from './components/DataGrid.js' = not external
-        // import * as Components from './components/foo.js' = not external
-
-        // Note that we can't do a simple check for only `third_party`, as in Chromium
-        // our full path is `third_party/devtools-frontend/src/`, which thus *always*
-        // includes third_party. It also not possible to use the current directory
-        // as a check for the import, as the import will be different in Chromium and
-        // would therefore not match the path of `__dirname`.
-        // These should be removed because the new heuristic _should_ deal with these
-        // e.g. it'll pick up third_party/lit-html/lit-html.js is its own entrypoint
-
-        // Puppeteer has dynamic imports in its build gated on an ifNode
-        // flag, but our Rollup config doesn't know about that and tries
-        // to parse dynamic import('fs'). Let's ignore Puppeteer for now.
-        // The long term plan is probably for Puppeteer to ship a web
-        // bundle anyway. See go/pptr-agnostify for details.
-        if (importedFileDirectory.includes(path.join('front_end', 'third_party', 'puppeteer'))) {
-          return null;
-        }
-
-        // The CodeMirror addons look like bundles (addon/comment/comment.js) but are not.
-        if (importedFileDirectory.includes(path.join('front_end', 'third_party', 'codemirror', 'package'))) {
-          return null;
-        }
-
-        // The LightHouse bundle shouldn't be processed by `terser` again, as it is uniquely built
-        if (importedFilelocation.includes(
-                path.join('front_end', 'third_party', 'lighthouse', 'lighthouse-dt-bundle.js'))) {
-          return {
-            id: importedFilelocation,
-            external: true,
-          };
-        }
-
-        const importedFileName = path.basename(importedFilelocation, '.js');
-        const importedFileParentDirectory = path.basename(path.dirname(importedFilelocation));
-        const isExternal = importedFileName === importedFileParentDirectory;
-
-        return {
-          id: importedFilelocation,
-          external: isExternal,
-        };
-      }
+        return devtools_plugin.devtoolsPlugin(source, importer);
+      },
     },
   ]
 });

package/scripts/devtools_paths.js

@@ -59,8 +59,9 @@ function isInChromiumDirectory() {
   }
 
   const normalizedPath = PATH_TO_EXECUTED_FILE.split(path.sep).join('/');
-  const isInChromium = normalizedPath.includes('chromium/src/third_party/devtools-frontend');
-  const potentialChromiumDir = PATH_TO_EXECUTED_FILE.substring(0, PATH_TO_EXECUTED_FILE.indexOf('chromium') + 8);
+  const devtoolsPath = 'src/third_party/devtools-frontend';
+  const isInChromium = normalizedPath.includes(devtoolsPath);
+  const potentialChromiumDir = PATH_TO_EXECUTED_FILE.substring(0, PATH_TO_EXECUTED_FILE.indexOf(devtoolsPath));
   const result = {isInChromium, chromiumDirectory: potentialChromiumDir};
   _lookUpCaches.set('chromium', result);
   return result;

package/scripts/javascript_natives/helpers.js

@@ -0,0 +1,211 @@
+// 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.
+
+// @ts-check
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {fileURLToPath} from 'url';
+
+/** @type {Map<string, Map<string, string[][]>>} */
+const methods = new Map();
+
+export function clearState() {
+  methods.clear();
+}
+
+export function parseTSFunction(func, node) {
+  if (!func.name.escapedText) {
+    return;
+  }
+
+  const args = func.parameters
+                   .map(p => {
+                     let text = p.name.escapedText;
+                     if (p.questionToken) {
+                       text = '?' + text;
+                     }
+                     if (p.dotDotDotToken) {
+                       text = '...' + text;
+                     }
+                     return text;
+                   })
+                   .filter(x => x !== 'this');
+  storeMethod(node.name.text, func.name.escapedText, args);
+}
+
+/**
+ * @param {WebIDL2.IDLRootType} thing
+ * */
+export function walkRoot(thing) {
+  switch (thing.type) {
+    case 'interface':
+      walkInterface(thing);
+      break;
+    case 'interface mixin':
+    case 'namespace':
+      walkMembers(thing);
+      break;
+  }
+}
+
+/**
+ * @param {WebIDL2.InterfaceType} thing
+ * */
+function walkInterface(thing) {
+  thing.members.forEach(member => {
+    switch (member.type) {
+      case 'constructor':
+        storeMethod('Window', thing.name, member.arguments.map(argName));
+        break;
+      case 'operation':
+        handleOperation(member);
+    }
+  });
+  const namedConstructor = thing.extAttrs.find(extAttr => extAttr.name === 'NamedConstructor');
+  if (namedConstructor && namedConstructor.arguments) {
+    storeMethod('Window', namedConstructor.rhs.value, namedConstructor.arguments.map(argName));
+  }
+}
+
+/**
+ * @param {WebIDL2.NamespaceType | WebIDL2.InterfaceMixinType} thing
+ * */
+function walkMembers(thing) {
+  thing.members.forEach(member => {
+    if (member.type === 'operation') {
+      handleOperation(member);
+    }
+  });
+}
+
+/**
+ * @param {WebIDL2.OperationMemberType} member
+ * */
+function handleOperation(member) {
+  storeMethod(
+      member.special === 'static' ? (parent.name + 'Constructor') : member.parent.name, member.name,
+      member.arguments.map(argName));
+}
+
+/**
+ * @param {WebIDL2.Argument} a
+ * */
+function argName(a) {
+  let name = a.name;
+  if (a.optional) {
+    name = '?' + name;
+  }
+  if (a.variadic) {
+    name = '...' + name;
+  }
+  return name;
+}
+
+/**
+ * @param {string} parent
+ * @param {string} name
+ * @param {Array<string>} args
+ * */
+function storeMethod(parent, name, args) {
+  if (!methods.has(name)) {
+    methods.set(name, new Map());
+  }
+  const method = methods.get(name);
+  if (!method.has(parent)) {
+    method.set(parent, []);
+  }
+  method.get(parent).push(args);
+}
+
+export function postProcess(dryRun = false) {
+  for (const name of methods.keys()) {
+    // We use the set jsonParents to track the set of different signatures across parent for this function name.
+    // If all signatures are identical, we leave out the parent and emit a single NativeFunction entry without receiver.
+    const jsonParents = new Set();
+    for (const [parent, signatures] of methods.get(name)) {
+      signatures.sort((a, b) => a.length - b.length);
+      const filteredSignatures = [];
+      for (const signature of signatures) {
+        const smallerIndex = filteredSignatures.findIndex(smaller => startsTheSame(smaller, signature));
+        if (smallerIndex !== -1) {
+          filteredSignatures[smallerIndex] = (signature.map((arg, index) => {
+            const otherArg = filteredSignatures[smallerIndex][index];
+            if (otherArg) {
+              return otherArg.length > arg.length ? otherArg : arg;
+            }
+            if (arg.startsWith('?') || arg.startsWith('...')) {
+              return arg;
+            }
+            return '?' + arg;
+          }));
+        } else {
+          filteredSignatures.push(signature);
+        }
+      }
+
+      function startsTheSame(smaller, bigger) {
+        for (let i = 0; i < smaller.length; i++) {
+          const withoutQuestion = str => /[\?]?(.*)/.exec(str)[1];
+          if (withoutQuestion(smaller[i]) !== withoutQuestion(bigger[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+
+      methods.get(name).set(parent, filteredSignatures);
+      jsonParents.add(JSON.stringify(filteredSignatures));
+    }
+    // If all parents had the same signature for this name, we put a `*` as parent for this entry.
+    if (jsonParents.size === 1) {
+      methods.set(name, new Map([['*', JSON.parse(jsonParents.values().next().value)]]));
+    }
+    for (const [parent, signatures] of methods.get(name)) {
+      if (signatures.length === 1 && !signatures[0].length) {
+        methods.get(name).delete(parent);
+      }
+    }
+    if (methods.get(name).size === 0) {
+      methods.delete(name);
+    }
+  }
+  const functions = [];
+  for (const [name, method] of methods) {
+    if (method.has('*')) {
+      // All parents had the same signature so we emit an entry without receiver.
+      functions.push({name, signatures: method.get('*')});
+    } else {
+      for (const [parent, signatures] of method) {
+        if (parent.endsWith('Constructor')) {
+          functions.push(
+              {name, signatures, static: true, receiver: parent.substring(0, parent.length - 'Constructor'.length)});
+        } else {
+          functions.push({name, signatures, receiver: parent});
+        }
+      }
+    }
+  }
+  const output = `export const NativeFunctions = [\n${
+      functions
+          .map(
+              entry =>
+                  `  {\n${Object.entries(entry).map(kv => `    ${kv[0]}: ${JSON.stringify(kv[1])}`).join(',\n')}\n  }`)
+          .join(',\n')}\n];`;
+
+  if (dryRun) {
+    return output;
+  }
+
+  fs.writeFileSync(
+      (new URL('../../front_end/models/javascript_metadata/NativeFunctions.js', import.meta.url)).pathname,
+      `// 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.
+// Generated from ${
+          path.relative(path.join(fileURLToPath(import.meta.url), '..', '..'), fileURLToPath(import.meta.url))}
+
+${output}
+`);
+}

package/scripts/javascript_natives/index.js

@@ -2,19 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-const WebIDL2 = require('webidl2');
-const fs = require('fs');
-const path = require('path');
-const ts = require('typescript');
-const glob = require('glob');
-const methods = {
-  __proto__: null
-};
+import * as fs from 'fs';
+import glob from 'glob';
+import * as path from 'path';
+import ts from 'typescript';
+import * as WebIDL2 from 'webidl2';
+
+import {parseTSFunction, postProcess, walkRoot} from './helpers.js';
+
 const program = ts.createProgram(
     [
-      path.join(__dirname, 'node_modules', 'typescript', 'lib', 'lib.esnext.d.ts'),
+      new URL('node_modules/typescript/lib/lib.esnext.d.ts', import.meta.url).pathname,
     ],
-    {noLib: true});
+    {noLib: false, types: []});
+
 for (const file of program.getSourceFiles()) {
   ts.forEachChild(file, node => {
     if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
@@ -31,201 +32,63 @@ for (const file of program.getSourceFiles()) {
   });
 }
 
-function parseTSFunction(func, node) {
-  if (!func.name.escapedText) {
-    return;
-  }
-
-  const args = func.parameters
-                   .map(p => {
-                     let text = p.name.escapedText;
-                     if (p.questionToken) {
-                       text = '?' + text;
-                     }
-                     if (p.dotDotDotToken) {
-                       text = '...' + text;
-                     }
-                     return text;
-                   })
-                   .filter(x => x !== 'this');
-  storeMethod(node.name.text, func.name.escapedText, args);
-}
-
 // Assume the DevTools front-end repository is at
 // `devtools/devtools-frontend`, where `devtools` is on the same level
 // as `chromium`. This matches `scripts/npm_test.js`.
-glob(
-    '../../../../chromium/src/third_party/blink/renderer/+(core|modules)/**/*.idl', {cwd: process.env.PWD},
-    function(er, files) {
-      for (const file of files) {
-        if (file.includes('testing')) {
-          continue;
-        }
-        const data = fs.readFileSync(path.join(process.env.PWD, file), 'utf8');
-        const lines = data.split('\n');
-        const newLines = [];
-        for (const line of lines) {
-          if (!line.includes(' attribute ')) {
-            newLines.push(line);
-          }
-        }
+const files =
+    glob.sync('../../../../chromium/src/third_party/blink/renderer/+(core|modules)/**/*.idl', {cwd: process.env.PWD});
 
-        try {
-          WebIDL2.parse(newLines.join('\n')).forEach(walk);
-        } catch (e) {
-          // console.error(file);
-        }
-      }
-      WebIDL2
-          .parse(`
-  namespace console {
-    void assert(optional boolean condition = false, any... data);
-    void clear();
-    void count(optional DOMString label = "default");
-    void debug(any... data);
-    void dir(any item, optional object? options);
-    void dirxml(any... data);
-    void error(any... data);
-    void group(any... data);
-    void groupCollapsed(any... data);
-    void groupEnd();
-    void info(any... data);
-    void log(any... data);
-    void profile(optional DOMString title);
-    void profileEnd(optional DOMString title);
-    void table(any... tabularData);
-    void time(optional DOMString label);
-    void timeEnd(optional DOMString label);
-    void timeStamp(optional DOMString name);
-    void trace(any... data);
-    void warn(any... data);
-  };
-`).forEach(walk);
-      postProcess();
-    });
-
-function walk(thing, parent) {
-  if (thing.type === 'interface') {
-    const constructor = thing.extAttrs.find(extAttr => extAttr.name === 'Constructor');
-    if (constructor && constructor.arguments && thing.extAttrs.find(extAttr => extAttr.name === 'Exposed')) {
-      storeMethod('Window', thing.name, constructor.arguments.map(argName));
-    }
-
-    const namedConstructor = thing.extAttrs.find(extAttr => extAttr.name === 'NamedConstructor');
-    if (namedConstructor && namedConstructor.arguments) {
-      storeMethod('Window', namedConstructor.rhs.value, namedConstructor.arguments.map(argName));
-    }
+for (const file of files) {
+  if (file.includes('testing')) {
+    continue;
   }
-  if (thing.type.includes('operation')) {
-    storeMethod(thing.static ? (parent.name + 'Constructor') : parent.name, thing.name, thing.arguments.map(argName));
-    return;
-  }
-  if (thing.members) {
-    for (const member of thing.members) {
-      walk(member, thing);
+  const data = fs.readFileSync(path.join(process.env.PWD, file), 'utf8');
+  const lines = data.split('\n');
+  const newLines = [];
+  for (const line of lines) {
+    if (!line.includes(' attribute ')) {
+      newLines.push(line);
     }
   }
-}
-
-function argName(a) {
-  let name = a.name;
-  if (a.optional) {
-    name = '?' + name;
-  }
-  if (a.variadic) {
-    name = '...' + name;
-  }
-  return name;
-}
 
-function storeMethod(parent, name, args) {
-  if (!methods[name]) {
-    methods[name] = {__proto__: null};
-  }
-  if (!methods[name][parent]) {
-    methods[name][parent] = [];
+  try {
+    WebIDL2.parse(newLines.join('\n')).forEach(walkRoot);
+  } catch (e) {
+    // console.error(file);
   }
-  methods[name][parent].push(args);
-}
 
-function postProcess() {
-  for (const name in methods) {
-    const jsonParents = new Set();
-    for (const parent in methods[name]) {
-      const signatures = methods[name][parent];
-      signatures.sort((a, b) => a.length - b.length);
-      const filteredSignatures = [];
-      for (const signature of signatures) {
-        const smallerIndex = filteredSignatures.findIndex(smaller => startsThesame(smaller, signature));
-        if (smallerIndex !== -1) {
-          filteredSignatures[smallerIndex] = (signature.map((arg, index) => {
-            const otherArg = filteredSignatures[smallerIndex][index];
-            if (otherArg) {
-              return otherArg.length > arg.length ? otherArg : arg;
-            }
-            if (arg.startsWith('?') || arg.startsWith('...')) {
-              return arg;
-            }
-            return '?' + arg;
-          }));
-        } else {
-          filteredSignatures.push(signature);
-        }
-      }
+  // Source for Console spec: https://console.spec.whatwg.org/#idl-index
+  WebIDL2
+      .parse(`
+[Exposed=(Window,Worker,Worklet)]
+namespace console { // but see namespace object requirements below
+  // Logging
+  undefined assert(optional boolean condition = false, any... data);
+  undefined clear();
+  undefined debug(any... data);
+  undefined error(any... data);
+  undefined info(any... data);
+  undefined log(any... data);
+  undefined table(optional any tabularData, optional sequence<DOMString> properties);
+  undefined trace(any... data);
+  undefined warn(any... data);
+  undefined dir(optional any item, optional object? options);
+  undefined dirxml(any... data);
 
-      function startsThesame(smaller, bigger) {
-        for (let i = 0; i < smaller.length; i++) {
-          const withoutQuestion = str => /[\?]?(.*)/.exec(str)[1];
-          if (withoutQuestion(smaller[i]) !== withoutQuestion(bigger[i])) {
-            return false;
-          }
-        }
-        return true;
-      }
+  // Counting
+  undefined count(optional DOMString label = "default");
+  undefined countReset(optional DOMString label = "default");
 
-      methods[name][parent] = filteredSignatures;
-      jsonParents.add(JSON.stringify(filteredSignatures));
-    }
-    if (jsonParents.size === 1) {
-      methods[name] = {'*': JSON.parse(jsonParents.values().next().value)};
-    }
-    for (const parent in methods[name]) {
-      const signatures = methods[name][parent];
-      if (signatures.length === 1 && !signatures[0].length) {
-        delete methods[name][parent];
-      }
-    }
-    if (!Object.keys(methods[name]).length) {
-      delete methods[name];
-    }
-  }
-  const functions = [];
-  for (const name in methods) {
-    if (methods[name]['*']) {
-      functions.push({name, signatures: methods[name]['*']});
-    } else {
-      for (const parent in methods[name]) {
-        if (parent.endsWith('Constructor')) {
-          functions.push({
-            name,
-            signatures: methods[name][parent],
-            static: true,
-            receiver: parent.substring(0, parent.length - 'Constructor'.length)
-          });
-        } else {
-          functions.push({name, signatures: methods[name][parent], receiver: parent});
-        }
-      }
-    }
-  }
+  // Grouping
+  undefined group(any... data);
+  undefined groupCollapsed(any... data);
+  undefined groupEnd();
 
-  fs.writeFileSync(
-      path.join(__dirname, '..', '..', 'front_end', 'models', 'javascript_metadata', 'NativeFunctions.js'),
-      `// 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.
-// Generated from ${path.relative(path.join(__dirname, '..', '..'), __filename)}
-
-export const NativeFunctions = ${JSON.stringify(functions, null, 2)};
-`);
+  // Timing
+  undefined time(optional DOMString label = "default");
+  undefined timeLog(optional DOMString label = "default", any... data);
+  undefined timeEnd(optional DOMString label = "default");
+};
+`).forEach(walkRoot);
 }
+postProcess();

package/scripts/javascript_natives/package.json

@@ -1,11 +1,16 @@
 {
+  "private": true,
   "main": "index.js",
   "scripts": {
-    "start": "node index.js"
+    "start": "node index.js",
+    "test": "mocha tests.js"
   },
+  "type": "module",
   "dependencies": {
+    "@types/webidl2": "^23.13.6",
     "glob": "^7.1.2",
-    "typescript": "^2.8.3",
-    "webidl2": "^10.3.3"
+    "mocha": "^9.1.4",
+    "typescript": "latest",
+    "webidl2": "^24.2.0"
   }
 }

package/scripts/javascript_natives/test.d.ts

@@ -0,0 +1,9 @@
+interface Array<T> {
+  at(index: number): T|undefined;
+  diffSig(oneSig: number): T|undefined;
+}
+
+interface ReadonlyArray<T> {
+  at(index: number): T|undefined;
+  diffSig(twoSig: number): T|undefined;
+}