reffy 20.0.13 → 20.0.14

package/src/lib/throttled-queue.js

@@ -1,129 +1,129 @@
-/**
- * Helper function to sleep for a specified number of milliseconds
- */
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms, 'slept'));
-}
-
-
-/**
- * Helper function that returns the "origin" of a URL, defined in a loose way
- * as the part of the true origin that identifies the server that's going to
- * serve the resource.
- *
- * For example "github.io" for all specs under github.io, "whatwg.org" for
- * all WHATWG specs, "csswg.org" for CSS specs at large (including Houdini
- * and FXTF specs since they are served by the same server).
- */
-function getOrigin(url) {
-    if (!url) {
-        return '';
-    }
-    const origin = (new URL(url)).origin;
-    if (origin.endsWith('.whatwg.org')) {
-        return 'https://whatwg.org';
-    }
-    else if (origin.endsWith('.github.io')) {
-        return 'https://github.io';
-    }
-    else if (origin.endsWith('.csswg.org') ||
-             origin.endsWith('.css-houdini.org') ||
-             origin.endsWith('.fxtf.org')) {
-        return 'https://csswg.org';
-    }
-    else {
-        return origin;
-    }
-}
-
-
-/**
- * The ThrottledQueue class can be used to run a series of tasks that send
- * network requests to an origin server in parallel, up to a certain limit,
- * while guaranteeing that only one request will be sent to a given origin
- * server at a time.
- */
-export default class ThrottledQueue {
-  originQueue = {};
-  maxParallel = 4;
-  sleepInterval = 2000;
-  ongoing = 0;
-  pending = [];
-
-  constructor(options = { maxParallel: 4, sleepInterval: 2000 }) {
-    if (options.maxParallel >= 0) {
-      this.maxParallel = options.maxParallel;
-    }
-    if (options.sleepInterval) {
-      this.sleepInterval = options.sleepInterval;
-    }
-  }
-
-  /**
-   * Run the given processing function with the given parameters, immediately
-   * if possible or as soon as possible when too many tasks are already running
-   * in parallel.
-   *
-   * Note this function has no notion of origin. Users may call the function
-   * directly if they don't need any throttling per origin.
-   */
-  async runThrottled(processFunction, ...params) {
-    if (this.ongoing >= this.maxParallel) {
-      return new Promise((resolve, reject) => {
-        this.pending.push({ params, resolve, reject });
-      });
-    }
-    else {
-      this.ongoing += 1;
-      const result = await processFunction.call(null, ...params);
-      this.ongoing -= 1;
-
-      // Done with current task, trigger next pending task in the background
-      setTimeout(_ => {
-        if (this.pending.length && this.ongoing < this.maxParallel) {
-          const next = this.pending.shift();
-          this.runThrottled(processFunction, ...next.params)
-            .then(result => next.resolve(result))
-            .catch(err => next.reject(err));
-        }
-      }, 0);
-
-      return result;
-    }
-  }
-
-  /**
-   * Run the given processing function with the given parameters, immediately
-   * if possible or as soon as possible when too many tasks are already running
-   * in parallel, or when there's already a task being run against the same
-   * origin as that of the provided URL.
-   *
-   * Said differently, the function serializes tasks per origin, and calls
-   * "runThrottled" to restrict the number of tasks that run in parallel to the
-   * requested maximum.
-   *
-   * Additionally, the function forces a 2 second sleep after processing to
-   * keep a low network profile (sleeping time can be adjusted per origin
-   * depending if the sleepInterval parameter that was passed to the
-   * constructor is a function.
-   */
-  async runThrottledPerOrigin(url, processFunction, ...params) {
-    const origin = getOrigin(url);
-    if (!this.originQueue[origin]) {
-      this.originQueue[origin] = Promise.resolve(true);
-    }
-    return new Promise((resolve, reject) => {
-      this.originQueue[origin] = this.originQueue[origin]
-        .then(async _ => this.runThrottled(processFunction, ...params))
-        .then(async result => {
-          const interval = (typeof this.sleepInterval === 'function') ?
-            this.sleepInterval(origin) :
-            this.sleepInterval;
-          await sleep(interval);
-          return result;
-        })
-        .then(resolve)
-        .catch(reject);
-    });
-  }
-}
+/**
+ * Helper function to sleep for a specified number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms, 'slept'));
+}
+
+
+/**
+ * Helper function that returns the "origin" of a URL, defined in a loose way
+ * as the part of the true origin that identifies the server that's going to
+ * serve the resource.
+ *
+ * For example "github.io" for all specs under github.io, "whatwg.org" for
+ * all WHATWG specs, "csswg.org" for CSS specs at large (including Houdini
+ * and FXTF specs since they are served by the same server).
+ */
+function getOrigin(url) {
+    if (!url) {
+        return '';
+    }
+    const origin = (new URL(url)).origin;
+    if (origin.endsWith('.whatwg.org')) {
+        return 'https://whatwg.org';
+    }
+    else if (origin.endsWith('.github.io')) {
+        return 'https://github.io';
+    }
+    else if (origin.endsWith('.csswg.org') ||
+             origin.endsWith('.css-houdini.org') ||
+             origin.endsWith('.fxtf.org')) {
+        return 'https://csswg.org';
+    }
+    else {
+        return origin;
+    }
+}
+
+
+/**
+ * The ThrottledQueue class can be used to run a series of tasks that send
+ * network requests to an origin server in parallel, up to a certain limit,
+ * while guaranteeing that only one request will be sent to a given origin
+ * server at a time.
+ */
+export default class ThrottledQueue {
+  originQueue = {};
+  maxParallel = 4;
+  sleepInterval = 2000;
+  ongoing = 0;
+  pending = [];
+
+  constructor(options = { maxParallel: 4, sleepInterval: 2000 }) {
+    if (options.maxParallel >= 0) {
+      this.maxParallel = options.maxParallel;
+    }
+    if (options.sleepInterval) {
+      this.sleepInterval = options.sleepInterval;
+    }
+  }
+
+  /**
+   * Run the given processing function with the given parameters, immediately
+   * if possible or as soon as possible when too many tasks are already running
+   * in parallel.
+   *
+   * Note this function has no notion of origin. Users may call the function
+   * directly if they don't need any throttling per origin.
+   */
+  async runThrottled(processFunction, ...params) {
+    if (this.ongoing >= this.maxParallel) {
+      return new Promise((resolve, reject) => {
+        this.pending.push({ params, resolve, reject });
+      });
+    }
+    else {
+      this.ongoing += 1;
+      const result = await processFunction.call(null, ...params);
+      this.ongoing -= 1;
+
+      // Done with current task, trigger next pending task in the background
+      setTimeout(_ => {
+        if (this.pending.length && this.ongoing < this.maxParallel) {
+          const next = this.pending.shift();
+          this.runThrottled(processFunction, ...next.params)
+            .then(result => next.resolve(result))
+            .catch(err => next.reject(err));
+        }
+      }, 0);
+
+      return result;
+    }
+  }
+
+  /**
+   * Run the given processing function with the given parameters, immediately
+   * if possible or as soon as possible when too many tasks are already running
+   * in parallel, or when there's already a task being run against the same
+   * origin as that of the provided URL.
+   *
+   * Said differently, the function serializes tasks per origin, and calls
+   * "runThrottled" to restrict the number of tasks that run in parallel to the
+   * requested maximum.
+   *
+   * Additionally, the function forces a 2 second sleep after processing to
+   * keep a low network profile (sleeping time can be adjusted per origin
+   * depending if the sleepInterval parameter that was passed to the
+   * constructor is a function.
+   */
+  async runThrottledPerOrigin(url, processFunction, ...params) {
+    const origin = getOrigin(url);
+    if (!this.originQueue[origin]) {
+      this.originQueue[origin] = Promise.resolve(true);
+    }
+    return new Promise((resolve, reject) => {
+      this.originQueue[origin] = this.originQueue[origin]
+        .then(async _ => this.runThrottled(processFunction, ...params))
+        .then(async result => {
+          const interval = (typeof this.sleepInterval === 'function') ?
+            this.sleepInterval(origin) :
+            this.sleepInterval;
+          await sleep(interval);
+          return result;
+        })
+        .then(resolve)
+        .catch(reject);
+    });
+  }
+}

package/src/postprocessing/annotate-links.js

@@ -1,41 +1,41 @@
-/**
- * Post-processing module that annotates links extracts with the spec
-   shortname they link to
- */
-
-function canonicalizeUrl(url) {
-    return url.replace(/^http:/, 'https:')
-            .split('#')[0]
-            .replace('index.html', '')
-            .replace('Overview.html', '')
-            .replace('cover.html', '')
-            .replace(/spec.whatwg.org\/.*/, 'spec.whatwg.org/')  // subpage to main document in whatwg
-            .replace(/w3.org\/TR\/(([^\/]+\/)+)[^\/]+\.[^\/]+$/, 'w3.org/TR/$1') // subpage to main document in w3c
-            .replace(/w3.org\/TR\/([^\/]+)$/, 'w3.org/TR/$1/') // enforce trailing slash
-            .replace(/w3c.github.io\/([^\/]+)$/, 'w3c.github.io/$1/') // enforce trailing slash for ED on GitHub
-        ;
-}
-
-const needsSaving = {};
-
-export default {
-  dependsOn: ['links'],
-  input: 'spec',
-
-  run: function(spec, {speclist}) {
-    if (!speclist || !speclist.length) {
-      console.error("No spec list passed as input, cannot annotate links in post-processing");
-      return spec;
-    }
-    for (let link in (spec.links || {})) {
-      // Annotate with the spec to which the page belong if we can find one
-      const specUrl = canonicalizeUrl(link);
-      let matchingSpec = speclist.find(s => s?.release?.url === specUrl || s?.nightly?.url === specUrl || (s?.series?.currentSpecification === s?.shortname && (s?.series?.nightlyUrl === specUrl || s?.series?.releaseUrl === specUrl)) || s?.nightly?.pages?.includes(specUrl) || s?.release?.pages?.includes(specUrl));
-      if (matchingSpec) {
-        spec.links[link].specShortname = matchingSpec.shortname;
-      }
-    }
-    return spec;
-  }
-};
-
+/**
+ * Post-processing module that annotates links extracts with the spec
+   shortname they link to
+ */
+
+function canonicalizeUrl(url) {
+    return url.replace(/^http:/, 'https:')
+            .split('#')[0]
+            .replace('index.html', '')
+            .replace('Overview.html', '')
+            .replace('cover.html', '')
+            .replace(/spec.whatwg.org\/.*/, 'spec.whatwg.org/')  // subpage to main document in whatwg
+            .replace(/w3.org\/TR\/(([^\/]+\/)+)[^\/]+\.[^\/]+$/, 'w3.org/TR/$1') // subpage to main document in w3c
+            .replace(/w3.org\/TR\/([^\/]+)$/, 'w3.org/TR/$1/') // enforce trailing slash
+            .replace(/w3c.github.io\/([^\/]+)$/, 'w3c.github.io/$1/') // enforce trailing slash for ED on GitHub
+        ;
+}
+
+const needsSaving = {};
+
+export default {
+  dependsOn: ['links'],
+  input: 'spec',
+
+  run: function(spec, {speclist}) {
+    if (!speclist || !speclist.length) {
+      console.error("No spec list passed as input, cannot annotate links in post-processing");
+      return spec;
+    }
+    for (let link in (spec.links || {})) {
+      // Annotate with the spec to which the page belong if we can find one
+      const specUrl = canonicalizeUrl(link);
+      let matchingSpec = speclist.find(s => s?.release?.url === specUrl || s?.nightly?.url === specUrl || (s?.series?.currentSpecification === s?.shortname && (s?.series?.nightlyUrl === specUrl || s?.series?.releaseUrl === specUrl)) || s?.nightly?.pages?.includes(specUrl) || s?.release?.pages?.includes(specUrl));
+      if (matchingSpec) {
+        spec.links[link].specShortname = matchingSpec.shortname;
+      }
+    }
+    return spec;
+  }
+};
+

package/src/postprocessing/csscomplete.js

@@ -1,48 +1,48 @@
-/**
- * Post-processing module that adds CSS property definitions found in prose
- * from the dfns extract, clean up property definitions that should never have
- * been extracted, and adds the generated IDL attribute names in a
- * styleDeclaration sub-property.
- *
- * Module runs at the spec level. It does not create a distinct property but
- * rather completes the `css` property with additional info.
- */
-
-import { getGeneratedIDLNamesByCSSProperty } from '../lib/util.js';
-
-export default {
-  dependsOn: ['css', 'dfns'],
-  input: 'spec',
-
-  run: async function(spec, options) {
-    if (spec.dfns && spec.css) {
-      spec.dfns
-        .filter(dfn => dfn.type == "property" && !dfn.informative)
-        .forEach(propDfn => {
-          propDfn.linkingText.forEach(lt => {
-            if (!spec.css.properties.find(p => p.name === lt)) {
-              spec.css.properties.push({
-                name: lt,
-                href: propDfn.href
-              });
-            }
-          });
-        });
-    }
-
-    if (spec.css) {
-      // Add generated IDL attribute names
-      spec.css.properties.forEach(dfn => {
-        dfn.styleDeclaration = getGeneratedIDLNamesByCSSProperty(dfn.name);
-      });
-
-      // Drop the sample definition (property-name) in CSS2 and the custom
-      // property definition (--*) in CSS Variables that specs incorrectly flag
-      // as real CSS properties.
-      spec.css.properties = spec.css.properties.filter(p =>
-        !['property-name', '--*'].includes(p.name));
-    }
-
-    return spec;
-  }
-};
+/**
+ * Post-processing module that adds CSS property definitions found in prose
+ * from the dfns extract, clean up property definitions that should never have
+ * been extracted, and adds the generated IDL attribute names in a
+ * styleDeclaration sub-property.
+ *
+ * Module runs at the spec level. It does not create a distinct property but
+ * rather completes the `css` property with additional info.
+ */
+
+import { getGeneratedIDLNamesByCSSProperty } from '../lib/util.js';
+
+export default {
+  dependsOn: ['css', 'dfns'],
+  input: 'spec',
+
+  run: async function(spec, options) {
+    if (spec.dfns && spec.css) {
+      spec.dfns
+        .filter(dfn => dfn.type == "property" && !dfn.informative)
+        .forEach(propDfn => {
+          propDfn.linkingText.forEach(lt => {
+            if (!spec.css.properties.find(p => p.name === lt)) {
+              spec.css.properties.push({
+                name: lt,
+                href: propDfn.href
+              });
+            }
+          });
+        });
+    }
+
+    if (spec.css) {
+      // Add generated IDL attribute names
+      spec.css.properties.forEach(dfn => {
+        dfn.styleDeclaration = getGeneratedIDLNamesByCSSProperty(dfn.name);
+      });
+
+      // Drop the sample definition (property-name) in CSS2 and the custom
+      // property definition (--*) in CSS Variables that specs incorrectly flag
+      // as real CSS properties.
+      spec.css.properties = spec.css.properties.filter(p =>
+        !['property-name', '--*'].includes(p.name));
+    }
+
+    return spec;
+  }
+};