reffy 8.0.2 → 9.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reffy",
-  "version": "8.0.2",
+  "version": "9.0.0",
   "description": "W3C/WHATWG spec dependencies exploration companion. Features a short set of tools to study spec references as well as WebIDL term definitions and references found in W3C specifications.",
   "repository": {
     "type": "git",
@@ -34,18 +34,18 @@
     "abortcontroller-polyfill": "1.7.3",
     "commander": "9.4.0",
     "fetch-filecache-for-crawling": "4.1.0",
-    "puppeteer": "15.4.0",
+    "puppeteer": "16.1.1",
     "semver": "^7.3.5",
-    "web-specs": "2.17.0",
+    "web-specs": "2.19.0",
     "webidl2": "24.2.2"
   },
   "devDependencies": {
     "chai": "4.3.6",
     "mocha": "10.0.0",
     "nock": "13.2.9",
-    "respec": "32.1.10",
+    "respec": "32.2.3",
     "respec-hljs": "2.1.1",
-    "rollup": "2.77.0"
+    "rollup": "2.78.0"
   },
   "scripts": {
     "test": "mocha --recursive tests/"

package/src/browserlib/extract-cssdfn.mjs

@@ -13,15 +13,37 @@ import informativeSelector from './informative-selector.mjs';
 export default function () {
   let res = {
     properties: extractTableDfns(document, 'propdef', { unique: true }),
-    descriptors: extractTableDfns(document, 'descdef', { unique: false }),
+    atrules: {},
     valuespaces: extractValueSpaces(document)
   };
+  let descriptors = extractTableDfns(document, 'descdef', { unique: false });
 
   // Try old recipes if we couldn't extract anything
   if ((Object.keys(res.properties).length === 0) &&
-      (Object.keys(res.descriptors).length === 0)) {
+      (Object.keys(descriptors).length === 0)) {
     res.properties = extractDlDfns(document, 'propdef', { unique: true });
-    res.descriptors = extractDlDfns(document, 'descdef', { unique: false });
+    descriptors = extractDlDfns(document, 'descdef', { unique: false });
+  }
+
+  // Move at-rules definitions from valuespaces to at-rules structure
+  for (const [name, dfn] of Object.entries(res.valuespaces)) {
+    if (name.startsWith('@')) {
+      if (!res.atrules[name]) {
+        res.atrules[name] = Object.assign(dfn, { descriptors: [] });
+      }
+      delete res.valuespaces[name];
+    }
+  }
+
+  // Move descriptors to at-rules structure
+  for (const [name, desclist] of Object.entries(descriptors)) {
+    for (const desc of desclist) {
+      const rule = desc.for;
+      if (!res.atrules[rule]) {
+        res.atrules[rule] = { descriptors: [] };
+      }
+      res.atrules[rule].descriptors.push(desc);
+    }
   }
 
   return res;
@@ -198,6 +220,9 @@ const extractDlDfns = (doc, className, options) =>
  * Definitions with `data-dfn-type` attribute set to `value` are not extracted
  * on purpose as they are typically namespaced to another construct (through a
  * `data-dfn-for` attribute.
+ *
+ * The function also extracts syntax of at-rules (name starts with '@') defined
+ * in "pre.prod" blocks.
  */
 const extractValueSpaces = doc => {
   let res = {};
@@ -213,16 +238,27 @@ const extractValueSpaces = doc => {
       .replace(/\/\*[^]*?\*\//gm, '')  // Drop comments
       .split(/\s?=\s/)
       .map(s => s.trim().replace(/\s+/g, ' '));
-    if (nameAndValue[0].match(/^<.*>$|^.*\(\)$/)) {
-      const name = nameAndValue[0].replace(/^(.*\(\))$/, '<$1>');
+
+    function addValuespace(name, value) {
       if (!(name in res)) {
         res[name] = {};
       }
       if (!res[name].value || (pureSyntax && !res[name].pureSyntax)) {
-        res[name].value = normalize(nameAndValue[1]);
+        res[name].value = normalize(value);
         res[name].pureSyntax = pureSyntax;
       }
     }
+
+    if (nameAndValue[0].match(/^<.*>$|^.*\(\)$/)) {
+      // Regular valuespace
+      addValuespace(
+        nameAndValue[0].replace(/^(.*\(\))$/, '<$1>'),
+        nameAndValue[1]);
+    }
+    else if (nameAndValue[0].match(/^@[a-z\-]+$/)) {
+      // At-rule syntax
+      addValuespace(nameAndValue[0], nameAndValue[1]);
+    }
   };
 
   // Regular expression to use to split production rules:
@@ -351,8 +387,16 @@ const extractValueSpaces = doc => {
     .map(val => val.replace(/\/\*[^]*?\*\//gm, ''))  // Drop comments
     .map(val => val.split(reSplitRules))             // Separate definitions
     .flat()
-    .filter(text => text.match(/\s?=\s/))
-    .map(text => parseProductionRule(text, { pureSyntax: true }));
+    .map(text => text.trim())
+    .map(text => {
+      if (text.match(/\s?=\s/)) {
+        return parseProductionRule(text, { pureSyntax: true });
+      }
+      else if (text.startsWith('@')) {
+        const name = text.split(' ')[0];
+        return parseProductionRule(`${name} = ${text}`, { pureSyntax: true });
+      }
+    });
 
   // Don't keep the info on whether value comes from a pure syntax section
   Object.values(res).map(value => delete value.pureSyntax);

package/src/lib/util.js

@@ -946,9 +946,13 @@ async function createFolderIfNeeded(folder) {
  * the tree.
  */
 const trees = {
-  // DOM tree:
+  // The DOM tree is defined through "get the parent" algorithms:
   // https://dom.spec.whatwg.org/#node-trees
-  'dom': ['Window', 'Document', 'Element', 'Node'],
+  // https://dom.spec.whatwg.org/#get-the-parent
+  // - Node -> Node
+  // - Document -> Window
+  // - ShadowRoot -> Element (both derive from Node, so covered by Node -> Node)
+  'dom': ['Window', 'Document', 'Node'],
 
   // IndexedDB tree (defined through "get the parent" algorithms)
   // https://www.w3.org/TR/IndexedDB/#ref-for-get-the-parent%E2%91%A0

package/src/postprocessing/events.js

@@ -46,7 +46,6 @@ module.exports = {
     for (const event of events) {
       expandMixinTargets(event, mixins);
       setBubblingPerTarget(event, parsedInterfaces);
-      cleanTargetInTrees(event, parsedInterfaces);
     }
 
     // Consolidate events extended in other specs
@@ -69,6 +68,7 @@ module.exports = {
     return events
       .filter(event => !eventsToDrop.includes(event))
       .map(event => {
+        cleanTargetInterfaces(event, parsedInterfaces);
         delete event.spec;
         return event;
       });
@@ -135,41 +135,57 @@ function setBubblingPerTarget(event, parsedInterfaces) {
 }
 
 
-function cleanTargetInTrees(event, parsedInterfaces) {
-  // When several targets are attached to an event that bubbles
-  // keep only the "deepest" target
-  if (event.bubbles && event.targets?.length > 1) {
-    const filteredTargets = deepestInterfaceInTree(event.targets, parsedInterfaces);
-    if (filteredTargets.length !== event.targets.length) {
-      event.targets = filteredTargets;
-      return true;
+/**
+ * Filter the list of target interfaces to remove those that don't need to
+ * appear explicitly because they are de facto already covered by another entry
+ * in the list.
+ *
+ * Two reasons to drop a target interface t from the list:
+ * 1. There exists another target interface o with similar bubbling properties
+ * for the event and t inherits from o. If event fires at o, it can de facto
+ * fire at t.
+ * 2. There exists another target interface o such that t and o belong to the
+ * same bubbling tree, o is at a deeper level than t in the bubbling tree, and
+ * event bubbles when it fires at o. Event will de facto fire at t through
+ * bubbling when that happens.
+ */
+function cleanTargetInterfaces(event, parsedInterfaces) {
+  // Helper function that returns true if the iface interface inherits from the
+  // base interface
+  function inheritsFrom(iface, base) {
+    while (iface) {
+      if (iface === base) {
+        return true;
+      }
+      iface = parsedInterfaces.find(i => i.name === iface)?.inheritance;
     }
+    return false;
   }
-  return false;
-}
-
 
-function deepestInterfaceInTree(targets, parsedInterfaces) {
-  let deepestInTrees = {};
-  let filteredTargets = [];
-  for (let {target, bubbles} of targets) {
-    const treeInfo = getInterfaceTreeInfo(target, parsedInterfaces);
-    if (!treeInfo) { // Not in a tree, we keep it in
-      filteredTargets.push({target});
-      continue;
-    }
-    const { tree, depth } = treeInfo;
-    const currentDeepest = deepestInTrees[tree]?.target;
-    if (currentDeepest) {
-      const { depth: currentDeepestDepth } = getInterfaceTreeInfo(currentDeepest, parsedInterfaces);
-      if (depth > currentDeepestDepth) {
-        deepestInTrees[tree] = {target, bubbles};
-      }
-    } else {
-      deepestInTrees[tree] = {target, bubbles};
-    }
+  if (!event.targets) {
+    return;
   }
-  return filteredTargets.concat(Object.values(deepestInTrees));
+
+  event.targets = event.targets
+    .filter(({ target, bubbles }) =>
+      // Drop if an ancestor in the inheritance chain is already there
+      !event.targets.find(({ target: other, bubbles: otherBubbles}) =>
+        target !== other &&
+        bubbles === otherBubbles &&
+        inheritsFrom(target, other)))
+    .filter(({ target, bubbles }) => {
+      // Drop if a deeper bubbling target interface in the tree is already there
+      const targetTreeInfo = getInterfaceTreeInfo(target, parsedInterfaces);
+      return !targetTreeInfo ||
+        !event.targets.find(({ target: other, bubbles: otherBubbles }) => {
+          if (other === target) {
+            return false;
+          }
+          const otherTreeInfo = getInterfaceTreeInfo(other, parsedInterfaces);
+          return otherTreeInfo?.tree === targetTreeInfo.tree &&
+            otherBubbles && otherTreeInfo.depth > targetTreeInfo.depth;
+        });
+    });
 }