reffy 8.0.2 → 8.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reffy",
-  "version": "8.0.2",
+  "version": "8.0.3",
   "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,7 +34,7 @@
     "abortcontroller-polyfill": "1.7.3",
     "commander": "9.4.0",
     "fetch-filecache-for-crawling": "4.1.0",
-    "puppeteer": "15.4.0",
+    "puppeteer": "15.4.1",
     "semver": "^7.3.5",
     "web-specs": "2.17.0",
     "webidl2": "24.2.2"
@@ -43,7 +43,7 @@
     "chai": "4.3.6",
     "mocha": "10.0.0",
     "nock": "13.2.9",
-    "respec": "32.1.10",
+    "respec": "32.2.0",
     "respec-hljs": "2.1.1",
     "rollup": "2.77.0"
   },

package/reffy.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * The spec crawler takes a list of spec URLs as input, gathers some knowledge
  * about these specs (published versions, URL of the Editor's Draft, etc.),

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;
+        });
+    });
 }