reffy 8.0.0 → 8.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reffy",
-  "version": "8.0.0",
+  "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"
@@ -42,8 +42,8 @@
   "devDependencies": {
     "chai": "4.3.6",
     "mocha": "10.0.0",
-    "nock": "13.2.8",
-    "respec": "32.1.10",
+    "nock": "13.2.9",
+    "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/browserlib/extract-cssdfn.mjs

@@ -257,10 +257,22 @@ const extractValueSpaces = doc => {
         // https://drafts.csswg.org/css-easing-2/#typedef-step-easing-function
         const prod = text.split(reSplitRules)
             .find(p => p.trim().startsWith(dfn.textContent.trim()));
-        if (!prod) {
-          throw new Error(`Production rule for ${dfn.textContent.trim()} found has unexpected format`);
+        if (prod) {
+          parseProductionRule(prod, { pureSyntax: true });
+        }
+        else {
+          // "=" may appear in another formula in the body of the text, as in:
+          // https://drafts.csswg.org/css-speech-1/#typedef-voice-volume-decibel
+          // It may be worth checking but not an error per se.
+          console.warn('[reffy]', `Found "=" next to definition of ${dfn.textContent.trim()} but no production rule. Did I miss something?`);
+          const name = (dfn.getAttribute('data-lt') ?? dfn.textContent)
+            .trim().replace(/^<?(.*?)>?$/, '<$1>');
+          if (!(name in res)) {
+            res[name] = {
+              prose: parent.textContent.trim().replace(/\s+/g, ' ')
+            };
+          }
         }
-        parseProductionRule(prod, { pureSyntax: true });
       }
       else if (dfn.textContent.trim().match(/^[a-zA-Z_][a-zA-Z0-9_\-]+\([^\)]+\)$/)) {
         // Definition is "prod(foo bar)", create a "prod() = prod(foo bar)" entry

package/src/lib/util.js

@@ -816,7 +816,7 @@ async function expandSpecResult(spec, baseFolder, properties) {
             // Also drop header that may have been added when extract was
             // serialized.
             if (contents.startsWith('// GENERATED CONTENT - DO NOT EDIT')) {
-                const hasWindowsEndings = contents.indexOf('\r\n');
+                const hasWindowsEndings = contents.includes('\r\n\r\n');
                 if (hasWindowsEndings) {
                     const endOfHeader = contents.indexOf('\r\n\r\n');
                     contents = contents.substring(endOfHeader + 4)
@@ -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
@@ -55,11 +54,13 @@ module.exports = {
       .map(event => {
         const err = extendEvent(event, events);
         if (err) {
+          // Event could not be extended, let's keep extension event
           console.warn(err);
-          return event;
+          return null;
         }
         else {
-          return null;
+          // Event successfully extended, extension can be dropped
+          return event;
         }
       })
       .filter(event => !!event);
@@ -67,6 +68,7 @@ module.exports = {
     return events
       .filter(event => !eventsToDrop.includes(event))
       .map(event => {
+        cleanTargetInterfaces(event, parsedInterfaces);
         delete event.spec;
         return event;
       });
@@ -133,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;
+        });
+    });
 }